1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2014, Joyent, Inc. All rights reserved. 25 * Copyright 2017 RackTop Systems. 26 */ 27 28 /* 29 * - General Introduction: 30 * 31 * This file contains the implementation of the MAC client kernel 32 * API and related code. The MAC client API allows a kernel module 33 * to gain access to a MAC instance (physical NIC, link aggregation, etc). 34 * It allows a MAC client to associate itself with a MAC address, 35 * VLANs, callback functions for data traffic and for promiscuous mode. 36 * The MAC client API is also used to specify the properties associated 37 * with a MAC client, such as bandwidth limits, priority, CPUS, etc. 38 * These properties are further used to determine the hardware resources 39 * to allocate to the various MAC clients. 40 * 41 * - Primary MAC clients: 42 * 43 * The MAC client API refers to "primary MAC clients". A primary MAC 44 * client is a client which "owns" the primary MAC address of 45 * the underlying MAC instance. The primary MAC address is called out 46 * since it is associated with specific semantics: the primary MAC 47 * address is the MAC address which is assigned to the IP interface 48 * when it is plumbed, and the primary MAC address is assigned 49 * to VLAN data-links. The primary address of a MAC instance can 50 * also change dynamically from under the MAC client, for example 51 * as a result of a change of state of a link aggregation. In that 52 * case the MAC layer automatically updates all data-structures which 53 * refer to the current value of the primary MAC address. Typical 54 * primary MAC clients are dls, aggr, and xnb. A typical non-primary 55 * MAC client is the vnic driver. 56 * 57 * - Virtual Switching: 58 * 59 * The MAC layer implements a virtual switch between the MAC clients 60 * (primary and non-primary) defined on top of the same underlying 61 * NIC (physical, link aggregation, etc). The virtual switch is 62 * VLAN-aware, i.e. it allows multiple MAC clients to be member 63 * of one or more VLANs, and the virtual switch will distribute 64 * multicast tagged packets only to the member of the corresponding 65 * VLANs. 66 * 67 * - Upper vs Lower MAC: 68 * 69 * Creating a VNIC on top of a MAC instance effectively causes 70 * two MAC instances to be layered on top of each other, one for 71 * the VNIC(s), one for the underlying MAC instance (physical NIC, 72 * link aggregation, etc). In the code below we refer to the 73 * underlying NIC as the "lower MAC", and we refer to VNICs as 74 * the "upper MAC". 75 * 76 * - Pass-through for VNICs: 77 * 78 * When VNICs are created on top of an underlying MAC, this causes 79 * a layering of two MAC instances. Since the lower MAC already 80 * does the switching and demultiplexing to its MAC clients, the 81 * upper MAC would simply have to pass packets to the layer below 82 * or above it, which would introduce overhead. In order to avoid 83 * this overhead, the MAC layer implements a pass-through mechanism 84 * for VNICs. When a VNIC opens the lower MAC instance, it saves 85 * the MAC client handle it optains from the MAC layer. When a MAC 86 * client opens a VNIC (upper MAC), the MAC layer detects that 87 * the MAC being opened is a VNIC, and gets the MAC client handle 88 * that the VNIC driver obtained from the lower MAC. This exchange 89 * is done through a private capability between the MAC layer 90 * and the VNIC driver. The upper MAC then returns that handle 91 * directly to its MAC client. Any operation done by the upper 92 * MAC client is now done on the lower MAC client handle, which 93 * allows the VNIC driver to be completely bypassed for the 94 * performance sensitive data-path. 95 * 96 * - Secondary MACs for VNICs: 97 * 98 * VNICs support multiple upper mac clients to enable support for 99 * multiple MAC addresses on the VNIC. When the VNIC is created the 100 * initial mac client is the primary upper mac. Any additional mac 101 * clients are secondary macs. These are kept in sync with the primary 102 * (for things such as the rx function and resource control settings) 103 * using the same private capability interface between the MAC layer 104 * and the VNIC layer. 105 * 106 */ 107 108 #include <sys/types.h> 109 #include <sys/conf.h> 110 #include <sys/id_space.h> 111 #include <sys/esunddi.h> 112 #include <sys/stat.h> 113 #include <sys/mkdev.h> 114 #include <sys/stream.h> 115 #include <sys/strsun.h> 116 #include <sys/strsubr.h> 117 #include <sys/dlpi.h> 118 #include <sys/modhash.h> 119 #include <sys/mac_impl.h> 120 #include <sys/mac_client_impl.h> 121 #include <sys/mac_soft_ring.h> 122 #include <sys/mac_stat.h> 123 #include <sys/dls.h> 124 #include <sys/dld.h> 125 #include <sys/modctl.h> 126 #include <sys/fs/dv_node.h> 127 #include <sys/thread.h> 128 #include <sys/proc.h> 129 #include <sys/callb.h> 130 #include <sys/cpuvar.h> 131 #include <sys/atomic.h> 132 #include <sys/sdt.h> 133 #include <sys/mac_flow.h> 134 #include <sys/ddi_intr_impl.h> 135 #include <sys/disp.h> 136 #include <sys/sdt.h> 137 #include <sys/vnic.h> 138 #include <sys/vnic_impl.h> 139 #include <sys/vlan.h> 140 #include <inet/ip.h> 141 #include <inet/ip6.h> 142 #include <sys/exacct.h> 143 #include <sys/exacct_impl.h> 144 #include <inet/nd.h> 145 #include <sys/ethernet.h> 146 147 kmem_cache_t *mac_client_impl_cache; 148 kmem_cache_t *mac_promisc_impl_cache; 149 150 static boolean_t mac_client_single_rcvr(mac_client_impl_t *); 151 static flow_entry_t *mac_client_swap_mciflent(mac_client_impl_t *); 152 static flow_entry_t *mac_client_get_flow(mac_client_impl_t *, 153 mac_unicast_impl_t *); 154 static void mac_client_remove_flow_from_list(mac_client_impl_t *, 155 flow_entry_t *); 156 static void mac_client_add_to_flow_list(mac_client_impl_t *, flow_entry_t *); 157 static void mac_rename_flow_names(mac_client_impl_t *, const char *); 158 static void mac_virtual_link_update(mac_impl_t *); 159 static int mac_client_datapath_setup(mac_client_impl_t *, uint16_t, 160 uint8_t *, mac_resource_props_t *, boolean_t, mac_unicast_impl_t *); 161 static void mac_client_datapath_teardown(mac_client_handle_t, 162 mac_unicast_impl_t *, flow_entry_t *); 163 static int mac_resource_ctl_set(mac_client_handle_t, mac_resource_props_t *); 164 165 /* ARGSUSED */ 166 static int 167 i_mac_client_impl_ctor(void *buf, void *arg, int kmflag) 168 { 169 int i; 170 mac_client_impl_t *mcip = buf; 171 172 bzero(buf, MAC_CLIENT_IMPL_SIZE); 173 mutex_init(&mcip->mci_tx_cb_lock, NULL, MUTEX_DRIVER, NULL); 174 mcip->mci_tx_notify_cb_info.mcbi_lockp = &mcip->mci_tx_cb_lock; 175 176 ASSERT(mac_tx_percpu_cnt >= 0); 177 for (i = 0; i <= mac_tx_percpu_cnt; i++) { 178 mutex_init(&mcip->mci_tx_pcpu[i].pcpu_tx_lock, NULL, 179 MUTEX_DRIVER, NULL); 180 } 181 cv_init(&mcip->mci_tx_cv, NULL, CV_DRIVER, NULL); 182 183 return (0); 184 } 185 186 /* ARGSUSED */ 187 static void 188 i_mac_client_impl_dtor(void *buf, void *arg) 189 { 190 int i; 191 mac_client_impl_t *mcip = buf; 192 193 ASSERT(mcip->mci_promisc_list == NULL); 194 ASSERT(mcip->mci_unicast_list == NULL); 195 ASSERT(mcip->mci_state_flags == 0); 196 ASSERT(mcip->mci_tx_flag == 0); 197 198 mutex_destroy(&mcip->mci_tx_cb_lock); 199 200 ASSERT(mac_tx_percpu_cnt >= 0); 201 for (i = 0; i <= mac_tx_percpu_cnt; i++) { 202 ASSERT(mcip->mci_tx_pcpu[i].pcpu_tx_refcnt == 0); 203 mutex_destroy(&mcip->mci_tx_pcpu[i].pcpu_tx_lock); 204 } 205 cv_destroy(&mcip->mci_tx_cv); 206 } 207 208 /* ARGSUSED */ 209 static int 210 i_mac_promisc_impl_ctor(void *buf, void *arg, int kmflag) 211 { 212 mac_promisc_impl_t *mpip = buf; 213 214 bzero(buf, sizeof (mac_promisc_impl_t)); 215 mpip->mpi_mci_link.mcb_objp = buf; 216 mpip->mpi_mci_link.mcb_objsize = sizeof (mac_promisc_impl_t); 217 mpip->mpi_mi_link.mcb_objp = buf; 218 mpip->mpi_mi_link.mcb_objsize = sizeof (mac_promisc_impl_t); 219 return (0); 220 } 221 222 /* ARGSUSED */ 223 static void 224 i_mac_promisc_impl_dtor(void *buf, void *arg) 225 { 226 mac_promisc_impl_t *mpip = buf; 227 228 ASSERT(mpip->mpi_mci_link.mcb_objp != NULL); 229 ASSERT(mpip->mpi_mci_link.mcb_objsize == sizeof (mac_promisc_impl_t)); 230 ASSERT(mpip->mpi_mi_link.mcb_objp == mpip->mpi_mci_link.mcb_objp); 231 ASSERT(mpip->mpi_mi_link.mcb_objsize == sizeof (mac_promisc_impl_t)); 232 233 mpip->mpi_mci_link.mcb_objp = NULL; 234 mpip->mpi_mci_link.mcb_objsize = 0; 235 mpip->mpi_mi_link.mcb_objp = NULL; 236 mpip->mpi_mi_link.mcb_objsize = 0; 237 238 ASSERT(mpip->mpi_mci_link.mcb_flags == 0); 239 mpip->mpi_mci_link.mcb_objsize = 0; 240 } 241 242 void 243 mac_client_init(void) 244 { 245 ASSERT(mac_tx_percpu_cnt >= 0); 246 247 mac_client_impl_cache = kmem_cache_create("mac_client_impl_cache", 248 MAC_CLIENT_IMPL_SIZE, 0, i_mac_client_impl_ctor, 249 i_mac_client_impl_dtor, NULL, NULL, NULL, 0); 250 ASSERT(mac_client_impl_cache != NULL); 251 252 mac_promisc_impl_cache = kmem_cache_create("mac_promisc_impl_cache", 253 sizeof (mac_promisc_impl_t), 0, i_mac_promisc_impl_ctor, 254 i_mac_promisc_impl_dtor, NULL, NULL, NULL, 0); 255 ASSERT(mac_promisc_impl_cache != NULL); 256 } 257 258 void 259 mac_client_fini(void) 260 { 261 kmem_cache_destroy(mac_client_impl_cache); 262 kmem_cache_destroy(mac_promisc_impl_cache); 263 } 264 265 /* 266 * Return the lower MAC client handle from the VNIC driver for the 267 * specified VNIC MAC instance. 268 */ 269 mac_client_impl_t * 270 mac_vnic_lower(mac_impl_t *mip) 271 { 272 mac_capab_vnic_t cap; 273 mac_client_impl_t *mcip; 274 275 VERIFY(i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_VNIC, &cap)); 276 mcip = cap.mcv_mac_client_handle(cap.mcv_arg); 277 278 return (mcip); 279 } 280 281 /* 282 * Update the secondary macs 283 */ 284 void 285 mac_vnic_secondary_update(mac_impl_t *mip) 286 { 287 mac_capab_vnic_t cap; 288 289 VERIFY(i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_VNIC, &cap)); 290 cap.mcv_mac_secondary_update(cap.mcv_arg); 291 } 292 293 /* 294 * Return the MAC client handle of the primary MAC client for the 295 * specified MAC instance, or NULL otherwise. 296 */ 297 mac_client_impl_t * 298 mac_primary_client_handle(mac_impl_t *mip) 299 { 300 mac_client_impl_t *mcip; 301 302 if (mip->mi_state_flags & MIS_IS_VNIC) 303 return (mac_vnic_lower(mip)); 304 305 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 306 307 for (mcip = mip->mi_clients_list; mcip != NULL; 308 mcip = mcip->mci_client_next) { 309 if (MCIP_DATAPATH_SETUP(mcip) && mac_is_primary_client(mcip)) 310 return (mcip); 311 } 312 return (NULL); 313 } 314 315 /* 316 * Open a MAC specified by its MAC name. 317 */ 318 int 319 mac_open(const char *macname, mac_handle_t *mhp) 320 { 321 mac_impl_t *mip; 322 int err; 323 324 /* 325 * Look up its entry in the global hash table. 326 */ 327 if ((err = mac_hold(macname, &mip)) != 0) 328 return (err); 329 330 /* 331 * Hold the dip associated to the MAC to prevent it from being 332 * detached. For a softmac, its underlying dip is held by the 333 * mi_open() callback. 334 * 335 * This is done to be more tolerant with some defective drivers, 336 * which incorrectly handle mac_unregister() failure in their 337 * xxx_detach() routine. For example, some drivers ignore the 338 * failure of mac_unregister() and free all resources that 339 * that are needed for data transmition. 340 */ 341 e_ddi_hold_devi(mip->mi_dip); 342 343 if (!(mip->mi_callbacks->mc_callbacks & MC_OPEN)) { 344 *mhp = (mac_handle_t)mip; 345 return (0); 346 } 347 348 /* 349 * The mac perimeter is used in both mac_open and mac_close by the 350 * framework to single thread the MC_OPEN/MC_CLOSE of drivers. 351 */ 352 i_mac_perim_enter(mip); 353 mip->mi_oref++; 354 if (mip->mi_oref != 1 || ((err = mip->mi_open(mip->mi_driver)) == 0)) { 355 *mhp = (mac_handle_t)mip; 356 i_mac_perim_exit(mip); 357 return (0); 358 } 359 mip->mi_oref--; 360 ddi_release_devi(mip->mi_dip); 361 mac_rele(mip); 362 i_mac_perim_exit(mip); 363 return (err); 364 } 365 366 /* 367 * Open a MAC specified by its linkid. 368 */ 369 int 370 mac_open_by_linkid(datalink_id_t linkid, mac_handle_t *mhp) 371 { 372 dls_dl_handle_t dlh; 373 int err; 374 375 if ((err = dls_devnet_hold_tmp(linkid, &dlh)) != 0) 376 return (err); 377 378 dls_devnet_prop_task_wait(dlh); 379 380 err = mac_open(dls_devnet_mac(dlh), mhp); 381 382 dls_devnet_rele_tmp(dlh); 383 return (err); 384 } 385 386 /* 387 * Open a MAC specified by its link name. 388 */ 389 int 390 mac_open_by_linkname(const char *link, mac_handle_t *mhp) 391 { 392 datalink_id_t linkid; 393 int err; 394 395 if ((err = dls_mgmt_get_linkid(link, &linkid)) != 0) 396 return (err); 397 return (mac_open_by_linkid(linkid, mhp)); 398 } 399 400 /* 401 * Close the specified MAC. 402 */ 403 void 404 mac_close(mac_handle_t mh) 405 { 406 mac_impl_t *mip = (mac_impl_t *)mh; 407 408 i_mac_perim_enter(mip); 409 /* 410 * The mac perimeter is used in both mac_open and mac_close by the 411 * framework to single thread the MC_OPEN/MC_CLOSE of drivers. 412 */ 413 if (mip->mi_callbacks->mc_callbacks & MC_OPEN) { 414 ASSERT(mip->mi_oref != 0); 415 if (--mip->mi_oref == 0) { 416 if ((mip->mi_callbacks->mc_callbacks & MC_CLOSE)) 417 mip->mi_close(mip->mi_driver); 418 } 419 } 420 i_mac_perim_exit(mip); 421 ddi_release_devi(mip->mi_dip); 422 mac_rele(mip); 423 } 424 425 /* 426 * Misc utility functions to retrieve various information about a MAC 427 * instance or a MAC client. 428 */ 429 430 const mac_info_t * 431 mac_info(mac_handle_t mh) 432 { 433 return (&((mac_impl_t *)mh)->mi_info); 434 } 435 436 dev_info_t * 437 mac_devinfo_get(mac_handle_t mh) 438 { 439 return (((mac_impl_t *)mh)->mi_dip); 440 } 441 442 void * 443 mac_driver(mac_handle_t mh) 444 { 445 return (((mac_impl_t *)mh)->mi_driver); 446 } 447 448 const char * 449 mac_name(mac_handle_t mh) 450 { 451 return (((mac_impl_t *)mh)->mi_name); 452 } 453 454 int 455 mac_type(mac_handle_t mh) 456 { 457 return (((mac_impl_t *)mh)->mi_type->mt_type); 458 } 459 460 int 461 mac_nativetype(mac_handle_t mh) 462 { 463 return (((mac_impl_t *)mh)->mi_type->mt_nativetype); 464 } 465 466 char * 467 mac_client_name(mac_client_handle_t mch) 468 { 469 return (((mac_client_impl_t *)mch)->mci_name); 470 } 471 472 minor_t 473 mac_minor(mac_handle_t mh) 474 { 475 return (((mac_impl_t *)mh)->mi_minor); 476 } 477 478 /* 479 * Return the VID associated with a MAC client. This function should 480 * be called for clients which are associated with only one VID. 481 */ 482 uint16_t 483 mac_client_vid(mac_client_handle_t mch) 484 { 485 uint16_t vid = VLAN_ID_NONE; 486 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 487 flow_desc_t flow_desc; 488 489 if (mcip->mci_nflents == 0) 490 return (vid); 491 492 ASSERT(MCIP_DATAPATH_SETUP(mcip) && mac_client_single_rcvr(mcip)); 493 494 mac_flow_get_desc(mcip->mci_flent, &flow_desc); 495 if ((flow_desc.fd_mask & FLOW_LINK_VID) != 0) 496 vid = flow_desc.fd_vid; 497 498 return (vid); 499 } 500 501 /* 502 * Return whether the specified MAC client corresponds to a VLAN VNIC. 503 */ 504 boolean_t 505 mac_client_is_vlan_vnic(mac_client_handle_t mch) 506 { 507 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 508 509 return (((mcip->mci_state_flags & MCIS_IS_VNIC) != 0) && 510 ((mcip->mci_flent->fe_type & FLOW_PRIMARY_MAC) != 0)); 511 } 512 513 /* 514 * Return the link speed associated with the specified MAC client. 515 * 516 * The link speed of a MAC client is equal to the smallest value of 517 * 1) the current link speed of the underlying NIC, or 518 * 2) the bandwidth limit set for the MAC client. 519 * 520 * Note that the bandwidth limit can be higher than the speed 521 * of the underlying NIC. This is allowed to avoid spurious 522 * administration action failures or artifically lowering the 523 * bandwidth limit of a link that may have temporarily lowered 524 * its link speed due to hardware problem or administrator action. 525 */ 526 static uint64_t 527 mac_client_ifspeed(mac_client_impl_t *mcip) 528 { 529 mac_impl_t *mip = mcip->mci_mip; 530 uint64_t nic_speed; 531 532 nic_speed = mac_stat_get((mac_handle_t)mip, MAC_STAT_IFSPEED); 533 534 if (nic_speed == 0) { 535 return (0); 536 } else { 537 uint64_t policy_limit = (uint64_t)-1; 538 539 if (MCIP_RESOURCE_PROPS_MASK(mcip) & MRP_MAXBW) 540 policy_limit = MCIP_RESOURCE_PROPS_MAXBW(mcip); 541 542 return (MIN(policy_limit, nic_speed)); 543 } 544 } 545 546 /* 547 * Return the link state of the specified client. If here are more 548 * than one clients of the underying mac_impl_t, the link state 549 * will always be UP regardless of the link state of the underlying 550 * mac_impl_t. This is needed to allow the MAC clients to continue 551 * to communicate with each other even when the physical link of 552 * their mac_impl_t is down. 553 */ 554 static uint64_t 555 mac_client_link_state(mac_client_impl_t *mcip) 556 { 557 mac_impl_t *mip = mcip->mci_mip; 558 uint16_t vid; 559 mac_client_impl_t *mci_list; 560 mac_unicast_impl_t *mui_list, *oth_mui_list; 561 562 /* 563 * Returns LINK_STATE_UP if there are other MAC clients defined on 564 * mac_impl_t which share same VLAN ID as that of mcip. Note that 565 * if 'mcip' has more than one VID's then we match ANY one of the 566 * VID's with other MAC client's VID's and return LINK_STATE_UP. 567 */ 568 rw_enter(&mcip->mci_rw_lock, RW_READER); 569 for (mui_list = mcip->mci_unicast_list; mui_list != NULL; 570 mui_list = mui_list->mui_next) { 571 vid = mui_list->mui_vid; 572 for (mci_list = mip->mi_clients_list; mci_list != NULL; 573 mci_list = mci_list->mci_client_next) { 574 if (mci_list == mcip) 575 continue; 576 for (oth_mui_list = mci_list->mci_unicast_list; 577 oth_mui_list != NULL; oth_mui_list = oth_mui_list-> 578 mui_next) { 579 if (vid == oth_mui_list->mui_vid) { 580 rw_exit(&mcip->mci_rw_lock); 581 return (LINK_STATE_UP); 582 } 583 } 584 } 585 } 586 rw_exit(&mcip->mci_rw_lock); 587 588 return (mac_stat_get((mac_handle_t)mip, MAC_STAT_LINK_STATE)); 589 } 590 591 /* 592 * These statistics are consumed by dladm show-link -s <vnic>, 593 * dladm show-vnic -s and netstat. With the introduction of dlstat, 594 * dladm show-link -s and dladm show-vnic -s witll be EOL'ed while 595 * netstat will consume from kstats introduced for dlstat. This code 596 * will be removed at that time. 597 */ 598 599 /* 600 * Return the statistics of a MAC client. These statistics are different 601 * then the statistics of the underlying MAC which are returned by 602 * mac_stat_get(). 603 * 604 * Note that for things based on the tx and rx stats, mac will end up clobbering 605 * those stats when the underlying set of rings in the srs changes. As such, we 606 * need to source not only the current set, but also the historical set when 607 * returning to the client, lest our counters appear to go backwards. 608 */ 609 uint64_t 610 mac_client_stat_get(mac_client_handle_t mch, uint_t stat) 611 { 612 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 613 mac_impl_t *mip = mcip->mci_mip; 614 flow_entry_t *flent = mcip->mci_flent; 615 mac_soft_ring_set_t *mac_srs; 616 mac_rx_stats_t *mac_rx_stat, *old_rx_stat; 617 mac_tx_stats_t *mac_tx_stat, *old_tx_stat; 618 int i; 619 uint64_t val = 0; 620 621 mac_srs = (mac_soft_ring_set_t *)(flent->fe_tx_srs); 622 mac_tx_stat = &mac_srs->srs_tx.st_stat; 623 old_rx_stat = &mcip->mci_misc_stat.mms_defunctrxlanestats; 624 old_tx_stat = &mcip->mci_misc_stat.mms_defuncttxlanestats; 625 626 switch (stat) { 627 case MAC_STAT_LINK_STATE: 628 val = mac_client_link_state(mcip); 629 break; 630 case MAC_STAT_LINK_UP: 631 val = (mac_client_link_state(mcip) == LINK_STATE_UP); 632 break; 633 case MAC_STAT_PROMISC: 634 val = mac_stat_get((mac_handle_t)mip, MAC_STAT_PROMISC); 635 break; 636 case MAC_STAT_LOWLINK_STATE: 637 val = mac_stat_get((mac_handle_t)mip, MAC_STAT_LOWLINK_STATE); 638 break; 639 case MAC_STAT_IFSPEED: 640 val = mac_client_ifspeed(mcip); 641 break; 642 case MAC_STAT_MULTIRCV: 643 val = mcip->mci_misc_stat.mms_multircv; 644 break; 645 case MAC_STAT_BRDCSTRCV: 646 val = mcip->mci_misc_stat.mms_brdcstrcv; 647 break; 648 case MAC_STAT_MULTIXMT: 649 val = mcip->mci_misc_stat.mms_multixmt; 650 break; 651 case MAC_STAT_BRDCSTXMT: 652 val = mcip->mci_misc_stat.mms_brdcstxmt; 653 break; 654 case MAC_STAT_OBYTES: 655 val = mac_tx_stat->mts_obytes; 656 val += old_tx_stat->mts_obytes; 657 break; 658 case MAC_STAT_OPACKETS: 659 val = mac_tx_stat->mts_opackets; 660 val += old_tx_stat->mts_opackets; 661 break; 662 case MAC_STAT_OERRORS: 663 val = mac_tx_stat->mts_oerrors; 664 val += old_tx_stat->mts_oerrors; 665 break; 666 case MAC_STAT_IPACKETS: 667 for (i = 0; i < flent->fe_rx_srs_cnt; i++) { 668 mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i]; 669 mac_rx_stat = &mac_srs->srs_rx.sr_stat; 670 val += mac_rx_stat->mrs_intrcnt + 671 mac_rx_stat->mrs_pollcnt + mac_rx_stat->mrs_lclcnt; 672 } 673 val += old_rx_stat->mrs_intrcnt + old_rx_stat->mrs_pollcnt + 674 old_rx_stat->mrs_lclcnt; 675 break; 676 case MAC_STAT_RBYTES: 677 for (i = 0; i < flent->fe_rx_srs_cnt; i++) { 678 mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i]; 679 mac_rx_stat = &mac_srs->srs_rx.sr_stat; 680 val += mac_rx_stat->mrs_intrbytes + 681 mac_rx_stat->mrs_pollbytes + 682 mac_rx_stat->mrs_lclbytes; 683 } 684 val += old_rx_stat->mrs_intrbytes + old_rx_stat->mrs_pollbytes + 685 old_rx_stat->mrs_lclbytes; 686 break; 687 case MAC_STAT_IERRORS: 688 for (i = 0; i < flent->fe_rx_srs_cnt; i++) { 689 mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i]; 690 mac_rx_stat = &mac_srs->srs_rx.sr_stat; 691 val += mac_rx_stat->mrs_ierrors; 692 } 693 val += old_rx_stat->mrs_ierrors; 694 break; 695 default: 696 val = mac_driver_stat_default(mip, stat); 697 break; 698 } 699 700 return (val); 701 } 702 703 /* 704 * Return the statistics of the specified MAC instance. 705 */ 706 uint64_t 707 mac_stat_get(mac_handle_t mh, uint_t stat) 708 { 709 mac_impl_t *mip = (mac_impl_t *)mh; 710 uint64_t val; 711 int ret; 712 713 /* 714 * The range of stat determines where it is maintained. Stat 715 * values from 0 up to (but not including) MAC_STAT_MIN are 716 * mainteined by the mac module itself. Everything else is 717 * maintained by the driver. 718 * 719 * If the mac_impl_t being queried corresponds to a VNIC, 720 * the stats need to be queried from the lower MAC client 721 * corresponding to the VNIC. (The mac_link_update() 722 * invoked by the driver to the lower MAC causes the *lower 723 * MAC* to update its mi_linkstate, and send a notification 724 * to its MAC clients. Due to the VNIC passthrough, 725 * these notifications are sent to the upper MAC clients 726 * of the VNIC directly, and the upper mac_impl_t of the VNIC 727 * does not have a valid mi_linkstate. 728 */ 729 if (stat < MAC_STAT_MIN && !(mip->mi_state_flags & MIS_IS_VNIC)) { 730 /* these stats are maintained by the mac module itself */ 731 switch (stat) { 732 case MAC_STAT_LINK_STATE: 733 return (mip->mi_linkstate); 734 case MAC_STAT_LINK_UP: 735 return (mip->mi_linkstate == LINK_STATE_UP); 736 case MAC_STAT_PROMISC: 737 return (mip->mi_devpromisc != 0); 738 case MAC_STAT_LOWLINK_STATE: 739 return (mip->mi_lowlinkstate); 740 default: 741 ASSERT(B_FALSE); 742 } 743 } 744 745 /* 746 * Call the driver to get the given statistic. 747 */ 748 ret = mip->mi_getstat(mip->mi_driver, stat, &val); 749 if (ret != 0) { 750 /* 751 * The driver doesn't support this statistic. Get the 752 * statistic's default value. 753 */ 754 val = mac_driver_stat_default(mip, stat); 755 } 756 return (val); 757 } 758 759 /* 760 * Query hardware rx ring corresponding to the pseudo ring. 761 */ 762 uint64_t 763 mac_pseudo_rx_ring_stat_get(mac_ring_handle_t handle, uint_t stat) 764 { 765 return (mac_rx_ring_stat_get(handle, stat)); 766 } 767 768 /* 769 * Query hardware tx ring corresponding to the pseudo ring. 770 */ 771 uint64_t 772 mac_pseudo_tx_ring_stat_get(mac_ring_handle_t handle, uint_t stat) 773 { 774 return (mac_tx_ring_stat_get(handle, stat)); 775 } 776 777 /* 778 * Utility function which returns the VID associated with a flow entry. 779 */ 780 uint16_t 781 i_mac_flow_vid(flow_entry_t *flent) 782 { 783 flow_desc_t flow_desc; 784 785 mac_flow_get_desc(flent, &flow_desc); 786 787 if ((flow_desc.fd_mask & FLOW_LINK_VID) != 0) 788 return (flow_desc.fd_vid); 789 return (VLAN_ID_NONE); 790 } 791 792 /* 793 * Verify the validity of the specified unicast MAC address. Returns B_TRUE 794 * if the address is valid, B_FALSE otherwise (multicast address, or incorrect 795 * length. 796 */ 797 boolean_t 798 mac_unicst_verify(mac_handle_t mh, const uint8_t *addr, uint_t len) 799 { 800 mac_impl_t *mip = (mac_impl_t *)mh; 801 802 /* 803 * Verify the address. No lock is needed since mi_type and plugin 804 * details don't change after mac_register(). 805 */ 806 if ((len != mip->mi_type->mt_addr_length) || 807 (mip->mi_type->mt_ops.mtops_unicst_verify(addr, 808 mip->mi_pdata)) != 0) { 809 return (B_FALSE); 810 } else { 811 return (B_TRUE); 812 } 813 } 814 815 void 816 mac_sdu_get(mac_handle_t mh, uint_t *min_sdu, uint_t *max_sdu) 817 { 818 mac_impl_t *mip = (mac_impl_t *)mh; 819 820 if (min_sdu != NULL) 821 *min_sdu = mip->mi_sdu_min; 822 if (max_sdu != NULL) 823 *max_sdu = mip->mi_sdu_max; 824 } 825 826 void 827 mac_sdu_get2(mac_handle_t mh, uint_t *min_sdu, uint_t *max_sdu, 828 uint_t *multicast_sdu) 829 { 830 mac_impl_t *mip = (mac_impl_t *)mh; 831 832 if (min_sdu != NULL) 833 *min_sdu = mip->mi_sdu_min; 834 if (max_sdu != NULL) 835 *max_sdu = mip->mi_sdu_max; 836 if (multicast_sdu != NULL) 837 *multicast_sdu = mip->mi_sdu_multicast; 838 } 839 840 /* 841 * Update the MAC unicast address of the specified client's flows. Currently 842 * only one unicast MAC unicast address is allowed per client. 843 */ 844 static void 845 mac_unicast_update_client_flow(mac_client_impl_t *mcip) 846 { 847 mac_impl_t *mip = mcip->mci_mip; 848 flow_entry_t *flent = mcip->mci_flent; 849 mac_address_t *map = mcip->mci_unicast; 850 flow_desc_t flow_desc; 851 852 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 853 ASSERT(flent != NULL); 854 855 mac_flow_get_desc(flent, &flow_desc); 856 ASSERT(flow_desc.fd_mask & FLOW_LINK_DST); 857 858 bcopy(map->ma_addr, flow_desc.fd_dst_mac, map->ma_len); 859 mac_flow_set_desc(flent, &flow_desc); 860 861 /* 862 * The v6 local and SLAAC addrs (used by mac protection) need to be 863 * regenerated because our mac address has changed. 864 */ 865 mac_protect_update_mac_token(mcip); 866 867 /* 868 * A MAC client could have one MAC address but multiple 869 * VLANs. In that case update the flow entries corresponding 870 * to all VLANs of the MAC client. 871 */ 872 for (flent = mcip->mci_flent_list; flent != NULL; 873 flent = flent->fe_client_next) { 874 mac_flow_get_desc(flent, &flow_desc); 875 if (!(flent->fe_type & FLOW_PRIMARY_MAC || 876 flent->fe_type & FLOW_VNIC_MAC)) 877 continue; 878 879 bcopy(map->ma_addr, flow_desc.fd_dst_mac, map->ma_len); 880 mac_flow_set_desc(flent, &flow_desc); 881 } 882 } 883 884 /* 885 * Update all clients that share the same unicast address. 886 */ 887 void 888 mac_unicast_update_clients(mac_impl_t *mip, mac_address_t *map) 889 { 890 mac_client_impl_t *mcip; 891 892 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 893 894 /* 895 * Find all clients that share the same unicast MAC address and update 896 * them appropriately. 897 */ 898 for (mcip = mip->mi_clients_list; mcip != NULL; 899 mcip = mcip->mci_client_next) { 900 /* 901 * Ignore clients that don't share this MAC address. 902 */ 903 if (map != mcip->mci_unicast) 904 continue; 905 906 /* 907 * Update those clients with same old unicast MAC address. 908 */ 909 mac_unicast_update_client_flow(mcip); 910 } 911 } 912 913 /* 914 * Update the unicast MAC address of the specified VNIC MAC client. 915 * 916 * Check whether the operation is valid. Any of following cases should fail: 917 * 918 * 1. It's a VLAN type of VNIC. 919 * 2. The new value is current "primary" MAC address. 920 * 3. The current MAC address is shared with other clients. 921 * 4. The new MAC address has been used. This case will be valid when 922 * client migration is fully supported. 923 */ 924 int 925 mac_vnic_unicast_set(mac_client_handle_t mch, const uint8_t *addr) 926 { 927 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 928 mac_impl_t *mip = mcip->mci_mip; 929 mac_address_t *map = mcip->mci_unicast; 930 int err; 931 932 ASSERT(!(mip->mi_state_flags & MIS_IS_VNIC)); 933 ASSERT(mcip->mci_state_flags & MCIS_IS_VNIC); 934 ASSERT(mcip->mci_flags != MAC_CLIENT_FLAGS_PRIMARY); 935 936 i_mac_perim_enter(mip); 937 938 /* 939 * If this is a VLAN type of VNIC, it's using "primary" MAC address 940 * of the underlying interface. Must fail here. Refer to case 1 above. 941 */ 942 if (bcmp(map->ma_addr, mip->mi_addr, map->ma_len) == 0) { 943 i_mac_perim_exit(mip); 944 return (ENOTSUP); 945 } 946 947 /* 948 * If the new address is the "primary" one, must fail. Refer to 949 * case 2 above. 950 */ 951 if (bcmp(addr, mip->mi_addr, map->ma_len) == 0) { 952 i_mac_perim_exit(mip); 953 return (EACCES); 954 } 955 956 /* 957 * If the address is shared by multiple clients, must fail. Refer 958 * to case 3 above. 959 */ 960 if (mac_check_macaddr_shared(map)) { 961 i_mac_perim_exit(mip); 962 return (EBUSY); 963 } 964 965 /* 966 * If the new address has been used, must fail for now. Refer to 967 * case 4 above. 968 */ 969 if (mac_find_macaddr(mip, (uint8_t *)addr) != NULL) { 970 i_mac_perim_exit(mip); 971 return (ENOTSUP); 972 } 973 974 /* 975 * Update the MAC address. 976 */ 977 err = mac_update_macaddr(map, (uint8_t *)addr); 978 979 if (err != 0) { 980 i_mac_perim_exit(mip); 981 return (err); 982 } 983 984 /* 985 * Update all flows of this MAC client. 986 */ 987 mac_unicast_update_client_flow(mcip); 988 989 i_mac_perim_exit(mip); 990 return (0); 991 } 992 993 /* 994 * Program the new primary unicast address of the specified MAC. 995 * 996 * Function mac_update_macaddr() takes care different types of underlying 997 * MAC. If the underlying MAC is VNIC, the VNIC driver must have registerd 998 * mi_unicst() entry point, that indirectly calls mac_vnic_unicast_set() 999 * which will take care of updating the MAC address of the corresponding 1000 * MAC client. 1001 * 1002 * This is the only interface that allow the client to update the "primary" 1003 * MAC address of the underlying MAC. The new value must have not been 1004 * used by other clients. 1005 */ 1006 int 1007 mac_unicast_primary_set(mac_handle_t mh, const uint8_t *addr) 1008 { 1009 mac_impl_t *mip = (mac_impl_t *)mh; 1010 mac_address_t *map; 1011 int err; 1012 1013 /* verify the address validity */ 1014 if (!mac_unicst_verify(mh, addr, mip->mi_type->mt_addr_length)) 1015 return (EINVAL); 1016 1017 i_mac_perim_enter(mip); 1018 1019 /* 1020 * If the new value is the same as the current primary address value, 1021 * there's nothing to do. 1022 */ 1023 if (bcmp(addr, mip->mi_addr, mip->mi_type->mt_addr_length) == 0) { 1024 i_mac_perim_exit(mip); 1025 return (0); 1026 } 1027 1028 if (mac_find_macaddr(mip, (uint8_t *)addr) != 0) { 1029 i_mac_perim_exit(mip); 1030 return (EBUSY); 1031 } 1032 1033 map = mac_find_macaddr(mip, mip->mi_addr); 1034 ASSERT(map != NULL); 1035 1036 /* 1037 * Update the MAC address. 1038 */ 1039 if (mip->mi_state_flags & MIS_IS_AGGR) { 1040 mac_capab_aggr_t aggr_cap; 1041 1042 /* 1043 * If the mac is an aggregation, other than the unicast 1044 * addresses programming, aggr must be informed about this 1045 * primary unicst address change to change its mac address 1046 * policy to be user-specified. 1047 */ 1048 ASSERT(map->ma_type == MAC_ADDRESS_TYPE_UNICAST_CLASSIFIED); 1049 VERIFY(i_mac_capab_get(mh, MAC_CAPAB_AGGR, &aggr_cap)); 1050 err = aggr_cap.mca_unicst(mip->mi_driver, addr); 1051 if (err == 0) 1052 bcopy(addr, map->ma_addr, map->ma_len); 1053 } else { 1054 err = mac_update_macaddr(map, (uint8_t *)addr); 1055 } 1056 1057 if (err != 0) { 1058 i_mac_perim_exit(mip); 1059 return (err); 1060 } 1061 1062 mac_unicast_update_clients(mip, map); 1063 1064 /* 1065 * Save the new primary MAC address in mac_impl_t. 1066 */ 1067 bcopy(addr, mip->mi_addr, mip->mi_type->mt_addr_length); 1068 1069 i_mac_perim_exit(mip); 1070 1071 if (err == 0) 1072 i_mac_notify(mip, MAC_NOTE_UNICST); 1073 1074 return (err); 1075 } 1076 1077 /* 1078 * Return the current primary MAC address of the specified MAC. 1079 */ 1080 void 1081 mac_unicast_primary_get(mac_handle_t mh, uint8_t *addr) 1082 { 1083 mac_impl_t *mip = (mac_impl_t *)mh; 1084 1085 rw_enter(&mip->mi_rw_lock, RW_READER); 1086 bcopy(mip->mi_addr, addr, mip->mi_type->mt_addr_length); 1087 rw_exit(&mip->mi_rw_lock); 1088 } 1089 1090 /* 1091 * Return the secondary MAC address for the specified handle 1092 */ 1093 void 1094 mac_unicast_secondary_get(mac_client_handle_t mh, uint8_t *addr) 1095 { 1096 mac_client_impl_t *mcip = (mac_client_impl_t *)mh; 1097 1098 ASSERT(mcip->mci_unicast != NULL); 1099 bcopy(mcip->mci_unicast->ma_addr, addr, mcip->mci_unicast->ma_len); 1100 } 1101 1102 /* 1103 * Return information about the use of the primary MAC address of the 1104 * specified MAC instance: 1105 * 1106 * - if client_name is non-NULL, it must point to a string of at 1107 * least MAXNAMELEN bytes, and will be set to the name of the MAC 1108 * client which uses the primary MAC address. 1109 * 1110 * - if in_use is non-NULL, used to return whether the primary MAC 1111 * address is currently in use. 1112 */ 1113 void 1114 mac_unicast_primary_info(mac_handle_t mh, char *client_name, boolean_t *in_use) 1115 { 1116 mac_impl_t *mip = (mac_impl_t *)mh; 1117 mac_client_impl_t *cur_client; 1118 1119 if (in_use != NULL) 1120 *in_use = B_FALSE; 1121 if (client_name != NULL) 1122 bzero(client_name, MAXNAMELEN); 1123 1124 /* 1125 * The mi_rw_lock is used to protect threads that don't hold the 1126 * mac perimeter to get a consistent view of the mi_clients_list. 1127 * Threads that modify the list must hold both the mac perimeter and 1128 * mi_rw_lock(RW_WRITER) 1129 */ 1130 rw_enter(&mip->mi_rw_lock, RW_READER); 1131 for (cur_client = mip->mi_clients_list; cur_client != NULL; 1132 cur_client = cur_client->mci_client_next) { 1133 if (mac_is_primary_client(cur_client) || 1134 (mip->mi_state_flags & MIS_IS_VNIC)) { 1135 rw_exit(&mip->mi_rw_lock); 1136 if (in_use != NULL) 1137 *in_use = B_TRUE; 1138 if (client_name != NULL) { 1139 bcopy(cur_client->mci_name, client_name, 1140 MAXNAMELEN); 1141 } 1142 return; 1143 } 1144 } 1145 rw_exit(&mip->mi_rw_lock); 1146 } 1147 1148 /* 1149 * Return the current destination MAC address of the specified MAC. 1150 */ 1151 boolean_t 1152 mac_dst_get(mac_handle_t mh, uint8_t *addr) 1153 { 1154 mac_impl_t *mip = (mac_impl_t *)mh; 1155 1156 rw_enter(&mip->mi_rw_lock, RW_READER); 1157 if (mip->mi_dstaddr_set) 1158 bcopy(mip->mi_dstaddr, addr, mip->mi_type->mt_addr_length); 1159 rw_exit(&mip->mi_rw_lock); 1160 return (mip->mi_dstaddr_set); 1161 } 1162 1163 /* 1164 * Add the specified MAC client to the list of clients which opened 1165 * the specified MAC. 1166 */ 1167 static void 1168 mac_client_add(mac_client_impl_t *mcip) 1169 { 1170 mac_impl_t *mip = mcip->mci_mip; 1171 1172 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 1173 1174 /* add VNIC to the front of the list */ 1175 rw_enter(&mip->mi_rw_lock, RW_WRITER); 1176 mcip->mci_client_next = mip->mi_clients_list; 1177 mip->mi_clients_list = mcip; 1178 mip->mi_nclients++; 1179 rw_exit(&mip->mi_rw_lock); 1180 } 1181 1182 /* 1183 * Remove the specified MAC client from the list of clients which opened 1184 * the specified MAC. 1185 */ 1186 static void 1187 mac_client_remove(mac_client_impl_t *mcip) 1188 { 1189 mac_impl_t *mip = mcip->mci_mip; 1190 mac_client_impl_t **prev, *cclient; 1191 1192 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 1193 1194 rw_enter(&mip->mi_rw_lock, RW_WRITER); 1195 prev = &mip->mi_clients_list; 1196 cclient = *prev; 1197 while (cclient != NULL && cclient != mcip) { 1198 prev = &cclient->mci_client_next; 1199 cclient = *prev; 1200 } 1201 ASSERT(cclient != NULL); 1202 *prev = cclient->mci_client_next; 1203 mip->mi_nclients--; 1204 rw_exit(&mip->mi_rw_lock); 1205 } 1206 1207 static mac_unicast_impl_t * 1208 mac_client_find_vid(mac_client_impl_t *mcip, uint16_t vid) 1209 { 1210 mac_unicast_impl_t *muip = mcip->mci_unicast_list; 1211 1212 while ((muip != NULL) && (muip->mui_vid != vid)) 1213 muip = muip->mui_next; 1214 1215 return (muip); 1216 } 1217 1218 /* 1219 * Return whether the specified (MAC address, VID) tuple is already used by 1220 * one of the MAC clients associated with the specified MAC. 1221 */ 1222 static boolean_t 1223 mac_addr_in_use(mac_impl_t *mip, uint8_t *mac_addr, uint16_t vid) 1224 { 1225 mac_client_impl_t *client; 1226 mac_address_t *map; 1227 1228 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 1229 1230 for (client = mip->mi_clients_list; client != NULL; 1231 client = client->mci_client_next) { 1232 1233 /* 1234 * Ignore clients that don't have unicast address. 1235 */ 1236 if (client->mci_unicast_list == NULL) 1237 continue; 1238 1239 map = client->mci_unicast; 1240 1241 if ((bcmp(mac_addr, map->ma_addr, map->ma_len) == 0) && 1242 (mac_client_find_vid(client, vid) != NULL)) { 1243 return (B_TRUE); 1244 } 1245 } 1246 1247 return (B_FALSE); 1248 } 1249 1250 /* 1251 * Generate a random MAC address. The MAC address prefix is 1252 * stored in the array pointed to by mac_addr, and its length, in bytes, 1253 * is specified by prefix_len. The least significant bits 1254 * after prefix_len bytes are generated, and stored after the prefix 1255 * in the mac_addr array. 1256 */ 1257 int 1258 mac_addr_random(mac_client_handle_t mch, uint_t prefix_len, 1259 uint8_t *mac_addr, mac_diag_t *diag) 1260 { 1261 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 1262 mac_impl_t *mip = mcip->mci_mip; 1263 size_t addr_len = mip->mi_type->mt_addr_length; 1264 1265 if (prefix_len >= addr_len) { 1266 *diag = MAC_DIAG_MACPREFIXLEN_INVALID; 1267 return (EINVAL); 1268 } 1269 1270 /* check the prefix value */ 1271 if (prefix_len > 0) { 1272 bzero(mac_addr + prefix_len, addr_len - prefix_len); 1273 if (!mac_unicst_verify((mac_handle_t)mip, mac_addr, 1274 addr_len)) { 1275 *diag = MAC_DIAG_MACPREFIX_INVALID; 1276 return (EINVAL); 1277 } 1278 } 1279 1280 /* generate the MAC address */ 1281 if (prefix_len < addr_len) { 1282 (void) random_get_pseudo_bytes(mac_addr + 1283 prefix_len, addr_len - prefix_len); 1284 } 1285 1286 *diag = 0; 1287 return (0); 1288 } 1289 1290 /* 1291 * Set the priority range for this MAC client. This will be used to 1292 * determine the absolute priority for the threads created for this 1293 * MAC client using the specified "low", "medium" and "high" level. 1294 * This will also be used for any subflows on this MAC client. 1295 */ 1296 #define MAC_CLIENT_SET_PRIORITY_RANGE(mcip, pri) { \ 1297 (mcip)->mci_min_pri = FLOW_MIN_PRIORITY(MINCLSYSPRI, \ 1298 MAXCLSYSPRI, (pri)); \ 1299 (mcip)->mci_max_pri = FLOW_MAX_PRIORITY(MINCLSYSPRI, \ 1300 MAXCLSYSPRI, (mcip)->mci_min_pri); \ 1301 } 1302 1303 /* 1304 * MAC client open entry point. Return a new MAC client handle. Each 1305 * MAC client is associated with a name, specified through the 'name' 1306 * argument. 1307 */ 1308 int 1309 mac_client_open(mac_handle_t mh, mac_client_handle_t *mchp, char *name, 1310 uint16_t flags) 1311 { 1312 mac_impl_t *mip = (mac_impl_t *)mh; 1313 mac_client_impl_t *mcip; 1314 int err = 0; 1315 boolean_t share_desired; 1316 flow_entry_t *flent = NULL; 1317 1318 share_desired = (flags & MAC_OPEN_FLAGS_SHARES_DESIRED) != 0; 1319 *mchp = NULL; 1320 1321 i_mac_perim_enter(mip); 1322 1323 if (mip->mi_state_flags & MIS_IS_VNIC) { 1324 /* 1325 * The underlying MAC is a VNIC. Return the MAC client 1326 * handle of the lower MAC which was obtained by 1327 * the VNIC driver when it did its mac_client_open(). 1328 */ 1329 1330 mcip = mac_vnic_lower(mip); 1331 1332 /* 1333 * Note that multiple mac clients share the same mcip in 1334 * this case. 1335 */ 1336 if (flags & MAC_OPEN_FLAGS_EXCLUSIVE) 1337 mcip->mci_state_flags |= MCIS_EXCLUSIVE; 1338 1339 if (flags & MAC_OPEN_FLAGS_MULTI_PRIMARY) 1340 mcip->mci_flags |= MAC_CLIENT_FLAGS_MULTI_PRIMARY; 1341 1342 mip->mi_clients_list = mcip; 1343 i_mac_perim_exit(mip); 1344 *mchp = (mac_client_handle_t)mcip; 1345 1346 DTRACE_PROBE2(mac__client__open__nonallocated, mac_impl_t *, 1347 mcip->mci_mip, mac_client_impl_t *, mcip); 1348 1349 return (err); 1350 } 1351 1352 mcip = kmem_cache_alloc(mac_client_impl_cache, KM_SLEEP); 1353 1354 mcip->mci_mip = mip; 1355 mcip->mci_upper_mip = NULL; 1356 mcip->mci_rx_fn = mac_pkt_drop; 1357 mcip->mci_rx_arg = NULL; 1358 mcip->mci_rx_p_fn = NULL; 1359 mcip->mci_rx_p_arg = NULL; 1360 mcip->mci_p_unicast_list = NULL; 1361 mcip->mci_direct_rx_fn = NULL; 1362 mcip->mci_direct_rx_arg = NULL; 1363 mcip->mci_vidcache = MCIP_VIDCACHE_INVALID; 1364 1365 mcip->mci_unicast_list = NULL; 1366 1367 if ((flags & MAC_OPEN_FLAGS_IS_VNIC) != 0) 1368 mcip->mci_state_flags |= MCIS_IS_VNIC; 1369 1370 if ((flags & MAC_OPEN_FLAGS_EXCLUSIVE) != 0) 1371 mcip->mci_state_flags |= MCIS_EXCLUSIVE; 1372 1373 if ((flags & MAC_OPEN_FLAGS_IS_AGGR_PORT) != 0) 1374 mcip->mci_state_flags |= MCIS_IS_AGGR_PORT; 1375 1376 if (mip->mi_state_flags & MIS_IS_AGGR) 1377 mcip->mci_state_flags |= MCIS_IS_AGGR; 1378 1379 if ((flags & MAC_OPEN_FLAGS_USE_DATALINK_NAME) != 0) { 1380 datalink_id_t linkid; 1381 1382 ASSERT(name == NULL); 1383 if ((err = dls_devnet_macname2linkid(mip->mi_name, 1384 &linkid)) != 0) { 1385 goto done; 1386 } 1387 if ((err = dls_mgmt_get_linkinfo(linkid, mcip->mci_name, NULL, 1388 NULL, NULL)) != 0) { 1389 /* 1390 * Use mac name if dlmgmtd is not available. 1391 */ 1392 if (err == EBADF) { 1393 (void) strlcpy(mcip->mci_name, mip->mi_name, 1394 sizeof (mcip->mci_name)); 1395 err = 0; 1396 } else { 1397 goto done; 1398 } 1399 } 1400 mcip->mci_state_flags |= MCIS_USE_DATALINK_NAME; 1401 } else { 1402 ASSERT(name != NULL); 1403 if (strlen(name) > MAXNAMELEN) { 1404 err = EINVAL; 1405 goto done; 1406 } 1407 (void) strlcpy(mcip->mci_name, name, sizeof (mcip->mci_name)); 1408 } 1409 1410 if (flags & MAC_OPEN_FLAGS_MULTI_PRIMARY) 1411 mcip->mci_flags |= MAC_CLIENT_FLAGS_MULTI_PRIMARY; 1412 1413 if (flags & MAC_OPEN_FLAGS_NO_UNICAST_ADDR) 1414 mcip->mci_state_flags |= MCIS_NO_UNICAST_ADDR; 1415 1416 mac_protect_init(mcip); 1417 1418 /* the subflow table will be created dynamically */ 1419 mcip->mci_subflow_tab = NULL; 1420 1421 mcip->mci_misc_stat.mms_multircv = 0; 1422 mcip->mci_misc_stat.mms_brdcstrcv = 0; 1423 mcip->mci_misc_stat.mms_multixmt = 0; 1424 mcip->mci_misc_stat.mms_brdcstxmt = 0; 1425 1426 /* Create an initial flow */ 1427 1428 err = mac_flow_create(NULL, NULL, mcip->mci_name, NULL, 1429 mcip->mci_state_flags & MCIS_IS_VNIC ? FLOW_VNIC_MAC : 1430 FLOW_PRIMARY_MAC, &flent); 1431 if (err != 0) 1432 goto done; 1433 mcip->mci_flent = flent; 1434 FLOW_MARK(flent, FE_MC_NO_DATAPATH); 1435 flent->fe_mcip = mcip; 1436 /* 1437 * Place initial creation reference on the flow. This reference 1438 * is released in the corresponding delete action viz. 1439 * mac_unicast_remove after waiting for all transient refs to 1440 * to go away. The wait happens in mac_flow_wait. 1441 */ 1442 FLOW_REFHOLD(flent); 1443 1444 /* 1445 * Do this ahead of the mac_bcast_add() below so that the mi_nclients 1446 * will have the right value for mac_rx_srs_setup(). 1447 */ 1448 mac_client_add(mcip); 1449 1450 mcip->mci_share = 0; 1451 if (share_desired) 1452 i_mac_share_alloc(mcip); 1453 1454 /* 1455 * We will do mimimal datapath setup to allow a MAC client to 1456 * transmit or receive non-unicast packets without waiting 1457 * for mac_unicast_add. 1458 */ 1459 if (mcip->mci_state_flags & MCIS_NO_UNICAST_ADDR) { 1460 if ((err = mac_client_datapath_setup(mcip, VLAN_ID_NONE, 1461 NULL, NULL, B_TRUE, NULL)) != 0) { 1462 goto done; 1463 } 1464 } 1465 1466 DTRACE_PROBE2(mac__client__open__allocated, mac_impl_t *, 1467 mcip->mci_mip, mac_client_impl_t *, mcip); 1468 1469 *mchp = (mac_client_handle_t)mcip; 1470 i_mac_perim_exit(mip); 1471 return (0); 1472 1473 done: 1474 i_mac_perim_exit(mip); 1475 mcip->mci_state_flags = 0; 1476 mcip->mci_tx_flag = 0; 1477 kmem_cache_free(mac_client_impl_cache, mcip); 1478 return (err); 1479 } 1480 1481 /* 1482 * Close the specified MAC client handle. 1483 */ 1484 void 1485 mac_client_close(mac_client_handle_t mch, uint16_t flags) 1486 { 1487 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 1488 mac_impl_t *mip = mcip->mci_mip; 1489 flow_entry_t *flent; 1490 1491 i_mac_perim_enter(mip); 1492 1493 if (flags & MAC_CLOSE_FLAGS_EXCLUSIVE) 1494 mcip->mci_state_flags &= ~MCIS_EXCLUSIVE; 1495 1496 if ((mcip->mci_state_flags & MCIS_IS_VNIC) && 1497 !(flags & MAC_CLOSE_FLAGS_IS_VNIC)) { 1498 /* 1499 * This is an upper VNIC client initiated operation. 1500 * The lower MAC client will be closed by the VNIC driver 1501 * when the VNIC is deleted. 1502 */ 1503 1504 i_mac_perim_exit(mip); 1505 return; 1506 } 1507 1508 /* If we have only setup up minimal datapth setup, tear it down */ 1509 if (mcip->mci_state_flags & MCIS_NO_UNICAST_ADDR) { 1510 mac_client_datapath_teardown((mac_client_handle_t)mcip, NULL, 1511 mcip->mci_flent); 1512 mcip->mci_state_flags &= ~MCIS_NO_UNICAST_ADDR; 1513 } 1514 1515 /* 1516 * Remove the flent associated with the MAC client 1517 */ 1518 flent = mcip->mci_flent; 1519 mcip->mci_flent = NULL; 1520 FLOW_FINAL_REFRELE(flent); 1521 1522 /* 1523 * MAC clients must remove the unicast addresses and promisc callbacks 1524 * they added before issuing a mac_client_close(). 1525 */ 1526 ASSERT(mcip->mci_unicast_list == NULL); 1527 ASSERT(mcip->mci_promisc_list == NULL); 1528 ASSERT(mcip->mci_tx_notify_cb_list == NULL); 1529 1530 i_mac_share_free(mcip); 1531 mac_protect_fini(mcip); 1532 mac_client_remove(mcip); 1533 1534 i_mac_perim_exit(mip); 1535 mcip->mci_subflow_tab = NULL; 1536 mcip->mci_state_flags = 0; 1537 mcip->mci_tx_flag = 0; 1538 kmem_cache_free(mac_client_impl_cache, mch); 1539 } 1540 1541 /* 1542 * Set the rx bypass receive callback. 1543 */ 1544 boolean_t 1545 mac_rx_bypass_set(mac_client_handle_t mch, mac_direct_rx_t rx_fn, void *arg1) 1546 { 1547 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 1548 mac_impl_t *mip = mcip->mci_mip; 1549 1550 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 1551 1552 /* 1553 * If the mac_client is a VLAN, we should not do DLS bypass and 1554 * instead let the packets come up via mac_rx_deliver so the vlan 1555 * header can be stripped. 1556 */ 1557 if (mcip->mci_nvids > 0) 1558 return (B_FALSE); 1559 1560 /* 1561 * These are not accessed directly in the data path, and hence 1562 * don't need any protection 1563 */ 1564 mcip->mci_direct_rx_fn = rx_fn; 1565 mcip->mci_direct_rx_arg = arg1; 1566 return (B_TRUE); 1567 } 1568 1569 /* 1570 * Enable/Disable rx bypass. By default, bypass is assumed to be enabled. 1571 */ 1572 void 1573 mac_rx_bypass_enable(mac_client_handle_t mch) 1574 { 1575 ((mac_client_impl_t *)mch)->mci_state_flags &= ~MCIS_RX_BYPASS_DISABLE; 1576 } 1577 1578 void 1579 mac_rx_bypass_disable(mac_client_handle_t mch) 1580 { 1581 ((mac_client_impl_t *)mch)->mci_state_flags |= MCIS_RX_BYPASS_DISABLE; 1582 } 1583 1584 /* 1585 * Set the receive callback for the specified MAC client. There can be 1586 * at most one such callback per MAC client. 1587 */ 1588 void 1589 mac_rx_set(mac_client_handle_t mch, mac_rx_t rx_fn, void *arg) 1590 { 1591 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 1592 mac_impl_t *mip = mcip->mci_mip; 1593 mac_impl_t *umip = mcip->mci_upper_mip; 1594 1595 /* 1596 * Instead of adding an extra set of locks and refcnts in 1597 * the datapath at the mac client boundary, we temporarily quiesce 1598 * the SRS and related entities. We then change the receive function 1599 * without interference from any receive data thread and then reenable 1600 * the data flow subsequently. 1601 */ 1602 i_mac_perim_enter(mip); 1603 mac_rx_client_quiesce(mch); 1604 1605 mcip->mci_rx_fn = rx_fn; 1606 mcip->mci_rx_arg = arg; 1607 mac_rx_client_restart(mch); 1608 i_mac_perim_exit(mip); 1609 1610 /* 1611 * If we're changing the rx function on the primary mac of a vnic, 1612 * make sure any secondary macs on the vnic are updated as well. 1613 */ 1614 if (umip != NULL) { 1615 ASSERT((umip->mi_state_flags & MIS_IS_VNIC) != 0); 1616 mac_vnic_secondary_update(umip); 1617 } 1618 } 1619 1620 /* 1621 * Reset the receive callback for the specified MAC client. 1622 */ 1623 void 1624 mac_rx_clear(mac_client_handle_t mch) 1625 { 1626 mac_rx_set(mch, mac_pkt_drop, NULL); 1627 } 1628 1629 void 1630 mac_secondary_dup(mac_client_handle_t smch, mac_client_handle_t dmch) 1631 { 1632 mac_client_impl_t *smcip = (mac_client_impl_t *)smch; 1633 mac_client_impl_t *dmcip = (mac_client_impl_t *)dmch; 1634 flow_entry_t *flent = dmcip->mci_flent; 1635 1636 /* This should only be called to setup secondary macs */ 1637 ASSERT((flent->fe_type & FLOW_PRIMARY_MAC) == 0); 1638 1639 mac_rx_set(dmch, smcip->mci_rx_fn, smcip->mci_rx_arg); 1640 dmcip->mci_promisc_list = smcip->mci_promisc_list; 1641 1642 /* 1643 * Duplicate the primary mac resources to the secondary. 1644 * Since we already validated the resource controls when setting 1645 * them on the primary, we can ignore errors here. 1646 */ 1647 (void) mac_resource_ctl_set(dmch, MCIP_RESOURCE_PROPS(smcip)); 1648 } 1649 1650 /* 1651 * Called when removing a secondary MAC. Currently only clears the promisc_list 1652 * since we share the primary mac's promisc_list. 1653 */ 1654 void 1655 mac_secondary_cleanup(mac_client_handle_t mch) 1656 { 1657 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 1658 flow_entry_t *flent = mcip->mci_flent; 1659 1660 /* This should only be called for secondary macs */ 1661 ASSERT((flent->fe_type & FLOW_PRIMARY_MAC) == 0); 1662 mcip->mci_promisc_list = NULL; 1663 } 1664 1665 /* 1666 * Walk the MAC client subflow table and updates their priority values. 1667 */ 1668 static int 1669 mac_update_subflow_priority_cb(flow_entry_t *flent, void *arg) 1670 { 1671 mac_flow_update_priority(arg, flent); 1672 return (0); 1673 } 1674 1675 void 1676 mac_update_subflow_priority(mac_client_impl_t *mcip) 1677 { 1678 (void) mac_flow_walk(mcip->mci_subflow_tab, 1679 mac_update_subflow_priority_cb, mcip); 1680 } 1681 1682 /* 1683 * Modify the TX or RX ring properties. We could either just move around 1684 * rings, i.e add/remove rings given to a client. Or this might cause the 1685 * client to move from hardware based to software or the other way around. 1686 * If we want to reset this property, then we clear the mask, additionally 1687 * if the client was given a non-default group we remove all rings except 1688 * for 1 and give it back to the default group. 1689 */ 1690 int 1691 mac_client_set_rings_prop(mac_client_impl_t *mcip, mac_resource_props_t *mrp, 1692 mac_resource_props_t *tmrp) 1693 { 1694 mac_impl_t *mip = mcip->mci_mip; 1695 flow_entry_t *flent = mcip->mci_flent; 1696 uint8_t *mac_addr; 1697 int err = 0; 1698 mac_group_t *defgrp; 1699 mac_group_t *group; 1700 mac_group_t *ngrp; 1701 mac_resource_props_t *cmrp = MCIP_RESOURCE_PROPS(mcip); 1702 uint_t ringcnt; 1703 boolean_t unspec; 1704 1705 if (mcip->mci_share != 0) 1706 return (EINVAL); 1707 1708 if (mrp->mrp_mask & MRP_RX_RINGS) { 1709 unspec = mrp->mrp_mask & MRP_RXRINGS_UNSPEC; 1710 group = flent->fe_rx_ring_group; 1711 defgrp = MAC_DEFAULT_RX_GROUP(mip); 1712 mac_addr = flent->fe_flow_desc.fd_dst_mac; 1713 1714 /* 1715 * No resulting change. If we are resetting on a client on 1716 * which there was no rx rings property. For dynamic group 1717 * if we are setting the same number of rings already set. 1718 * For static group if we are requesting a group again. 1719 */ 1720 if (mrp->mrp_mask & MRP_RINGS_RESET) { 1721 if (!(tmrp->mrp_mask & MRP_RX_RINGS)) 1722 return (0); 1723 } else { 1724 if (unspec) { 1725 if (tmrp->mrp_mask & MRP_RXRINGS_UNSPEC) 1726 return (0); 1727 } else if (mip->mi_rx_group_type == 1728 MAC_GROUP_TYPE_DYNAMIC) { 1729 if ((tmrp->mrp_mask & MRP_RX_RINGS) && 1730 !(tmrp->mrp_mask & MRP_RXRINGS_UNSPEC) && 1731 mrp->mrp_nrxrings == tmrp->mrp_nrxrings) { 1732 return (0); 1733 } 1734 } 1735 } 1736 /* Resetting the prop */ 1737 if (mrp->mrp_mask & MRP_RINGS_RESET) { 1738 /* 1739 * We will just keep one ring and give others back if 1740 * we are not the primary. For the primary we give 1741 * all the rings in the default group except the 1742 * default ring. If it is a static group, then 1743 * we don't do anything, but clear the MRP_RX_RINGS 1744 * flag. 1745 */ 1746 if (group != defgrp) { 1747 if (mip->mi_rx_group_type == 1748 MAC_GROUP_TYPE_DYNAMIC) { 1749 /* 1750 * This group has reserved rings 1751 * that need to be released now, 1752 * so does the group. 1753 */ 1754 MAC_RX_RING_RELEASED(mip, 1755 group->mrg_cur_count); 1756 MAC_RX_GRP_RELEASED(mip); 1757 if ((flent->fe_type & 1758 FLOW_PRIMARY_MAC) != 0) { 1759 if (mip->mi_nactiveclients == 1760 1) { 1761 (void) 1762 mac_rx_switch_group( 1763 mcip, group, 1764 defgrp); 1765 return (0); 1766 } else { 1767 cmrp->mrp_nrxrings = 1768 group-> 1769 mrg_cur_count + 1770 defgrp-> 1771 mrg_cur_count - 1; 1772 } 1773 } else { 1774 cmrp->mrp_nrxrings = 1; 1775 } 1776 (void) mac_group_ring_modify(mcip, 1777 group, defgrp); 1778 } else { 1779 /* 1780 * If this is a static group, we 1781 * need to release the group. The 1782 * client will remain in the same 1783 * group till some other client 1784 * needs this group. 1785 */ 1786 MAC_RX_GRP_RELEASED(mip); 1787 } 1788 /* Let check if we can give this an excl group */ 1789 } else if (group == defgrp) { 1790 ngrp = mac_reserve_rx_group(mcip, mac_addr, 1791 B_TRUE); 1792 /* Couldn't give it a group, that's fine */ 1793 if (ngrp == NULL) 1794 return (0); 1795 /* Switch to H/W */ 1796 if (mac_rx_switch_group(mcip, defgrp, ngrp) != 1797 0) { 1798 mac_stop_group(ngrp); 1799 return (0); 1800 } 1801 } 1802 /* 1803 * If the client is in the default group, we will 1804 * just clear the MRP_RX_RINGS and leave it as 1805 * it rather than look for an exclusive group 1806 * for it. 1807 */ 1808 return (0); 1809 } 1810 1811 if (group == defgrp && ((mrp->mrp_nrxrings > 0) || unspec)) { 1812 ngrp = mac_reserve_rx_group(mcip, mac_addr, B_TRUE); 1813 if (ngrp == NULL) 1814 return (ENOSPC); 1815 1816 /* Switch to H/W */ 1817 if (mac_rx_switch_group(mcip, defgrp, ngrp) != 0) { 1818 mac_release_rx_group(mcip, ngrp); 1819 return (ENOSPC); 1820 } 1821 MAC_RX_GRP_RESERVED(mip); 1822 if (mip->mi_rx_group_type == MAC_GROUP_TYPE_DYNAMIC) 1823 MAC_RX_RING_RESERVED(mip, ngrp->mrg_cur_count); 1824 } else if (group != defgrp && !unspec && 1825 mrp->mrp_nrxrings == 0) { 1826 /* Switch to S/W */ 1827 ringcnt = group->mrg_cur_count; 1828 if (mac_rx_switch_group(mcip, group, defgrp) != 0) 1829 return (ENOSPC); 1830 if (tmrp->mrp_mask & MRP_RX_RINGS) { 1831 MAC_RX_GRP_RELEASED(mip); 1832 if (mip->mi_rx_group_type == 1833 MAC_GROUP_TYPE_DYNAMIC) { 1834 MAC_RX_RING_RELEASED(mip, ringcnt); 1835 } 1836 } 1837 } else if (group != defgrp && mip->mi_rx_group_type == 1838 MAC_GROUP_TYPE_DYNAMIC) { 1839 ringcnt = group->mrg_cur_count; 1840 err = mac_group_ring_modify(mcip, group, defgrp); 1841 if (err != 0) 1842 return (err); 1843 /* 1844 * Update the accounting. If this group 1845 * already had explicitly reserved rings, 1846 * we need to update the rings based on 1847 * the new ring count. If this group 1848 * had not explicitly reserved rings, 1849 * then we just reserve the rings asked for 1850 * and reserve the group. 1851 */ 1852 if (tmrp->mrp_mask & MRP_RX_RINGS) { 1853 if (ringcnt > group->mrg_cur_count) { 1854 MAC_RX_RING_RELEASED(mip, 1855 ringcnt - group->mrg_cur_count); 1856 } else { 1857 MAC_RX_RING_RESERVED(mip, 1858 group->mrg_cur_count - ringcnt); 1859 } 1860 } else { 1861 MAC_RX_RING_RESERVED(mip, group->mrg_cur_count); 1862 MAC_RX_GRP_RESERVED(mip); 1863 } 1864 } 1865 } 1866 if (mrp->mrp_mask & MRP_TX_RINGS) { 1867 unspec = mrp->mrp_mask & MRP_TXRINGS_UNSPEC; 1868 group = flent->fe_tx_ring_group; 1869 defgrp = MAC_DEFAULT_TX_GROUP(mip); 1870 1871 /* 1872 * For static groups we only allow rings=0 or resetting the 1873 * rings property. 1874 */ 1875 if (mrp->mrp_ntxrings > 0 && 1876 mip->mi_tx_group_type != MAC_GROUP_TYPE_DYNAMIC) { 1877 return (ENOTSUP); 1878 } 1879 if (mrp->mrp_mask & MRP_RINGS_RESET) { 1880 if (!(tmrp->mrp_mask & MRP_TX_RINGS)) 1881 return (0); 1882 } else { 1883 if (unspec) { 1884 if (tmrp->mrp_mask & MRP_TXRINGS_UNSPEC) 1885 return (0); 1886 } else if (mip->mi_tx_group_type == 1887 MAC_GROUP_TYPE_DYNAMIC) { 1888 if ((tmrp->mrp_mask & MRP_TX_RINGS) && 1889 !(tmrp->mrp_mask & MRP_TXRINGS_UNSPEC) && 1890 mrp->mrp_ntxrings == tmrp->mrp_ntxrings) { 1891 return (0); 1892 } 1893 } 1894 } 1895 /* Resetting the prop */ 1896 if (mrp->mrp_mask & MRP_RINGS_RESET) { 1897 if (group != defgrp) { 1898 if (mip->mi_tx_group_type == 1899 MAC_GROUP_TYPE_DYNAMIC) { 1900 ringcnt = group->mrg_cur_count; 1901 if ((flent->fe_type & 1902 FLOW_PRIMARY_MAC) != 0) { 1903 mac_tx_client_quiesce( 1904 (mac_client_handle_t) 1905 mcip); 1906 mac_tx_switch_group(mcip, 1907 group, defgrp); 1908 mac_tx_client_restart( 1909 (mac_client_handle_t) 1910 mcip); 1911 MAC_TX_GRP_RELEASED(mip); 1912 MAC_TX_RING_RELEASED(mip, 1913 ringcnt); 1914 return (0); 1915 } 1916 cmrp->mrp_ntxrings = 1; 1917 (void) mac_group_ring_modify(mcip, 1918 group, defgrp); 1919 /* 1920 * This group has reserved rings 1921 * that need to be released now. 1922 */ 1923 MAC_TX_RING_RELEASED(mip, ringcnt); 1924 } 1925 /* 1926 * If this is a static group, we 1927 * need to release the group. The 1928 * client will remain in the same 1929 * group till some other client 1930 * needs this group. 1931 */ 1932 MAC_TX_GRP_RELEASED(mip); 1933 } else if (group == defgrp && 1934 (flent->fe_type & FLOW_PRIMARY_MAC) == 0) { 1935 ngrp = mac_reserve_tx_group(mcip, B_TRUE); 1936 if (ngrp == NULL) 1937 return (0); 1938 mac_tx_client_quiesce( 1939 (mac_client_handle_t)mcip); 1940 mac_tx_switch_group(mcip, defgrp, ngrp); 1941 mac_tx_client_restart( 1942 (mac_client_handle_t)mcip); 1943 } 1944 /* 1945 * If the client is in the default group, we will 1946 * just clear the MRP_TX_RINGS and leave it as 1947 * it rather than look for an exclusive group 1948 * for it. 1949 */ 1950 return (0); 1951 } 1952 1953 /* Switch to H/W */ 1954 if (group == defgrp && ((mrp->mrp_ntxrings > 0) || unspec)) { 1955 ngrp = mac_reserve_tx_group(mcip, B_TRUE); 1956 if (ngrp == NULL) 1957 return (ENOSPC); 1958 mac_tx_client_quiesce((mac_client_handle_t)mcip); 1959 mac_tx_switch_group(mcip, defgrp, ngrp); 1960 mac_tx_client_restart((mac_client_handle_t)mcip); 1961 MAC_TX_GRP_RESERVED(mip); 1962 if (mip->mi_tx_group_type == MAC_GROUP_TYPE_DYNAMIC) 1963 MAC_TX_RING_RESERVED(mip, ngrp->mrg_cur_count); 1964 /* Switch to S/W */ 1965 } else if (group != defgrp && !unspec && 1966 mrp->mrp_ntxrings == 0) { 1967 /* Switch to S/W */ 1968 ringcnt = group->mrg_cur_count; 1969 mac_tx_client_quiesce((mac_client_handle_t)mcip); 1970 mac_tx_switch_group(mcip, group, defgrp); 1971 mac_tx_client_restart((mac_client_handle_t)mcip); 1972 if (tmrp->mrp_mask & MRP_TX_RINGS) { 1973 MAC_TX_GRP_RELEASED(mip); 1974 if (mip->mi_tx_group_type == 1975 MAC_GROUP_TYPE_DYNAMIC) { 1976 MAC_TX_RING_RELEASED(mip, ringcnt); 1977 } 1978 } 1979 } else if (group != defgrp && mip->mi_tx_group_type == 1980 MAC_GROUP_TYPE_DYNAMIC) { 1981 ringcnt = group->mrg_cur_count; 1982 err = mac_group_ring_modify(mcip, group, defgrp); 1983 if (err != 0) 1984 return (err); 1985 /* 1986 * Update the accounting. If this group 1987 * already had explicitly reserved rings, 1988 * we need to update the rings based on 1989 * the new ring count. If this group 1990 * had not explicitly reserved rings, 1991 * then we just reserve the rings asked for 1992 * and reserve the group. 1993 */ 1994 if (tmrp->mrp_mask & MRP_TX_RINGS) { 1995 if (ringcnt > group->mrg_cur_count) { 1996 MAC_TX_RING_RELEASED(mip, 1997 ringcnt - group->mrg_cur_count); 1998 } else { 1999 MAC_TX_RING_RESERVED(mip, 2000 group->mrg_cur_count - ringcnt); 2001 } 2002 } else { 2003 MAC_TX_RING_RESERVED(mip, group->mrg_cur_count); 2004 MAC_TX_GRP_RESERVED(mip); 2005 } 2006 } 2007 } 2008 return (0); 2009 } 2010 2011 /* 2012 * When the MAC client is being brought up (i.e. we do a unicast_add) we need 2013 * to initialize the cpu and resource control structure in the 2014 * mac_client_impl_t from the mac_impl_t (i.e if there are any cached 2015 * properties before the flow entry for the unicast address was created). 2016 */ 2017 static int 2018 mac_resource_ctl_set(mac_client_handle_t mch, mac_resource_props_t *mrp) 2019 { 2020 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 2021 mac_impl_t *mip = (mac_impl_t *)mcip->mci_mip; 2022 mac_impl_t *umip = mcip->mci_upper_mip; 2023 int err = 0; 2024 flow_entry_t *flent = mcip->mci_flent; 2025 mac_resource_props_t *omrp, *nmrp = MCIP_RESOURCE_PROPS(mcip); 2026 2027 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 2028 2029 err = mac_validate_props(mcip->mci_state_flags & MCIS_IS_VNIC ? 2030 mcip->mci_upper_mip : mip, mrp); 2031 if (err != 0) 2032 return (err); 2033 2034 /* 2035 * Copy over the existing properties since mac_update_resources 2036 * will modify the client's mrp. Currently, the saved property 2037 * is used to determine the difference between existing and 2038 * modified rings property. 2039 */ 2040 omrp = kmem_zalloc(sizeof (*omrp), KM_SLEEP); 2041 bcopy(nmrp, omrp, sizeof (*omrp)); 2042 mac_update_resources(mrp, MCIP_RESOURCE_PROPS(mcip), B_FALSE); 2043 if (MCIP_DATAPATH_SETUP(mcip)) { 2044 /* 2045 * We support rings only for primary client when there are 2046 * multiple clients sharing the same MAC address (e.g. VLAN). 2047 */ 2048 if (mrp->mrp_mask & MRP_RX_RINGS || 2049 mrp->mrp_mask & MRP_TX_RINGS) { 2050 2051 if ((err = mac_client_set_rings_prop(mcip, mrp, 2052 omrp)) != 0) { 2053 if (omrp->mrp_mask & MRP_RX_RINGS) { 2054 nmrp->mrp_mask |= MRP_RX_RINGS; 2055 nmrp->mrp_nrxrings = omrp->mrp_nrxrings; 2056 } else { 2057 nmrp->mrp_mask &= ~MRP_RX_RINGS; 2058 nmrp->mrp_nrxrings = 0; 2059 } 2060 if (omrp->mrp_mask & MRP_TX_RINGS) { 2061 nmrp->mrp_mask |= MRP_TX_RINGS; 2062 nmrp->mrp_ntxrings = omrp->mrp_ntxrings; 2063 } else { 2064 nmrp->mrp_mask &= ~MRP_TX_RINGS; 2065 nmrp->mrp_ntxrings = 0; 2066 } 2067 if (omrp->mrp_mask & MRP_RXRINGS_UNSPEC) 2068 omrp->mrp_mask |= MRP_RXRINGS_UNSPEC; 2069 else 2070 omrp->mrp_mask &= ~MRP_RXRINGS_UNSPEC; 2071 2072 if (omrp->mrp_mask & MRP_TXRINGS_UNSPEC) 2073 omrp->mrp_mask |= MRP_TXRINGS_UNSPEC; 2074 else 2075 omrp->mrp_mask &= ~MRP_TXRINGS_UNSPEC; 2076 kmem_free(omrp, sizeof (*omrp)); 2077 return (err); 2078 } 2079 2080 /* 2081 * If we modified the rings property of the primary 2082 * we need to update the property fields of its 2083 * VLANs as they inherit the primary's properites. 2084 */ 2085 if (mac_is_primary_client(mcip)) { 2086 mac_set_prim_vlan_rings(mip, 2087 MCIP_RESOURCE_PROPS(mcip)); 2088 } 2089 } 2090 /* 2091 * We have to set this prior to calling mac_flow_modify. 2092 */ 2093 if (mrp->mrp_mask & MRP_PRIORITY) { 2094 if (mrp->mrp_priority == MPL_RESET) { 2095 MAC_CLIENT_SET_PRIORITY_RANGE(mcip, 2096 MPL_LINK_DEFAULT); 2097 } else { 2098 MAC_CLIENT_SET_PRIORITY_RANGE(mcip, 2099 mrp->mrp_priority); 2100 } 2101 } 2102 2103 mac_flow_modify(mip->mi_flow_tab, flent, mrp); 2104 if (mrp->mrp_mask & MRP_PRIORITY) 2105 mac_update_subflow_priority(mcip); 2106 2107 /* Apply these resource settings to any secondary macs */ 2108 if (umip != NULL) { 2109 ASSERT((umip->mi_state_flags & MIS_IS_VNIC) != 0); 2110 mac_vnic_secondary_update(umip); 2111 } 2112 } 2113 kmem_free(omrp, sizeof (*omrp)); 2114 return (0); 2115 } 2116 2117 static int 2118 mac_unicast_flow_create(mac_client_impl_t *mcip, uint8_t *mac_addr, 2119 uint16_t vid, boolean_t is_primary, boolean_t first_flow, 2120 flow_entry_t **flent, mac_resource_props_t *mrp) 2121 { 2122 mac_impl_t *mip = (mac_impl_t *)mcip->mci_mip; 2123 flow_desc_t flow_desc; 2124 char flowname[MAXFLOWNAMELEN]; 2125 int err; 2126 uint_t flent_flags; 2127 2128 /* 2129 * First unicast address being added, create a new flow 2130 * for that MAC client. 2131 */ 2132 bzero(&flow_desc, sizeof (flow_desc)); 2133 2134 ASSERT(mac_addr != NULL || 2135 (mcip->mci_state_flags & MCIS_NO_UNICAST_ADDR)); 2136 if (mac_addr != NULL) { 2137 flow_desc.fd_mac_len = mip->mi_type->mt_addr_length; 2138 bcopy(mac_addr, flow_desc.fd_dst_mac, flow_desc.fd_mac_len); 2139 } 2140 flow_desc.fd_mask = FLOW_LINK_DST; 2141 if (vid != 0) { 2142 flow_desc.fd_vid = vid; 2143 flow_desc.fd_mask |= FLOW_LINK_VID; 2144 } 2145 2146 /* 2147 * XXX-nicolas. For now I'm keeping the FLOW_PRIMARY_MAC 2148 * and FLOW_VNIC. Even though they're a hack inherited 2149 * from the SRS code, we'll keep them for now. They're currently 2150 * consumed by mac_datapath_setup() to create the SRS. 2151 * That code should be eventually moved out of 2152 * mac_datapath_setup() and moved to a mac_srs_create() 2153 * function of some sort to keep things clean. 2154 * 2155 * Also, there's no reason why the SRS for the primary MAC 2156 * client should be different than any other MAC client. Until 2157 * this is cleaned-up, we support only one MAC unicast address 2158 * per client. 2159 * 2160 * We set FLOW_PRIMARY_MAC for the primary MAC address, 2161 * FLOW_VNIC for everything else. 2162 */ 2163 if (is_primary) 2164 flent_flags = FLOW_PRIMARY_MAC; 2165 else 2166 flent_flags = FLOW_VNIC_MAC; 2167 2168 /* 2169 * For the first flow we use the mac client's name - mci_name, for 2170 * subsequent ones we just create a name with the vid. This is 2171 * so that we can add these flows to the same flow table. This is 2172 * fine as the flow name (except for the one with the mac client's 2173 * name) is not visible. When the first flow is removed, we just replace 2174 * its fdesc with another from the list, so we will still retain the 2175 * flent with the MAC client's flow name. 2176 */ 2177 if (first_flow) { 2178 bcopy(mcip->mci_name, flowname, MAXFLOWNAMELEN); 2179 } else { 2180 (void) sprintf(flowname, "%s%u", mcip->mci_name, vid); 2181 flent_flags = FLOW_NO_STATS; 2182 } 2183 2184 if ((err = mac_flow_create(&flow_desc, mrp, flowname, NULL, 2185 flent_flags, flent)) != 0) 2186 return (err); 2187 2188 mac_misc_stat_create(*flent); 2189 FLOW_MARK(*flent, FE_INCIPIENT); 2190 (*flent)->fe_mcip = mcip; 2191 2192 /* 2193 * Place initial creation reference on the flow. This reference 2194 * is released in the corresponding delete action viz. 2195 * mac_unicast_remove after waiting for all transient refs to 2196 * to go away. The wait happens in mac_flow_wait. 2197 * We have already held the reference in mac_client_open(). 2198 */ 2199 if (!first_flow) 2200 FLOW_REFHOLD(*flent); 2201 return (0); 2202 } 2203 2204 /* Refresh the multicast grouping for this VID. */ 2205 int 2206 mac_client_update_mcast(void *arg, boolean_t add, const uint8_t *addrp) 2207 { 2208 flow_entry_t *flent = arg; 2209 mac_client_impl_t *mcip = flent->fe_mcip; 2210 uint16_t vid; 2211 flow_desc_t flow_desc; 2212 2213 mac_flow_get_desc(flent, &flow_desc); 2214 vid = (flow_desc.fd_mask & FLOW_LINK_VID) != 0 ? 2215 flow_desc.fd_vid : VLAN_ID_NONE; 2216 2217 /* 2218 * We don't call mac_multicast_add()/mac_multicast_remove() as 2219 * we want to add/remove for this specific vid. 2220 */ 2221 if (add) { 2222 return (mac_bcast_add(mcip, addrp, vid, 2223 MAC_ADDRTYPE_MULTICAST)); 2224 } else { 2225 mac_bcast_delete(mcip, addrp, vid); 2226 return (0); 2227 } 2228 } 2229 2230 static void 2231 mac_update_single_active_client(mac_impl_t *mip) 2232 { 2233 mac_client_impl_t *client = NULL; 2234 2235 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 2236 2237 rw_enter(&mip->mi_rw_lock, RW_WRITER); 2238 if (mip->mi_nactiveclients == 1) { 2239 /* 2240 * Find the one active MAC client from the list of MAC 2241 * clients. The active MAC client has at least one 2242 * unicast address. 2243 */ 2244 for (client = mip->mi_clients_list; client != NULL; 2245 client = client->mci_client_next) { 2246 if (client->mci_unicast_list != NULL) 2247 break; 2248 } 2249 ASSERT(client != NULL); 2250 } 2251 2252 /* 2253 * mi_single_active_client is protected by the MAC impl's read/writer 2254 * lock, which allows mac_rx() to check the value of that pointer 2255 * as a reader. 2256 */ 2257 mip->mi_single_active_client = client; 2258 rw_exit(&mip->mi_rw_lock); 2259 } 2260 2261 /* 2262 * Set up the data path. Called from i_mac_unicast_add after having 2263 * done all the validations including making sure this is an active 2264 * client (i.e that is ready to process packets.) 2265 */ 2266 static int 2267 mac_client_datapath_setup(mac_client_impl_t *mcip, uint16_t vid, 2268 uint8_t *mac_addr, mac_resource_props_t *mrp, boolean_t isprimary, 2269 mac_unicast_impl_t *muip) 2270 { 2271 mac_impl_t *mip = mcip->mci_mip; 2272 boolean_t mac_started = B_FALSE; 2273 boolean_t bcast_added = B_FALSE; 2274 boolean_t nactiveclients_added = B_FALSE; 2275 flow_entry_t *flent; 2276 int err = 0; 2277 boolean_t no_unicast; 2278 2279 no_unicast = mcip->mci_state_flags & MCIS_NO_UNICAST_ADDR; 2280 2281 if ((err = mac_start((mac_handle_t)mip)) != 0) 2282 goto bail; 2283 2284 mac_started = B_TRUE; 2285 2286 /* add the MAC client to the broadcast address group by default */ 2287 if (mip->mi_type->mt_brdcst_addr != NULL) { 2288 err = mac_bcast_add(mcip, mip->mi_type->mt_brdcst_addr, vid, 2289 MAC_ADDRTYPE_BROADCAST); 2290 if (err != 0) 2291 goto bail; 2292 bcast_added = B_TRUE; 2293 } 2294 2295 /* 2296 * If this is the first unicast address addition for this 2297 * client, reuse the pre-allocated larval flow entry associated with 2298 * the MAC client. 2299 */ 2300 flent = (mcip->mci_nflents == 0) ? mcip->mci_flent : NULL; 2301 2302 /* We are configuring the unicast flow now */ 2303 if (!MCIP_DATAPATH_SETUP(mcip)) { 2304 2305 if (mrp != NULL) { 2306 MAC_CLIENT_SET_PRIORITY_RANGE(mcip, 2307 (mrp->mrp_mask & MRP_PRIORITY) ? mrp->mrp_priority : 2308 MPL_LINK_DEFAULT); 2309 } 2310 if ((err = mac_unicast_flow_create(mcip, mac_addr, vid, 2311 isprimary, B_TRUE, &flent, mrp)) != 0) 2312 goto bail; 2313 2314 mip->mi_nactiveclients++; 2315 nactiveclients_added = B_TRUE; 2316 2317 /* 2318 * This will allocate the RX ring group if possible for the 2319 * flow and program the software classifier as needed. 2320 */ 2321 if ((err = mac_datapath_setup(mcip, flent, SRST_LINK)) != 0) 2322 goto bail; 2323 2324 if (no_unicast) 2325 goto done_setup; 2326 /* 2327 * The unicast MAC address must have been added successfully. 2328 */ 2329 ASSERT(mcip->mci_unicast != NULL); 2330 /* 2331 * Push down the sub-flows that were defined on this link 2332 * hitherto. The flows are added to the active flow table 2333 * and SRS, softrings etc. are created as needed. 2334 */ 2335 mac_link_init_flows((mac_client_handle_t)mcip); 2336 } else { 2337 mac_address_t *map = mcip->mci_unicast; 2338 2339 ASSERT(!no_unicast); 2340 /* 2341 * A unicast flow already exists for that MAC client, 2342 * this flow must be the same mac address but with 2343 * different VID. It has been checked by mac_addr_in_use(). 2344 * 2345 * We will use the SRS etc. from the mci_flent. Note that 2346 * We don't need to create kstat for this as except for 2347 * the fdesc, everything will be used from in the 1st flent. 2348 */ 2349 2350 if (bcmp(mac_addr, map->ma_addr, map->ma_len) != 0) { 2351 err = EINVAL; 2352 goto bail; 2353 } 2354 2355 if ((err = mac_unicast_flow_create(mcip, mac_addr, vid, 2356 isprimary, B_FALSE, &flent, NULL)) != 0) { 2357 goto bail; 2358 } 2359 if ((err = mac_flow_add(mip->mi_flow_tab, flent)) != 0) { 2360 FLOW_FINAL_REFRELE(flent); 2361 goto bail; 2362 } 2363 2364 /* update the multicast group for this vid */ 2365 mac_client_bcast_refresh(mcip, mac_client_update_mcast, 2366 (void *)flent, B_TRUE); 2367 2368 } 2369 2370 /* populate the shared MAC address */ 2371 muip->mui_map = mcip->mci_unicast; 2372 2373 rw_enter(&mcip->mci_rw_lock, RW_WRITER); 2374 muip->mui_next = mcip->mci_unicast_list; 2375 mcip->mci_unicast_list = muip; 2376 rw_exit(&mcip->mci_rw_lock); 2377 2378 done_setup: 2379 /* 2380 * First add the flent to the flow list of this mcip. Then set 2381 * the mip's mi_single_active_client if needed. The Rx path assumes 2382 * that mip->mi_single_active_client will always have an associated 2383 * flent. 2384 */ 2385 mac_client_add_to_flow_list(mcip, flent); 2386 if (nactiveclients_added) 2387 mac_update_single_active_client(mip); 2388 /* 2389 * Trigger a renegotiation of the capabilities when the number of 2390 * active clients changes from 1 to 2, since some of the capabilities 2391 * might have to be disabled. Also send a MAC_NOTE_LINK notification 2392 * to all the MAC clients whenever physical link is DOWN. 2393 */ 2394 if (mip->mi_nactiveclients == 2) { 2395 mac_capab_update((mac_handle_t)mip); 2396 mac_virtual_link_update(mip); 2397 } 2398 /* 2399 * Now that the setup is complete, clear the INCIPIENT flag. 2400 * The flag was set to avoid incoming packets seeing inconsistent 2401 * structures while the setup was in progress. Clear the mci_tx_flag 2402 * by calling mac_tx_client_block. It is possible that 2403 * mac_unicast_remove was called prior to this mac_unicast_add which 2404 * could have set the MCI_TX_QUIESCE flag. 2405 */ 2406 if (flent->fe_rx_ring_group != NULL) 2407 mac_rx_group_unmark(flent->fe_rx_ring_group, MR_INCIPIENT); 2408 FLOW_UNMARK(flent, FE_INCIPIENT); 2409 FLOW_UNMARK(flent, FE_MC_NO_DATAPATH); 2410 mac_tx_client_unblock(mcip); 2411 return (0); 2412 bail: 2413 if (bcast_added) 2414 mac_bcast_delete(mcip, mip->mi_type->mt_brdcst_addr, vid); 2415 2416 if (nactiveclients_added) 2417 mip->mi_nactiveclients--; 2418 2419 if (mac_started) 2420 mac_stop((mac_handle_t)mip); 2421 2422 return (err); 2423 } 2424 2425 /* 2426 * Return the passive primary MAC client, if present. The passive client is 2427 * a stand-by client that has the same unicast address as another that is 2428 * currenly active. Once the active client goes away, the passive client 2429 * becomes active. 2430 */ 2431 static mac_client_impl_t * 2432 mac_get_passive_primary_client(mac_impl_t *mip) 2433 { 2434 mac_client_impl_t *mcip; 2435 2436 for (mcip = mip->mi_clients_list; mcip != NULL; 2437 mcip = mcip->mci_client_next) { 2438 if (mac_is_primary_client(mcip) && 2439 (mcip->mci_flags & MAC_CLIENT_FLAGS_PASSIVE_PRIMARY) != 0) { 2440 return (mcip); 2441 } 2442 } 2443 return (NULL); 2444 } 2445 2446 /* 2447 * Add a new unicast address to the MAC client. 2448 * 2449 * The MAC address can be specified either by value, or the MAC client 2450 * can specify that it wants to use the primary MAC address of the 2451 * underlying MAC. See the introductory comments at the beginning 2452 * of this file for more more information on primary MAC addresses. 2453 * 2454 * Note also the tuple (MAC address, VID) must be unique 2455 * for the MAC clients defined on top of the same underlying MAC 2456 * instance, unless the MAC_UNICAST_NODUPCHECK is specified. 2457 * 2458 * In no case can a client use the PVID for the MAC, if the MAC has one set. 2459 */ 2460 int 2461 i_mac_unicast_add(mac_client_handle_t mch, uint8_t *mac_addr, uint16_t flags, 2462 mac_unicast_handle_t *mah, uint16_t vid, mac_diag_t *diag) 2463 { 2464 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 2465 mac_impl_t *mip = mcip->mci_mip; 2466 int err; 2467 uint_t mac_len = mip->mi_type->mt_addr_length; 2468 boolean_t check_dups = !(flags & MAC_UNICAST_NODUPCHECK); 2469 boolean_t fastpath_disabled = B_FALSE; 2470 boolean_t is_primary = (flags & MAC_UNICAST_PRIMARY); 2471 boolean_t is_unicast_hw = (flags & MAC_UNICAST_HW); 2472 mac_resource_props_t *mrp; 2473 boolean_t passive_client = B_FALSE; 2474 mac_unicast_impl_t *muip; 2475 boolean_t is_vnic_primary = 2476 (flags & MAC_UNICAST_VNIC_PRIMARY); 2477 2478 /* when VID is non-zero, the underlying MAC can not be VNIC */ 2479 ASSERT(!((mip->mi_state_flags & MIS_IS_VNIC) && (vid != 0))); 2480 2481 /* 2482 * Can't unicast add if the client asked only for minimal datapath 2483 * setup. 2484 */ 2485 if (mcip->mci_state_flags & MCIS_NO_UNICAST_ADDR) 2486 return (ENOTSUP); 2487 2488 /* 2489 * Check for an attempted use of the current Port VLAN ID, if enabled. 2490 * No client may use it. 2491 */ 2492 if (mip->mi_pvid != 0 && vid == mip->mi_pvid) 2493 return (EBUSY); 2494 2495 /* 2496 * Check whether it's the primary client and flag it. 2497 */ 2498 if (!(mcip->mci_state_flags & MCIS_IS_VNIC) && is_primary && vid == 0) 2499 mcip->mci_flags |= MAC_CLIENT_FLAGS_PRIMARY; 2500 2501 /* 2502 * is_vnic_primary is true when we come here as a VLAN VNIC 2503 * which uses the primary mac client's address but with a non-zero 2504 * VID. In this case the MAC address is not specified by an upper 2505 * MAC client. 2506 */ 2507 if ((mcip->mci_state_flags & MCIS_IS_VNIC) && is_primary && 2508 !is_vnic_primary) { 2509 /* 2510 * The address is being set by the upper MAC client 2511 * of a VNIC. The MAC address was already set by the 2512 * VNIC driver during VNIC creation. 2513 * 2514 * Note: a VNIC has only one MAC address. We return 2515 * the MAC unicast address handle of the lower MAC client 2516 * corresponding to the VNIC. We allocate a new entry 2517 * which is flagged appropriately, so that mac_unicast_remove() 2518 * doesn't attempt to free the original entry that 2519 * was allocated by the VNIC driver. 2520 */ 2521 ASSERT(mcip->mci_unicast != NULL); 2522 2523 /* Check for VLAN flags, if present */ 2524 if ((flags & MAC_UNICAST_TAG_DISABLE) != 0) 2525 mcip->mci_state_flags |= MCIS_TAG_DISABLE; 2526 2527 if ((flags & MAC_UNICAST_STRIP_DISABLE) != 0) 2528 mcip->mci_state_flags |= MCIS_STRIP_DISABLE; 2529 2530 if ((flags & MAC_UNICAST_DISABLE_TX_VID_CHECK) != 0) 2531 mcip->mci_state_flags |= MCIS_DISABLE_TX_VID_CHECK; 2532 2533 /* 2534 * Ensure that the primary unicast address of the VNIC 2535 * is added only once unless we have the 2536 * MAC_CLIENT_FLAGS_MULTI_PRIMARY set (and this is not 2537 * a passive MAC client). 2538 */ 2539 if ((mcip->mci_flags & MAC_CLIENT_FLAGS_VNIC_PRIMARY) != 0) { 2540 if ((mcip->mci_flags & 2541 MAC_CLIENT_FLAGS_MULTI_PRIMARY) == 0 || 2542 (mcip->mci_flags & 2543 MAC_CLIENT_FLAGS_PASSIVE_PRIMARY) != 0) { 2544 return (EBUSY); 2545 } 2546 mcip->mci_flags |= MAC_CLIENT_FLAGS_PASSIVE_PRIMARY; 2547 passive_client = B_TRUE; 2548 } 2549 2550 mcip->mci_flags |= MAC_CLIENT_FLAGS_VNIC_PRIMARY; 2551 2552 /* 2553 * Create a handle for vid 0. 2554 */ 2555 ASSERT(vid == 0); 2556 muip = kmem_zalloc(sizeof (mac_unicast_impl_t), KM_SLEEP); 2557 muip->mui_vid = vid; 2558 *mah = (mac_unicast_handle_t)muip; 2559 /* 2560 * This will be used by the caller to defer setting the 2561 * rx functions. 2562 */ 2563 if (passive_client) 2564 return (EAGAIN); 2565 return (0); 2566 } 2567 2568 /* primary MAC clients cannot be opened on top of anchor VNICs */ 2569 if ((is_vnic_primary || is_primary) && 2570 i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_ANCHOR_VNIC, NULL)) { 2571 return (ENXIO); 2572 } 2573 2574 /* 2575 * If this is a VNIC/VLAN, disable softmac fast-path. 2576 */ 2577 if (mcip->mci_state_flags & MCIS_IS_VNIC) { 2578 err = mac_fastpath_disable((mac_handle_t)mip); 2579 if (err != 0) 2580 return (err); 2581 fastpath_disabled = B_TRUE; 2582 } 2583 2584 /* 2585 * Return EBUSY if: 2586 * - there is an exclusively active mac client exists. 2587 * - this is an exclusive active mac client but 2588 * a. there is already active mac clients exist, or 2589 * b. fastpath streams are already plumbed on this legacy device 2590 * - the mac creator has disallowed active mac clients. 2591 */ 2592 if (mip->mi_state_flags & (MIS_EXCLUSIVE|MIS_NO_ACTIVE)) { 2593 if (fastpath_disabled) 2594 mac_fastpath_enable((mac_handle_t)mip); 2595 return (EBUSY); 2596 } 2597 2598 if (mcip->mci_state_flags & MCIS_EXCLUSIVE) { 2599 ASSERT(!fastpath_disabled); 2600 if (mip->mi_nactiveclients != 0) 2601 return (EBUSY); 2602 2603 if ((mip->mi_state_flags & MIS_LEGACY) && 2604 !(mip->mi_capab_legacy.ml_active_set(mip->mi_driver))) { 2605 return (EBUSY); 2606 } 2607 mip->mi_state_flags |= MIS_EXCLUSIVE; 2608 } 2609 2610 mrp = kmem_zalloc(sizeof (*mrp), KM_SLEEP); 2611 if (is_primary && !(mcip->mci_state_flags & (MCIS_IS_VNIC | 2612 MCIS_IS_AGGR_PORT))) { 2613 /* 2614 * Apply the property cached in the mac_impl_t to the primary 2615 * mac client. If the mac client is a VNIC or an aggregation 2616 * port, its property should be set in the mcip when the 2617 * VNIC/aggr was created. 2618 */ 2619 mac_get_resources((mac_handle_t)mip, mrp); 2620 (void) mac_client_set_resources(mch, mrp); 2621 } else if (mcip->mci_state_flags & MCIS_IS_VNIC) { 2622 /* 2623 * This is a primary VLAN client, we don't support 2624 * specifying rings property for this as it inherits the 2625 * rings property from its MAC. 2626 */ 2627 if (is_vnic_primary) { 2628 mac_resource_props_t *vmrp; 2629 2630 vmrp = MCIP_RESOURCE_PROPS(mcip); 2631 if (vmrp->mrp_mask & MRP_RX_RINGS || 2632 vmrp->mrp_mask & MRP_TX_RINGS) { 2633 if (fastpath_disabled) 2634 mac_fastpath_enable((mac_handle_t)mip); 2635 kmem_free(mrp, sizeof (*mrp)); 2636 return (ENOTSUP); 2637 } 2638 /* 2639 * Additionally we also need to inherit any 2640 * rings property from the MAC. 2641 */ 2642 mac_get_resources((mac_handle_t)mip, mrp); 2643 if (mrp->mrp_mask & MRP_RX_RINGS) { 2644 vmrp->mrp_mask |= MRP_RX_RINGS; 2645 vmrp->mrp_nrxrings = mrp->mrp_nrxrings; 2646 } 2647 if (mrp->mrp_mask & MRP_TX_RINGS) { 2648 vmrp->mrp_mask |= MRP_TX_RINGS; 2649 vmrp->mrp_ntxrings = mrp->mrp_ntxrings; 2650 } 2651 } 2652 bcopy(MCIP_RESOURCE_PROPS(mcip), mrp, sizeof (*mrp)); 2653 } 2654 2655 muip = kmem_zalloc(sizeof (mac_unicast_impl_t), KM_SLEEP); 2656 muip->mui_vid = vid; 2657 2658 if (is_primary || is_vnic_primary) { 2659 mac_addr = mip->mi_addr; 2660 } else { 2661 2662 /* 2663 * Verify the validity of the specified MAC addresses value. 2664 */ 2665 if (!mac_unicst_verify((mac_handle_t)mip, mac_addr, mac_len)) { 2666 *diag = MAC_DIAG_MACADDR_INVALID; 2667 err = EINVAL; 2668 goto bail_out; 2669 } 2670 2671 /* 2672 * Make sure that the specified MAC address is different 2673 * than the unicast MAC address of the underlying NIC. 2674 */ 2675 if (check_dups && bcmp(mip->mi_addr, mac_addr, mac_len) == 0) { 2676 *diag = MAC_DIAG_MACADDR_NIC; 2677 err = EINVAL; 2678 goto bail_out; 2679 } 2680 } 2681 2682 /* 2683 * Set the flags here so that if this is a passive client, we 2684 * can return and set it when we call mac_client_datapath_setup 2685 * when this becomes the active client. If we defer to using these 2686 * flags to mac_client_datapath_setup, then for a passive client, 2687 * we'd have to store the flags somewhere (probably fe_flags) 2688 * and then use it. 2689 */ 2690 if (!MCIP_DATAPATH_SETUP(mcip)) { 2691 if (is_unicast_hw) { 2692 /* 2693 * The client requires a hardware MAC address slot 2694 * for that unicast address. Since we support only 2695 * one unicast MAC address per client, flag the 2696 * MAC client itself. 2697 */ 2698 mcip->mci_state_flags |= MCIS_UNICAST_HW; 2699 } 2700 2701 /* Check for VLAN flags, if present */ 2702 if ((flags & MAC_UNICAST_TAG_DISABLE) != 0) 2703 mcip->mci_state_flags |= MCIS_TAG_DISABLE; 2704 2705 if ((flags & MAC_UNICAST_STRIP_DISABLE) != 0) 2706 mcip->mci_state_flags |= MCIS_STRIP_DISABLE; 2707 2708 if ((flags & MAC_UNICAST_DISABLE_TX_VID_CHECK) != 0) 2709 mcip->mci_state_flags |= MCIS_DISABLE_TX_VID_CHECK; 2710 } else { 2711 /* 2712 * Assert that the specified flags are consistent with the 2713 * flags specified by previous calls to mac_unicast_add(). 2714 */ 2715 ASSERT(((flags & MAC_UNICAST_TAG_DISABLE) != 0 && 2716 (mcip->mci_state_flags & MCIS_TAG_DISABLE) != 0) || 2717 ((flags & MAC_UNICAST_TAG_DISABLE) == 0 && 2718 (mcip->mci_state_flags & MCIS_TAG_DISABLE) == 0)); 2719 2720 ASSERT(((flags & MAC_UNICAST_STRIP_DISABLE) != 0 && 2721 (mcip->mci_state_flags & MCIS_STRIP_DISABLE) != 0) || 2722 ((flags & MAC_UNICAST_STRIP_DISABLE) == 0 && 2723 (mcip->mci_state_flags & MCIS_STRIP_DISABLE) == 0)); 2724 2725 ASSERT(((flags & MAC_UNICAST_DISABLE_TX_VID_CHECK) != 0 && 2726 (mcip->mci_state_flags & MCIS_DISABLE_TX_VID_CHECK) != 0) || 2727 ((flags & MAC_UNICAST_DISABLE_TX_VID_CHECK) == 0 && 2728 (mcip->mci_state_flags & MCIS_DISABLE_TX_VID_CHECK) == 0)); 2729 2730 /* 2731 * Make sure the client is consistent about its requests 2732 * for MAC addresses. I.e. all requests from the clients 2733 * must have the MAC_UNICAST_HW flag set or clear. 2734 */ 2735 if (((mcip->mci_state_flags & MCIS_UNICAST_HW) != 0 && 2736 !is_unicast_hw) || 2737 ((mcip->mci_state_flags & MCIS_UNICAST_HW) == 0 && 2738 is_unicast_hw)) { 2739 err = EINVAL; 2740 goto bail_out; 2741 } 2742 } 2743 /* 2744 * Make sure the MAC address is not already used by 2745 * another MAC client defined on top of the same 2746 * underlying NIC. Unless we have MAC_CLIENT_FLAGS_MULTI_PRIMARY 2747 * set when we allow a passive client to be present which will 2748 * be activated when the currently active client goes away - this 2749 * works only with primary addresses. 2750 */ 2751 if ((check_dups || is_primary || is_vnic_primary) && 2752 mac_addr_in_use(mip, mac_addr, vid)) { 2753 /* 2754 * Must have set the multiple primary address flag when 2755 * we did a mac_client_open AND this should be a primary 2756 * MAC client AND there should not already be a passive 2757 * primary. If all is true then we let this succeed 2758 * even if the address is a dup. 2759 */ 2760 if ((mcip->mci_flags & MAC_CLIENT_FLAGS_MULTI_PRIMARY) == 0 || 2761 (mcip->mci_flags & MAC_CLIENT_FLAGS_PRIMARY) == 0 || 2762 mac_get_passive_primary_client(mip) != NULL) { 2763 *diag = MAC_DIAG_MACADDR_INUSE; 2764 err = EEXIST; 2765 goto bail_out; 2766 } 2767 ASSERT((mcip->mci_flags & 2768 MAC_CLIENT_FLAGS_PASSIVE_PRIMARY) == 0); 2769 mcip->mci_flags |= MAC_CLIENT_FLAGS_PASSIVE_PRIMARY; 2770 kmem_free(mrp, sizeof (*mrp)); 2771 2772 /* 2773 * Stash the unicast address handle, we will use it when 2774 * we set up the passive client. 2775 */ 2776 mcip->mci_p_unicast_list = muip; 2777 *mah = (mac_unicast_handle_t)muip; 2778 return (0); 2779 } 2780 2781 err = mac_client_datapath_setup(mcip, vid, mac_addr, mrp, 2782 is_primary || is_vnic_primary, muip); 2783 if (err != 0) 2784 goto bail_out; 2785 2786 kmem_free(mrp, sizeof (*mrp)); 2787 *mah = (mac_unicast_handle_t)muip; 2788 return (0); 2789 2790 bail_out: 2791 if (fastpath_disabled) 2792 mac_fastpath_enable((mac_handle_t)mip); 2793 if (mcip->mci_state_flags & MCIS_EXCLUSIVE) { 2794 mip->mi_state_flags &= ~MIS_EXCLUSIVE; 2795 if (mip->mi_state_flags & MIS_LEGACY) { 2796 mip->mi_capab_legacy.ml_active_clear( 2797 mip->mi_driver); 2798 } 2799 } 2800 kmem_free(mrp, sizeof (*mrp)); 2801 kmem_free(muip, sizeof (mac_unicast_impl_t)); 2802 return (err); 2803 } 2804 2805 /* 2806 * Wrapper function to mac_unicast_add when we want to have the same mac 2807 * client open for two instances, one that is currently active and another 2808 * that will become active when the current one is removed. In this case 2809 * mac_unicast_add will return EGAIN and we will save the rx function and 2810 * arg which will be used when we activate the passive client in 2811 * mac_unicast_remove. 2812 */ 2813 int 2814 mac_unicast_add_set_rx(mac_client_handle_t mch, uint8_t *mac_addr, 2815 uint16_t flags, mac_unicast_handle_t *mah, uint16_t vid, mac_diag_t *diag, 2816 mac_rx_t rx_fn, void *arg) 2817 { 2818 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 2819 uint_t err; 2820 2821 err = mac_unicast_add(mch, mac_addr, flags, mah, vid, diag); 2822 if (err != 0 && err != EAGAIN) 2823 return (err); 2824 if (err == EAGAIN) { 2825 if (rx_fn != NULL) { 2826 mcip->mci_rx_p_fn = rx_fn; 2827 mcip->mci_rx_p_arg = arg; 2828 } 2829 return (0); 2830 } 2831 if (rx_fn != NULL) 2832 mac_rx_set(mch, rx_fn, arg); 2833 return (err); 2834 } 2835 2836 int 2837 mac_unicast_add(mac_client_handle_t mch, uint8_t *mac_addr, uint16_t flags, 2838 mac_unicast_handle_t *mah, uint16_t vid, mac_diag_t *diag) 2839 { 2840 mac_impl_t *mip = ((mac_client_impl_t *)mch)->mci_mip; 2841 uint_t err; 2842 2843 i_mac_perim_enter(mip); 2844 err = i_mac_unicast_add(mch, mac_addr, flags, mah, vid, diag); 2845 i_mac_perim_exit(mip); 2846 2847 return (err); 2848 } 2849 2850 static void 2851 mac_client_datapath_teardown(mac_client_handle_t mch, mac_unicast_impl_t *muip, 2852 flow_entry_t *flent) 2853 { 2854 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 2855 mac_impl_t *mip = mcip->mci_mip; 2856 boolean_t no_unicast; 2857 2858 /* 2859 * If we have not added a unicast address for this MAC client, just 2860 * teardown the datapath. 2861 */ 2862 no_unicast = mcip->mci_state_flags & MCIS_NO_UNICAST_ADDR; 2863 2864 if (!no_unicast) { 2865 /* 2866 * We would have initialized subflows etc. only if we brought 2867 * up the primary client and set the unicast unicast address 2868 * etc. Deactivate the flows. The flow entry will be removed 2869 * from the active flow tables, and the associated SRS, 2870 * softrings etc will be deleted. But the flow entry itself 2871 * won't be destroyed, instead it will continue to be archived 2872 * off the the global flow hash list, for a possible future 2873 * activation when say IP is plumbed again. 2874 */ 2875 mac_link_release_flows(mch); 2876 } 2877 mip->mi_nactiveclients--; 2878 mac_update_single_active_client(mip); 2879 2880 /* Tear down the data path */ 2881 mac_datapath_teardown(mcip, mcip->mci_flent, SRST_LINK); 2882 2883 /* 2884 * Prevent any future access to the flow entry through the mci_flent 2885 * pointer by setting the mci_flent to NULL. Access to mci_flent in 2886 * mac_bcast_send is also under mi_rw_lock. 2887 */ 2888 rw_enter(&mip->mi_rw_lock, RW_WRITER); 2889 flent = mcip->mci_flent; 2890 mac_client_remove_flow_from_list(mcip, flent); 2891 2892 if (mcip->mci_state_flags & MCIS_DESC_LOGGED) 2893 mcip->mci_state_flags &= ~MCIS_DESC_LOGGED; 2894 2895 /* 2896 * This is the last unicast address being removed and there shouldn't 2897 * be any outbound data threads at this point coming down from mac 2898 * clients. We have waited for the data threads to finish before 2899 * starting dld_str_detach. Non-data threads must access TX SRS 2900 * under mi_rw_lock. 2901 */ 2902 rw_exit(&mip->mi_rw_lock); 2903 2904 /* 2905 * Don't use FLOW_MARK with FE_MC_NO_DATAPATH, as the flow might 2906 * contain other flags, such as FE_CONDEMNED, which we need to 2907 * cleared. We don't call mac_flow_cleanup() for this unicast 2908 * flow as we have a already cleaned up SRSs etc. (via the teadown 2909 * path). We just clear the stats and reset the initial callback 2910 * function, the rest will be set when we call mac_flow_create, 2911 * if at all. 2912 */ 2913 mutex_enter(&flent->fe_lock); 2914 ASSERT(flent->fe_refcnt == 1 && flent->fe_mbg == NULL && 2915 flent->fe_tx_srs == NULL && flent->fe_rx_srs_cnt == 0); 2916 flent->fe_flags = FE_MC_NO_DATAPATH; 2917 flow_stat_destroy(flent); 2918 mac_misc_stat_delete(flent); 2919 2920 /* Initialize the receiver function to a safe routine */ 2921 flent->fe_cb_fn = (flow_fn_t)mac_pkt_drop; 2922 flent->fe_cb_arg1 = NULL; 2923 flent->fe_cb_arg2 = NULL; 2924 2925 flent->fe_index = -1; 2926 mutex_exit(&flent->fe_lock); 2927 2928 if (mip->mi_type->mt_brdcst_addr != NULL) { 2929 ASSERT(muip != NULL || no_unicast); 2930 mac_bcast_delete(mcip, mip->mi_type->mt_brdcst_addr, 2931 muip != NULL ? muip->mui_vid : VLAN_ID_NONE); 2932 } 2933 2934 if (mip->mi_nactiveclients == 1) { 2935 mac_capab_update((mac_handle_t)mip); 2936 mac_virtual_link_update(mip); 2937 } 2938 2939 if (mcip->mci_state_flags & MCIS_EXCLUSIVE) { 2940 mip->mi_state_flags &= ~MIS_EXCLUSIVE; 2941 2942 if (mip->mi_state_flags & MIS_LEGACY) 2943 mip->mi_capab_legacy.ml_active_clear(mip->mi_driver); 2944 } 2945 2946 mcip->mci_state_flags &= ~MCIS_UNICAST_HW; 2947 2948 if (mcip->mci_state_flags & MCIS_TAG_DISABLE) 2949 mcip->mci_state_flags &= ~MCIS_TAG_DISABLE; 2950 2951 if (mcip->mci_state_flags & MCIS_STRIP_DISABLE) 2952 mcip->mci_state_flags &= ~MCIS_STRIP_DISABLE; 2953 2954 if (mcip->mci_state_flags & MCIS_DISABLE_TX_VID_CHECK) 2955 mcip->mci_state_flags &= ~MCIS_DISABLE_TX_VID_CHECK; 2956 2957 if (muip != NULL) 2958 kmem_free(muip, sizeof (mac_unicast_impl_t)); 2959 mac_protect_cancel_timer(mcip); 2960 mac_protect_flush_dynamic(mcip); 2961 2962 bzero(&mcip->mci_misc_stat, sizeof (mcip->mci_misc_stat)); 2963 /* 2964 * Disable fastpath if this is a VNIC or a VLAN. 2965 */ 2966 if (mcip->mci_state_flags & MCIS_IS_VNIC) 2967 mac_fastpath_enable((mac_handle_t)mip); 2968 mac_stop((mac_handle_t)mip); 2969 } 2970 2971 /* 2972 * Remove a MAC address which was previously added by mac_unicast_add(). 2973 */ 2974 int 2975 mac_unicast_remove(mac_client_handle_t mch, mac_unicast_handle_t mah) 2976 { 2977 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 2978 mac_unicast_impl_t *muip = (mac_unicast_impl_t *)mah; 2979 mac_unicast_impl_t *pre; 2980 mac_impl_t *mip = mcip->mci_mip; 2981 flow_entry_t *flent; 2982 uint16_t mui_vid; 2983 2984 i_mac_perim_enter(mip); 2985 if (mcip->mci_flags & MAC_CLIENT_FLAGS_VNIC_PRIMARY) { 2986 /* 2987 * Called made by the upper MAC client of a VNIC. 2988 * There's nothing much to do, the unicast address will 2989 * be removed by the VNIC driver when the VNIC is deleted, 2990 * but let's ensure that all our transmit is done before 2991 * the client does a mac_client_stop lest it trigger an 2992 * assert in the driver. 2993 */ 2994 ASSERT(muip->mui_vid == 0); 2995 2996 mac_tx_client_flush(mcip); 2997 2998 if ((mcip->mci_flags & MAC_CLIENT_FLAGS_PASSIVE_PRIMARY) != 0) { 2999 mcip->mci_flags &= ~MAC_CLIENT_FLAGS_PASSIVE_PRIMARY; 3000 if (mcip->mci_rx_p_fn != NULL) { 3001 mac_rx_set(mch, mcip->mci_rx_p_fn, 3002 mcip->mci_rx_p_arg); 3003 mcip->mci_rx_p_fn = NULL; 3004 mcip->mci_rx_p_arg = NULL; 3005 } 3006 kmem_free(muip, sizeof (mac_unicast_impl_t)); 3007 i_mac_perim_exit(mip); 3008 return (0); 3009 } 3010 mcip->mci_flags &= ~MAC_CLIENT_FLAGS_VNIC_PRIMARY; 3011 3012 if (mcip->mci_state_flags & MCIS_TAG_DISABLE) 3013 mcip->mci_state_flags &= ~MCIS_TAG_DISABLE; 3014 3015 if (mcip->mci_state_flags & MCIS_STRIP_DISABLE) 3016 mcip->mci_state_flags &= ~MCIS_STRIP_DISABLE; 3017 3018 if (mcip->mci_state_flags & MCIS_DISABLE_TX_VID_CHECK) 3019 mcip->mci_state_flags &= ~MCIS_DISABLE_TX_VID_CHECK; 3020 3021 kmem_free(muip, sizeof (mac_unicast_impl_t)); 3022 i_mac_perim_exit(mip); 3023 return (0); 3024 } 3025 3026 ASSERT(muip != NULL); 3027 3028 /* 3029 * We are removing a passive client, we haven't setup the datapath 3030 * for this yet, so nothing much to do. 3031 */ 3032 if ((mcip->mci_flags & MAC_CLIENT_FLAGS_PASSIVE_PRIMARY) != 0) { 3033 3034 ASSERT((mcip->mci_flent->fe_flags & FE_MC_NO_DATAPATH) != 0); 3035 ASSERT(mcip->mci_p_unicast_list == muip); 3036 3037 mcip->mci_flags &= ~MAC_CLIENT_FLAGS_PASSIVE_PRIMARY; 3038 3039 mcip->mci_p_unicast_list = NULL; 3040 mcip->mci_rx_p_fn = NULL; 3041 mcip->mci_rx_p_arg = NULL; 3042 3043 mcip->mci_state_flags &= ~MCIS_UNICAST_HW; 3044 3045 if (mcip->mci_state_flags & MCIS_TAG_DISABLE) 3046 mcip->mci_state_flags &= ~MCIS_TAG_DISABLE; 3047 3048 if (mcip->mci_state_flags & MCIS_STRIP_DISABLE) 3049 mcip->mci_state_flags &= ~MCIS_STRIP_DISABLE; 3050 3051 if (mcip->mci_state_flags & MCIS_DISABLE_TX_VID_CHECK) 3052 mcip->mci_state_flags &= ~MCIS_DISABLE_TX_VID_CHECK; 3053 3054 kmem_free(muip, sizeof (mac_unicast_impl_t)); 3055 i_mac_perim_exit(mip); 3056 return (0); 3057 } 3058 /* 3059 * Remove the VID from the list of client's VIDs. 3060 */ 3061 pre = mcip->mci_unicast_list; 3062 if (muip == pre) { 3063 mcip->mci_unicast_list = muip->mui_next; 3064 } else { 3065 while ((pre->mui_next != NULL) && (pre->mui_next != muip)) 3066 pre = pre->mui_next; 3067 ASSERT(pre->mui_next == muip); 3068 rw_enter(&mcip->mci_rw_lock, RW_WRITER); 3069 pre->mui_next = muip->mui_next; 3070 rw_exit(&mcip->mci_rw_lock); 3071 } 3072 3073 if (!mac_client_single_rcvr(mcip)) { 3074 /* 3075 * This MAC client is shared by more than one unicast 3076 * addresses, so we will just remove the flent 3077 * corresponding to the address being removed. We don't invoke 3078 * mac_rx_classify_flow_rem() since the additional flow is 3079 * not associated with its own separate set of SRS and rings, 3080 * and these constructs are still needed for the remaining 3081 * flows. 3082 */ 3083 flent = mac_client_get_flow(mcip, muip); 3084 ASSERT(flent != NULL); 3085 3086 /* 3087 * The first one is disappearing, need to make sure 3088 * we replace it with another from the list of 3089 * shared clients. 3090 */ 3091 if (flent == mcip->mci_flent) 3092 flent = mac_client_swap_mciflent(mcip); 3093 mac_client_remove_flow_from_list(mcip, flent); 3094 mac_flow_remove(mip->mi_flow_tab, flent, B_FALSE); 3095 mac_flow_wait(flent, FLOW_DRIVER_UPCALL); 3096 3097 /* 3098 * The multicast groups that were added by the client so 3099 * far must be removed from the brodcast domain corresponding 3100 * to the VID being removed. 3101 */ 3102 mac_client_bcast_refresh(mcip, mac_client_update_mcast, 3103 (void *)flent, B_FALSE); 3104 3105 if (mip->mi_type->mt_brdcst_addr != NULL) { 3106 mac_bcast_delete(mcip, mip->mi_type->mt_brdcst_addr, 3107 muip->mui_vid); 3108 } 3109 3110 FLOW_FINAL_REFRELE(flent); 3111 ASSERT(!(mcip->mci_state_flags & MCIS_EXCLUSIVE)); 3112 /* 3113 * Enable fastpath if this is a VNIC or a VLAN. 3114 */ 3115 if (mcip->mci_state_flags & MCIS_IS_VNIC) 3116 mac_fastpath_enable((mac_handle_t)mip); 3117 mac_stop((mac_handle_t)mip); 3118 i_mac_perim_exit(mip); 3119 return (0); 3120 } 3121 3122 mui_vid = muip->mui_vid; 3123 mac_client_datapath_teardown(mch, muip, flent); 3124 3125 if ((mcip->mci_flags & MAC_CLIENT_FLAGS_PRIMARY) && mui_vid == 0) { 3126 mcip->mci_flags &= ~MAC_CLIENT_FLAGS_PRIMARY; 3127 } else { 3128 i_mac_perim_exit(mip); 3129 return (0); 3130 } 3131 3132 /* 3133 * If we are removing the primary, check if we have a passive primary 3134 * client that we need to activate now. 3135 */ 3136 mcip = mac_get_passive_primary_client(mip); 3137 if (mcip != NULL) { 3138 mac_resource_props_t *mrp; 3139 mac_unicast_impl_t *muip; 3140 3141 mcip->mci_flags &= ~MAC_CLIENT_FLAGS_PASSIVE_PRIMARY; 3142 mrp = kmem_zalloc(sizeof (*mrp), KM_SLEEP); 3143 3144 /* 3145 * Apply the property cached in the mac_impl_t to the 3146 * primary mac client. 3147 */ 3148 mac_get_resources((mac_handle_t)mip, mrp); 3149 (void) mac_client_set_resources(mch, mrp); 3150 ASSERT(mcip->mci_p_unicast_list != NULL); 3151 muip = mcip->mci_p_unicast_list; 3152 mcip->mci_p_unicast_list = NULL; 3153 if (mac_client_datapath_setup(mcip, VLAN_ID_NONE, 3154 mip->mi_addr, mrp, B_TRUE, muip) == 0) { 3155 if (mcip->mci_rx_p_fn != NULL) { 3156 mac_rx_set(mch, mcip->mci_rx_p_fn, 3157 mcip->mci_rx_p_arg); 3158 mcip->mci_rx_p_fn = NULL; 3159 mcip->mci_rx_p_arg = NULL; 3160 } 3161 } else { 3162 kmem_free(muip, sizeof (mac_unicast_impl_t)); 3163 } 3164 kmem_free(mrp, sizeof (*mrp)); 3165 } 3166 i_mac_perim_exit(mip); 3167 return (0); 3168 } 3169 3170 /* 3171 * Multicast add function invoked by MAC clients. 3172 */ 3173 int 3174 mac_multicast_add(mac_client_handle_t mch, const uint8_t *addr) 3175 { 3176 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3177 mac_impl_t *mip = mcip->mci_mip; 3178 flow_entry_t *flent = mcip->mci_flent_list; 3179 flow_entry_t *prev_fe = NULL; 3180 uint16_t vid; 3181 int err = 0; 3182 3183 /* Verify the address is a valid multicast address */ 3184 if ((err = mip->mi_type->mt_ops.mtops_multicst_verify(addr, 3185 mip->mi_pdata)) != 0) 3186 return (err); 3187 3188 i_mac_perim_enter(mip); 3189 while (flent != NULL) { 3190 vid = i_mac_flow_vid(flent); 3191 3192 err = mac_bcast_add((mac_client_impl_t *)mch, addr, vid, 3193 MAC_ADDRTYPE_MULTICAST); 3194 if (err != 0) 3195 break; 3196 prev_fe = flent; 3197 flent = flent->fe_client_next; 3198 } 3199 3200 /* 3201 * If we failed adding, then undo all, rather than partial 3202 * success. 3203 */ 3204 if (flent != NULL && prev_fe != NULL) { 3205 flent = mcip->mci_flent_list; 3206 while (flent != prev_fe->fe_client_next) { 3207 vid = i_mac_flow_vid(flent); 3208 mac_bcast_delete((mac_client_impl_t *)mch, addr, vid); 3209 flent = flent->fe_client_next; 3210 } 3211 } 3212 i_mac_perim_exit(mip); 3213 return (err); 3214 } 3215 3216 /* 3217 * Multicast delete function invoked by MAC clients. 3218 */ 3219 void 3220 mac_multicast_remove(mac_client_handle_t mch, const uint8_t *addr) 3221 { 3222 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3223 mac_impl_t *mip = mcip->mci_mip; 3224 flow_entry_t *flent; 3225 uint16_t vid; 3226 3227 i_mac_perim_enter(mip); 3228 for (flent = mcip->mci_flent_list; flent != NULL; 3229 flent = flent->fe_client_next) { 3230 vid = i_mac_flow_vid(flent); 3231 mac_bcast_delete((mac_client_impl_t *)mch, addr, vid); 3232 } 3233 i_mac_perim_exit(mip); 3234 } 3235 3236 /* 3237 * When a MAC client desires to capture packets on an interface, 3238 * it registers a promiscuous call back with mac_promisc_add(). 3239 * There are three types of promiscuous callbacks: 3240 * 3241 * * MAC_CLIENT_PROMISC_ALL 3242 * Captures all packets sent and received by the MAC client, 3243 * the physical interface, as well as all other MAC clients 3244 * defined on top of the same MAC. 3245 * 3246 * * MAC_CLIENT_PROMISC_FILTERED 3247 * Captures all packets sent and received by the MAC client, 3248 * plus all multicast traffic sent and received by the phyisical 3249 * interface and the other MAC clients. 3250 * 3251 * * MAC_CLIENT_PROMISC_MULTI 3252 * Captures all broadcast and multicast packets sent and 3253 * received by the MAC clients as well as the physical interface. 3254 * 3255 * In all cases, the underlying MAC is put in promiscuous mode. 3256 */ 3257 int 3258 mac_promisc_add(mac_client_handle_t mch, mac_client_promisc_type_t type, 3259 mac_rx_t fn, void *arg, mac_promisc_handle_t *mphp, uint16_t flags) 3260 { 3261 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3262 mac_impl_t *mip = mcip->mci_mip; 3263 mac_promisc_impl_t *mpip; 3264 mac_cb_info_t *mcbi; 3265 int rc; 3266 3267 i_mac_perim_enter(mip); 3268 3269 if ((rc = mac_start((mac_handle_t)mip)) != 0) { 3270 i_mac_perim_exit(mip); 3271 return (rc); 3272 } 3273 3274 if ((mcip->mci_state_flags & MCIS_IS_VNIC) && 3275 type == MAC_CLIENT_PROMISC_ALL && 3276 (mcip->mci_protect_flags & MPT_FLAG_PROMISC_FILTERED)) { 3277 /* 3278 * The function is being invoked by the upper MAC client 3279 * of a VNIC. The VNIC should only see the traffic 3280 * it is entitled to. 3281 */ 3282 type = MAC_CLIENT_PROMISC_FILTERED; 3283 } 3284 3285 3286 /* 3287 * Turn on promiscuous mode for the underlying NIC. 3288 * This is needed even for filtered callbacks which 3289 * expect to receive all multicast traffic on the wire. 3290 * 3291 * Physical promiscuous mode should not be turned on if 3292 * MAC_PROMISC_FLAGS_NO_PHYS is set. 3293 */ 3294 if ((flags & MAC_PROMISC_FLAGS_NO_PHYS) == 0) { 3295 if ((rc = i_mac_promisc_set(mip, B_TRUE)) != 0) { 3296 mac_stop((mac_handle_t)mip); 3297 i_mac_perim_exit(mip); 3298 return (rc); 3299 } 3300 } 3301 3302 mpip = kmem_cache_alloc(mac_promisc_impl_cache, KM_SLEEP); 3303 3304 mpip->mpi_type = type; 3305 mpip->mpi_fn = fn; 3306 mpip->mpi_arg = arg; 3307 mpip->mpi_mcip = mcip; 3308 mpip->mpi_no_tx_loop = ((flags & MAC_PROMISC_FLAGS_NO_TX_LOOP) != 0); 3309 mpip->mpi_no_phys = ((flags & MAC_PROMISC_FLAGS_NO_PHYS) != 0); 3310 mpip->mpi_strip_vlan_tag = 3311 ((flags & MAC_PROMISC_FLAGS_VLAN_TAG_STRIP) != 0); 3312 mpip->mpi_no_copy = ((flags & MAC_PROMISC_FLAGS_NO_COPY) != 0); 3313 3314 mcbi = &mip->mi_promisc_cb_info; 3315 mutex_enter(mcbi->mcbi_lockp); 3316 3317 mac_callback_add(&mip->mi_promisc_cb_info, &mcip->mci_promisc_list, 3318 &mpip->mpi_mci_link); 3319 mac_callback_add(&mip->mi_promisc_cb_info, &mip->mi_promisc_list, 3320 &mpip->mpi_mi_link); 3321 3322 mutex_exit(mcbi->mcbi_lockp); 3323 3324 *mphp = (mac_promisc_handle_t)mpip; 3325 3326 if (mcip->mci_state_flags & MCIS_IS_VNIC) { 3327 mac_impl_t *umip = mcip->mci_upper_mip; 3328 3329 ASSERT(umip != NULL); 3330 mac_vnic_secondary_update(umip); 3331 } 3332 3333 i_mac_perim_exit(mip); 3334 3335 return (0); 3336 } 3337 3338 /* 3339 * Remove a multicast address previously aded through mac_promisc_add(). 3340 */ 3341 void 3342 mac_promisc_remove(mac_promisc_handle_t mph) 3343 { 3344 mac_promisc_impl_t *mpip = (mac_promisc_impl_t *)mph; 3345 mac_client_impl_t *mcip = mpip->mpi_mcip; 3346 mac_impl_t *mip = mcip->mci_mip; 3347 mac_cb_info_t *mcbi; 3348 int rv; 3349 3350 i_mac_perim_enter(mip); 3351 3352 /* 3353 * Even if the device can't be reset into normal mode, we still 3354 * need to clear the client promisc callbacks. The client may want 3355 * to close the mac end point and we can't have stale callbacks. 3356 */ 3357 if (!(mpip->mpi_no_phys)) { 3358 if ((rv = i_mac_promisc_set(mip, B_FALSE)) != 0) { 3359 cmn_err(CE_WARN, "%s: failed to switch OFF promiscuous" 3360 " mode because of error 0x%x", mip->mi_name, rv); 3361 } 3362 } 3363 mcbi = &mip->mi_promisc_cb_info; 3364 mutex_enter(mcbi->mcbi_lockp); 3365 if (mac_callback_remove(mcbi, &mip->mi_promisc_list, 3366 &mpip->mpi_mi_link)) { 3367 VERIFY(mac_callback_remove(&mip->mi_promisc_cb_info, 3368 &mcip->mci_promisc_list, &mpip->mpi_mci_link)); 3369 kmem_cache_free(mac_promisc_impl_cache, mpip); 3370 } else { 3371 mac_callback_remove_wait(&mip->mi_promisc_cb_info); 3372 } 3373 3374 if (mcip->mci_state_flags & MCIS_IS_VNIC) { 3375 mac_impl_t *umip = mcip->mci_upper_mip; 3376 3377 ASSERT(umip != NULL); 3378 mac_vnic_secondary_update(umip); 3379 } 3380 3381 mutex_exit(mcbi->mcbi_lockp); 3382 mac_stop((mac_handle_t)mip); 3383 3384 i_mac_perim_exit(mip); 3385 } 3386 3387 /* 3388 * Reference count the number of active Tx threads. MCI_TX_QUIESCE indicates 3389 * that a control operation wants to quiesce the Tx data flow in which case 3390 * we return an error. Holding any of the per cpu locks ensures that the 3391 * mci_tx_flag won't change. 3392 * 3393 * 'CPU' must be accessed just once and used to compute the index into the 3394 * percpu array, and that index must be used for the entire duration of the 3395 * packet send operation. Note that the thread may be preempted and run on 3396 * another cpu any time and so we can't use 'CPU' more than once for the 3397 * operation. 3398 */ 3399 #define MAC_TX_TRY_HOLD(mcip, mytx, error) \ 3400 { \ 3401 (error) = 0; \ 3402 (mytx) = &(mcip)->mci_tx_pcpu[CPU->cpu_seqid & mac_tx_percpu_cnt]; \ 3403 mutex_enter(&(mytx)->pcpu_tx_lock); \ 3404 if (!((mcip)->mci_tx_flag & MCI_TX_QUIESCE)) { \ 3405 (mytx)->pcpu_tx_refcnt++; \ 3406 } else { \ 3407 (error) = -1; \ 3408 } \ 3409 mutex_exit(&(mytx)->pcpu_tx_lock); \ 3410 } 3411 3412 /* 3413 * Release the reference. If needed, signal any control operation waiting 3414 * for Tx quiescence. The wait and signal are always done using the 3415 * mci_tx_pcpu[0]'s lock 3416 */ 3417 #define MAC_TX_RELE(mcip, mytx) { \ 3418 mutex_enter(&(mytx)->pcpu_tx_lock); \ 3419 if (--(mytx)->pcpu_tx_refcnt == 0 && \ 3420 (mcip)->mci_tx_flag & MCI_TX_QUIESCE) { \ 3421 mutex_exit(&(mytx)->pcpu_tx_lock); \ 3422 mutex_enter(&(mcip)->mci_tx_pcpu[0].pcpu_tx_lock); \ 3423 cv_signal(&(mcip)->mci_tx_cv); \ 3424 mutex_exit(&(mcip)->mci_tx_pcpu[0].pcpu_tx_lock); \ 3425 } else { \ 3426 mutex_exit(&(mytx)->pcpu_tx_lock); \ 3427 } \ 3428 } 3429 3430 /* 3431 * Send function invoked by MAC clients. 3432 */ 3433 mac_tx_cookie_t 3434 mac_tx(mac_client_handle_t mch, mblk_t *mp_chain, uintptr_t hint, 3435 uint16_t flag, mblk_t **ret_mp) 3436 { 3437 mac_tx_cookie_t cookie = 0; 3438 int error; 3439 mac_tx_percpu_t *mytx; 3440 mac_soft_ring_set_t *srs; 3441 flow_entry_t *flent; 3442 boolean_t is_subflow = B_FALSE; 3443 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3444 mac_impl_t *mip = mcip->mci_mip; 3445 mac_srs_tx_t *srs_tx; 3446 3447 /* 3448 * Check whether the active Tx threads count is bumped already. 3449 */ 3450 if (!(flag & MAC_TX_NO_HOLD)) { 3451 MAC_TX_TRY_HOLD(mcip, mytx, error); 3452 if (error != 0) { 3453 freemsgchain(mp_chain); 3454 return (0); 3455 } 3456 } 3457 3458 /* 3459 * If mac protection is enabled, only the permissible packets will be 3460 * returned by mac_protect_check(). 3461 */ 3462 if ((mcip->mci_flent-> 3463 fe_resource_props.mrp_mask & MRP_PROTECT) != 0 && 3464 (mp_chain = mac_protect_check(mch, mp_chain)) == NULL) 3465 goto done; 3466 3467 if (mcip->mci_subflow_tab != NULL && 3468 mcip->mci_subflow_tab->ft_flow_count > 0 && 3469 mac_flow_lookup(mcip->mci_subflow_tab, mp_chain, 3470 FLOW_OUTBOUND, &flent) == 0) { 3471 /* 3472 * The main assumption here is that if in the event 3473 * we get a chain, all the packets will be classified 3474 * to the same Flow/SRS. If this changes for any 3475 * reason, the following logic should change as well. 3476 * I suppose the fanout_hint also assumes this . 3477 */ 3478 ASSERT(flent != NULL); 3479 is_subflow = B_TRUE; 3480 } else { 3481 flent = mcip->mci_flent; 3482 } 3483 3484 srs = flent->fe_tx_srs; 3485 /* 3486 * This is to avoid panics with PF_PACKET that can call mac_tx() 3487 * against an interface that is not capable of sending. A rewrite 3488 * of the mac datapath is required to remove this limitation. 3489 */ 3490 if (srs == NULL) { 3491 freemsgchain(mp_chain); 3492 goto done; 3493 } 3494 3495 srs_tx = &srs->srs_tx; 3496 if (srs_tx->st_mode == SRS_TX_DEFAULT && 3497 (srs->srs_state & SRS_ENQUEUED) == 0 && 3498 mip->mi_nactiveclients == 1 && mp_chain->b_next == NULL) { 3499 uint64_t obytes; 3500 3501 /* 3502 * Since dls always opens the underlying MAC, nclients equals 3503 * to 1 means that the only active client is dls itself acting 3504 * as a primary client of the MAC instance. Since dls will not 3505 * send tagged packets in that case, and dls is trusted to send 3506 * packets for its allowed VLAN(s), the VLAN tag insertion and 3507 * check is required only if nclients is greater than 1. 3508 */ 3509 if (mip->mi_nclients > 1) { 3510 if (MAC_VID_CHECK_NEEDED(mcip)) { 3511 int err = 0; 3512 3513 MAC_VID_CHECK(mcip, mp_chain, err); 3514 if (err != 0) { 3515 freemsg(mp_chain); 3516 mcip->mci_misc_stat.mms_txerrors++; 3517 goto done; 3518 } 3519 } 3520 if (MAC_TAG_NEEDED(mcip)) { 3521 mp_chain = mac_add_vlan_tag(mp_chain, 0, 3522 mac_client_vid(mch)); 3523 if (mp_chain == NULL) { 3524 mcip->mci_misc_stat.mms_txerrors++; 3525 goto done; 3526 } 3527 } 3528 } 3529 3530 obytes = (mp_chain->b_cont == NULL ? MBLKL(mp_chain) : 3531 msgdsize(mp_chain)); 3532 3533 MAC_TX(mip, srs_tx->st_arg2, mp_chain, mcip); 3534 if (mp_chain == NULL) { 3535 cookie = 0; 3536 SRS_TX_STAT_UPDATE(srs, opackets, 1); 3537 SRS_TX_STAT_UPDATE(srs, obytes, obytes); 3538 } else { 3539 mutex_enter(&srs->srs_lock); 3540 cookie = mac_tx_srs_no_desc(srs, mp_chain, 3541 flag, ret_mp); 3542 mutex_exit(&srs->srs_lock); 3543 } 3544 } else { 3545 cookie = srs_tx->st_func(srs, mp_chain, hint, flag, ret_mp); 3546 } 3547 3548 done: 3549 if (is_subflow) 3550 FLOW_REFRELE(flent); 3551 3552 if (!(flag & MAC_TX_NO_HOLD)) 3553 MAC_TX_RELE(mcip, mytx); 3554 3555 return (cookie); 3556 } 3557 3558 /* 3559 * mac_tx_is_blocked 3560 * 3561 * Given a cookie, it returns if the ring identified by the cookie is 3562 * flow-controlled or not. If NULL is passed in place of a cookie, 3563 * then it finds out if any of the underlying rings belonging to the 3564 * SRS is flow controlled or not and returns that status. 3565 */ 3566 /* ARGSUSED */ 3567 boolean_t 3568 mac_tx_is_flow_blocked(mac_client_handle_t mch, mac_tx_cookie_t cookie) 3569 { 3570 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3571 mac_soft_ring_set_t *mac_srs; 3572 mac_soft_ring_t *sringp; 3573 boolean_t blocked = B_FALSE; 3574 mac_tx_percpu_t *mytx; 3575 int err; 3576 int i; 3577 3578 /* 3579 * Bump the reference count so that mac_srs won't be deleted. 3580 * If the client is currently quiesced and we failed to bump 3581 * the reference, return B_TRUE so that flow control stays 3582 * as enabled. 3583 * 3584 * Flow control will then be disabled once the client is no 3585 * longer quiesced. 3586 */ 3587 MAC_TX_TRY_HOLD(mcip, mytx, err); 3588 if (err != 0) 3589 return (B_TRUE); 3590 3591 if ((mac_srs = MCIP_TX_SRS(mcip)) == NULL) { 3592 MAC_TX_RELE(mcip, mytx); 3593 return (B_FALSE); 3594 } 3595 3596 mutex_enter(&mac_srs->srs_lock); 3597 /* 3598 * Only in the case of TX_FANOUT and TX_AGGR, the underlying 3599 * softring (s_ring_state) will have the HIWAT set. This is 3600 * the multiple Tx ring flow control case. For all other 3601 * case, SRS (srs_state) will store the condition. 3602 */ 3603 if (mac_srs->srs_tx.st_mode == SRS_TX_FANOUT || 3604 mac_srs->srs_tx.st_mode == SRS_TX_AGGR) { 3605 if (cookie != 0) { 3606 sringp = (mac_soft_ring_t *)cookie; 3607 mutex_enter(&sringp->s_ring_lock); 3608 if (sringp->s_ring_state & S_RING_TX_HIWAT) 3609 blocked = B_TRUE; 3610 mutex_exit(&sringp->s_ring_lock); 3611 } else { 3612 for (i = 0; i < mac_srs->srs_tx_ring_count; i++) { 3613 sringp = mac_srs->srs_tx_soft_rings[i]; 3614 mutex_enter(&sringp->s_ring_lock); 3615 if (sringp->s_ring_state & S_RING_TX_HIWAT) { 3616 blocked = B_TRUE; 3617 mutex_exit(&sringp->s_ring_lock); 3618 break; 3619 } 3620 mutex_exit(&sringp->s_ring_lock); 3621 } 3622 } 3623 } else { 3624 blocked = (mac_srs->srs_state & SRS_TX_HIWAT); 3625 } 3626 mutex_exit(&mac_srs->srs_lock); 3627 MAC_TX_RELE(mcip, mytx); 3628 return (blocked); 3629 } 3630 3631 /* 3632 * Check if the MAC client is the primary MAC client. 3633 */ 3634 boolean_t 3635 mac_is_primary_client(mac_client_impl_t *mcip) 3636 { 3637 return (mcip->mci_flags & MAC_CLIENT_FLAGS_PRIMARY); 3638 } 3639 3640 void 3641 mac_ioctl(mac_handle_t mh, queue_t *wq, mblk_t *bp) 3642 { 3643 mac_impl_t *mip = (mac_impl_t *)mh; 3644 int cmd = ((struct iocblk *)bp->b_rptr)->ioc_cmd; 3645 3646 if ((cmd == ND_GET && (mip->mi_callbacks->mc_callbacks & MC_GETPROP)) || 3647 (cmd == ND_SET && (mip->mi_callbacks->mc_callbacks & MC_SETPROP))) { 3648 /* 3649 * If ndd props were registered, call them. 3650 * Note that ndd ioctls are Obsolete 3651 */ 3652 mac_ndd_ioctl(mip, wq, bp); 3653 return; 3654 } 3655 3656 /* 3657 * Call the driver to handle the ioctl. The driver may not support 3658 * any ioctls, in which case we reply with a NAK on its behalf. 3659 */ 3660 if (mip->mi_callbacks->mc_callbacks & MC_IOCTL) 3661 mip->mi_ioctl(mip->mi_driver, wq, bp); 3662 else 3663 miocnak(wq, bp, 0, EINVAL); 3664 } 3665 3666 /* 3667 * Return the link state of the specified MAC instance. 3668 */ 3669 link_state_t 3670 mac_link_get(mac_handle_t mh) 3671 { 3672 return (((mac_impl_t *)mh)->mi_linkstate); 3673 } 3674 3675 /* 3676 * Add a mac client specified notification callback. Please see the comments 3677 * above mac_callback_add() for general information about mac callback 3678 * addition/deletion in the presence of mac callback list walkers 3679 */ 3680 mac_notify_handle_t 3681 mac_notify_add(mac_handle_t mh, mac_notify_t notify_fn, void *arg) 3682 { 3683 mac_impl_t *mip = (mac_impl_t *)mh; 3684 mac_notify_cb_t *mncb; 3685 mac_cb_info_t *mcbi; 3686 3687 /* 3688 * Allocate a notify callback structure, fill in the details and 3689 * use the mac callback list manipulation functions to chain into 3690 * the list of callbacks. 3691 */ 3692 mncb = kmem_zalloc(sizeof (mac_notify_cb_t), KM_SLEEP); 3693 mncb->mncb_fn = notify_fn; 3694 mncb->mncb_arg = arg; 3695 mncb->mncb_mip = mip; 3696 mncb->mncb_link.mcb_objp = mncb; 3697 mncb->mncb_link.mcb_objsize = sizeof (mac_notify_cb_t); 3698 mncb->mncb_link.mcb_flags = MCB_NOTIFY_CB_T; 3699 3700 mcbi = &mip->mi_notify_cb_info; 3701 3702 i_mac_perim_enter(mip); 3703 mutex_enter(mcbi->mcbi_lockp); 3704 3705 mac_callback_add(&mip->mi_notify_cb_info, &mip->mi_notify_cb_list, 3706 &mncb->mncb_link); 3707 3708 mutex_exit(mcbi->mcbi_lockp); 3709 i_mac_perim_exit(mip); 3710 return ((mac_notify_handle_t)mncb); 3711 } 3712 3713 void 3714 mac_notify_remove_wait(mac_handle_t mh) 3715 { 3716 mac_impl_t *mip = (mac_impl_t *)mh; 3717 mac_cb_info_t *mcbi = &mip->mi_notify_cb_info; 3718 3719 mutex_enter(mcbi->mcbi_lockp); 3720 mac_callback_remove_wait(&mip->mi_notify_cb_info); 3721 mutex_exit(mcbi->mcbi_lockp); 3722 } 3723 3724 /* 3725 * Remove a mac client specified notification callback 3726 */ 3727 int 3728 mac_notify_remove(mac_notify_handle_t mnh, boolean_t wait) 3729 { 3730 mac_notify_cb_t *mncb = (mac_notify_cb_t *)mnh; 3731 mac_impl_t *mip = mncb->mncb_mip; 3732 mac_cb_info_t *mcbi; 3733 int err = 0; 3734 3735 mcbi = &mip->mi_notify_cb_info; 3736 3737 i_mac_perim_enter(mip); 3738 mutex_enter(mcbi->mcbi_lockp); 3739 3740 ASSERT(mncb->mncb_link.mcb_objp == mncb); 3741 /* 3742 * If there aren't any list walkers, the remove would succeed 3743 * inline, else we wait for the deferred remove to complete 3744 */ 3745 if (mac_callback_remove(&mip->mi_notify_cb_info, 3746 &mip->mi_notify_cb_list, &mncb->mncb_link)) { 3747 kmem_free(mncb, sizeof (mac_notify_cb_t)); 3748 } else { 3749 err = EBUSY; 3750 } 3751 3752 mutex_exit(mcbi->mcbi_lockp); 3753 i_mac_perim_exit(mip); 3754 3755 /* 3756 * If we failed to remove the notification callback and "wait" is set 3757 * to be B_TRUE, wait for the callback to finish after we exit the 3758 * mac perimeter. 3759 */ 3760 if (err != 0 && wait) { 3761 mac_notify_remove_wait((mac_handle_t)mip); 3762 return (0); 3763 } 3764 3765 return (err); 3766 } 3767 3768 /* 3769 * Associate resource management callbacks with the specified MAC 3770 * clients. 3771 */ 3772 3773 void 3774 mac_resource_set_common(mac_client_handle_t mch, mac_resource_add_t add, 3775 mac_resource_remove_t remove, mac_resource_quiesce_t quiesce, 3776 mac_resource_restart_t restart, mac_resource_bind_t bind, 3777 void *arg) 3778 { 3779 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3780 3781 mcip->mci_resource_add = add; 3782 mcip->mci_resource_remove = remove; 3783 mcip->mci_resource_quiesce = quiesce; 3784 mcip->mci_resource_restart = restart; 3785 mcip->mci_resource_bind = bind; 3786 mcip->mci_resource_arg = arg; 3787 } 3788 3789 void 3790 mac_resource_set(mac_client_handle_t mch, mac_resource_add_t add, void *arg) 3791 { 3792 /* update the 'resource_add' callback */ 3793 mac_resource_set_common(mch, add, NULL, NULL, NULL, NULL, arg); 3794 } 3795 3796 /* 3797 * Sets up the client resources and enable the polling interface over all the 3798 * SRS's and the soft rings of the client 3799 */ 3800 void 3801 mac_client_poll_enable(mac_client_handle_t mch) 3802 { 3803 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3804 mac_soft_ring_set_t *mac_srs; 3805 flow_entry_t *flent; 3806 int i; 3807 3808 flent = mcip->mci_flent; 3809 ASSERT(flent != NULL); 3810 3811 mcip->mci_state_flags |= MCIS_CLIENT_POLL_CAPABLE; 3812 for (i = 0; i < flent->fe_rx_srs_cnt; i++) { 3813 mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i]; 3814 ASSERT(mac_srs->srs_mcip == mcip); 3815 mac_srs_client_poll_enable(mcip, mac_srs); 3816 } 3817 } 3818 3819 /* 3820 * Tears down the client resources and disable the polling interface over all 3821 * the SRS's and the soft rings of the client 3822 */ 3823 void 3824 mac_client_poll_disable(mac_client_handle_t mch) 3825 { 3826 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3827 mac_soft_ring_set_t *mac_srs; 3828 flow_entry_t *flent; 3829 int i; 3830 3831 flent = mcip->mci_flent; 3832 ASSERT(flent != NULL); 3833 3834 mcip->mci_state_flags &= ~MCIS_CLIENT_POLL_CAPABLE; 3835 for (i = 0; i < flent->fe_rx_srs_cnt; i++) { 3836 mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i]; 3837 ASSERT(mac_srs->srs_mcip == mcip); 3838 mac_srs_client_poll_disable(mcip, mac_srs); 3839 } 3840 } 3841 3842 /* 3843 * Associate the CPUs specified by the given property with a MAC client. 3844 */ 3845 int 3846 mac_cpu_set(mac_client_handle_t mch, mac_resource_props_t *mrp) 3847 { 3848 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3849 mac_impl_t *mip = mcip->mci_mip; 3850 int err = 0; 3851 3852 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 3853 3854 if ((err = mac_validate_props(mcip->mci_state_flags & MCIS_IS_VNIC ? 3855 mcip->mci_upper_mip : mip, mrp)) != 0) { 3856 return (err); 3857 } 3858 if (MCIP_DATAPATH_SETUP(mcip)) 3859 mac_flow_modify(mip->mi_flow_tab, mcip->mci_flent, mrp); 3860 3861 mac_update_resources(mrp, MCIP_RESOURCE_PROPS(mcip), B_FALSE); 3862 return (0); 3863 } 3864 3865 /* 3866 * Apply the specified properties to the specified MAC client. 3867 */ 3868 int 3869 mac_client_set_resources(mac_client_handle_t mch, mac_resource_props_t *mrp) 3870 { 3871 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3872 mac_impl_t *mip = mcip->mci_mip; 3873 int err = 0; 3874 3875 i_mac_perim_enter(mip); 3876 3877 if ((mrp->mrp_mask & MRP_MAXBW) || (mrp->mrp_mask & MRP_PRIORITY)) { 3878 err = mac_resource_ctl_set(mch, mrp); 3879 if (err != 0) 3880 goto done; 3881 } 3882 3883 if (mrp->mrp_mask & (MRP_CPUS|MRP_POOL)) { 3884 err = mac_cpu_set(mch, mrp); 3885 if (err != 0) 3886 goto done; 3887 } 3888 3889 if (mrp->mrp_mask & MRP_PROTECT) { 3890 err = mac_protect_set(mch, mrp); 3891 if (err != 0) 3892 goto done; 3893 } 3894 3895 if ((mrp->mrp_mask & MRP_RX_RINGS) || (mrp->mrp_mask & MRP_TX_RINGS)) 3896 err = mac_resource_ctl_set(mch, mrp); 3897 3898 done: 3899 i_mac_perim_exit(mip); 3900 return (err); 3901 } 3902 3903 /* 3904 * Return the properties currently associated with the specified MAC client. 3905 */ 3906 void 3907 mac_client_get_resources(mac_client_handle_t mch, mac_resource_props_t *mrp) 3908 { 3909 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3910 mac_resource_props_t *mcip_mrp = MCIP_RESOURCE_PROPS(mcip); 3911 3912 bcopy(mcip_mrp, mrp, sizeof (mac_resource_props_t)); 3913 } 3914 3915 /* 3916 * Return the effective properties currently associated with the specified 3917 * MAC client. 3918 */ 3919 void 3920 mac_client_get_effective_resources(mac_client_handle_t mch, 3921 mac_resource_props_t *mrp) 3922 { 3923 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 3924 mac_resource_props_t *mcip_mrp = MCIP_EFFECTIVE_PROPS(mcip); 3925 3926 bcopy(mcip_mrp, mrp, sizeof (mac_resource_props_t)); 3927 } 3928 3929 /* 3930 * Pass a copy of the specified packet to the promiscuous callbacks 3931 * of the specified MAC. 3932 * 3933 * If sender is NULL, the function is being invoked for a packet chain 3934 * received from the wire. If sender is non-NULL, it points to 3935 * the MAC client from which the packet is being sent. 3936 * 3937 * The packets are distributed to the promiscuous callbacks as follows: 3938 * 3939 * - all packets are sent to the MAC_CLIENT_PROMISC_ALL callbacks 3940 * - all broadcast and multicast packets are sent to the 3941 * MAC_CLIENT_PROMISC_FILTER and MAC_CLIENT_PROMISC_MULTI. 3942 * 3943 * The unicast packets of MAC_CLIENT_PROMISC_FILTER callbacks are dispatched 3944 * after classification by mac_rx_deliver(). 3945 */ 3946 3947 static void 3948 mac_promisc_dispatch_one(mac_promisc_impl_t *mpip, mblk_t *mp, 3949 boolean_t loopback) 3950 { 3951 mblk_t *mp_copy, *mp_next; 3952 3953 if (!mpip->mpi_no_copy || mpip->mpi_strip_vlan_tag) { 3954 mp_copy = copymsg(mp); 3955 if (mp_copy == NULL) 3956 return; 3957 3958 if (mpip->mpi_strip_vlan_tag) { 3959 mp_copy = mac_strip_vlan_tag_chain(mp_copy); 3960 if (mp_copy == NULL) 3961 return; 3962 } 3963 mp_next = NULL; 3964 } else { 3965 mp_copy = mp; 3966 mp_next = mp->b_next; 3967 } 3968 mp_copy->b_next = NULL; 3969 3970 mpip->mpi_fn(mpip->mpi_arg, NULL, mp_copy, loopback); 3971 if (mp_copy == mp) 3972 mp->b_next = mp_next; 3973 } 3974 3975 /* 3976 * Return the VID of a packet. Zero if the packet is not tagged. 3977 */ 3978 static uint16_t 3979 mac_ether_vid(mblk_t *mp) 3980 { 3981 struct ether_header *eth = (struct ether_header *)mp->b_rptr; 3982 3983 if (ntohs(eth->ether_type) == ETHERTYPE_VLAN) { 3984 struct ether_vlan_header *t_evhp = 3985 (struct ether_vlan_header *)mp->b_rptr; 3986 return (VLAN_ID(ntohs(t_evhp->ether_tci))); 3987 } 3988 3989 return (0); 3990 } 3991 3992 /* 3993 * Return whether the specified packet contains a multicast or broadcast 3994 * destination MAC address. 3995 */ 3996 static boolean_t 3997 mac_is_mcast(mac_impl_t *mip, mblk_t *mp) 3998 { 3999 mac_header_info_t hdr_info; 4000 4001 if (mac_header_info((mac_handle_t)mip, mp, &hdr_info) != 0) 4002 return (B_FALSE); 4003 return ((hdr_info.mhi_dsttype == MAC_ADDRTYPE_BROADCAST) || 4004 (hdr_info.mhi_dsttype == MAC_ADDRTYPE_MULTICAST)); 4005 } 4006 4007 /* 4008 * Send a copy of an mblk chain to the MAC clients of the specified MAC. 4009 * "sender" points to the sender MAC client for outbound packets, and 4010 * is set to NULL for inbound packets. 4011 */ 4012 void 4013 mac_promisc_dispatch(mac_impl_t *mip, mblk_t *mp_chain, 4014 mac_client_impl_t *sender) 4015 { 4016 mac_promisc_impl_t *mpip; 4017 mac_cb_t *mcb; 4018 mblk_t *mp; 4019 boolean_t is_mcast, is_sender; 4020 4021 MAC_PROMISC_WALKER_INC(mip); 4022 for (mp = mp_chain; mp != NULL; mp = mp->b_next) { 4023 is_mcast = mac_is_mcast(mip, mp); 4024 /* send packet to interested callbacks */ 4025 for (mcb = mip->mi_promisc_list; mcb != NULL; 4026 mcb = mcb->mcb_nextp) { 4027 mpip = (mac_promisc_impl_t *)mcb->mcb_objp; 4028 is_sender = (mpip->mpi_mcip == sender); 4029 4030 if (is_sender && mpip->mpi_no_tx_loop) 4031 /* 4032 * The sender doesn't want to receive 4033 * copies of the packets it sends. 4034 */ 4035 continue; 4036 4037 /* this client doesn't need any packets (bridge) */ 4038 if (mpip->mpi_fn == NULL) 4039 continue; 4040 4041 /* 4042 * For an ethernet MAC, don't displatch a multicast 4043 * packet to a non-PROMISC_ALL callbacks unless the VID 4044 * of the packet matches the VID of the client. 4045 */ 4046 if (is_mcast && 4047 mpip->mpi_type != MAC_CLIENT_PROMISC_ALL && 4048 !mac_client_check_flow_vid(mpip->mpi_mcip, 4049 mac_ether_vid(mp))) 4050 continue; 4051 4052 if (is_sender || 4053 mpip->mpi_type == MAC_CLIENT_PROMISC_ALL || 4054 is_mcast) 4055 mac_promisc_dispatch_one(mpip, mp, is_sender); 4056 } 4057 } 4058 MAC_PROMISC_WALKER_DCR(mip); 4059 } 4060 4061 void 4062 mac_promisc_client_dispatch(mac_client_impl_t *mcip, mblk_t *mp_chain) 4063 { 4064 mac_impl_t *mip = mcip->mci_mip; 4065 mac_promisc_impl_t *mpip; 4066 boolean_t is_mcast; 4067 mblk_t *mp; 4068 mac_cb_t *mcb; 4069 4070 /* 4071 * The unicast packets for the MAC client still 4072 * need to be delivered to the MAC_CLIENT_PROMISC_FILTERED 4073 * promiscuous callbacks. The broadcast and multicast 4074 * packets were delivered from mac_rx(). 4075 */ 4076 MAC_PROMISC_WALKER_INC(mip); 4077 for (mp = mp_chain; mp != NULL; mp = mp->b_next) { 4078 is_mcast = mac_is_mcast(mip, mp); 4079 for (mcb = mcip->mci_promisc_list; mcb != NULL; 4080 mcb = mcb->mcb_nextp) { 4081 mpip = (mac_promisc_impl_t *)mcb->mcb_objp; 4082 if (mpip->mpi_type == MAC_CLIENT_PROMISC_FILTERED && 4083 !is_mcast) { 4084 mac_promisc_dispatch_one(mpip, mp, B_FALSE); 4085 } 4086 } 4087 } 4088 MAC_PROMISC_WALKER_DCR(mip); 4089 } 4090 4091 /* 4092 * Return the margin value currently assigned to the specified MAC instance. 4093 */ 4094 void 4095 mac_margin_get(mac_handle_t mh, uint32_t *marginp) 4096 { 4097 mac_impl_t *mip = (mac_impl_t *)mh; 4098 4099 rw_enter(&(mip->mi_rw_lock), RW_READER); 4100 *marginp = mip->mi_margin; 4101 rw_exit(&(mip->mi_rw_lock)); 4102 } 4103 4104 /* 4105 * mac_info_get() is used for retrieving the mac_info when a DL_INFO_REQ is 4106 * issued before a DL_ATTACH_REQ. we walk the i_mac_impl_hash table and find 4107 * the first mac_impl_t with a matching driver name; then we copy its mac_info_t 4108 * to the caller. we do all this with i_mac_impl_lock held so the mac_impl_t 4109 * cannot disappear while we are accessing it. 4110 */ 4111 typedef struct i_mac_info_state_s { 4112 const char *mi_name; 4113 mac_info_t *mi_infop; 4114 } i_mac_info_state_t; 4115 4116 /*ARGSUSED*/ 4117 static uint_t 4118 i_mac_info_walker(mod_hash_key_t key, mod_hash_val_t *val, void *arg) 4119 { 4120 i_mac_info_state_t *statep = arg; 4121 mac_impl_t *mip = (mac_impl_t *)val; 4122 4123 if (mip->mi_state_flags & MIS_DISABLED) 4124 return (MH_WALK_CONTINUE); 4125 4126 if (strcmp(statep->mi_name, 4127 ddi_driver_name(mip->mi_dip)) != 0) 4128 return (MH_WALK_CONTINUE); 4129 4130 statep->mi_infop = &mip->mi_info; 4131 return (MH_WALK_TERMINATE); 4132 } 4133 4134 boolean_t 4135 mac_info_get(const char *name, mac_info_t *minfop) 4136 { 4137 i_mac_info_state_t state; 4138 4139 rw_enter(&i_mac_impl_lock, RW_READER); 4140 state.mi_name = name; 4141 state.mi_infop = NULL; 4142 mod_hash_walk(i_mac_impl_hash, i_mac_info_walker, &state); 4143 if (state.mi_infop == NULL) { 4144 rw_exit(&i_mac_impl_lock); 4145 return (B_FALSE); 4146 } 4147 *minfop = *state.mi_infop; 4148 rw_exit(&i_mac_impl_lock); 4149 return (B_TRUE); 4150 } 4151 4152 /* 4153 * To get the capabilities that MAC layer cares about, such as rings, factory 4154 * mac address, vnic or not, it should directly invoke this function. If the 4155 * link is part of a bridge, then the only "capability" it has is the inability 4156 * to do zero copy. 4157 */ 4158 boolean_t 4159 i_mac_capab_get(mac_handle_t mh, mac_capab_t cap, void *cap_data) 4160 { 4161 mac_impl_t *mip = (mac_impl_t *)mh; 4162 4163 if (mip->mi_bridge_link != NULL) 4164 return (cap == MAC_CAPAB_NO_ZCOPY); 4165 else if (mip->mi_callbacks->mc_callbacks & MC_GETCAPAB) 4166 return (mip->mi_getcapab(mip->mi_driver, cap, cap_data)); 4167 else 4168 return (B_FALSE); 4169 } 4170 4171 /* 4172 * Capability query function. If number of active mac clients is greater than 4173 * 1, only limited capabilities can be advertised to the caller no matter the 4174 * driver has certain capability or not. Else, we query the driver to get the 4175 * capability. 4176 */ 4177 boolean_t 4178 mac_capab_get(mac_handle_t mh, mac_capab_t cap, void *cap_data) 4179 { 4180 mac_impl_t *mip = (mac_impl_t *)mh; 4181 4182 /* 4183 * if mi_nactiveclients > 1, only MAC_CAPAB_LEGACY, MAC_CAPAB_HCKSUM, 4184 * MAC_CAPAB_NO_NATIVEVLAN and MAC_CAPAB_NO_ZCOPY can be advertised. 4185 */ 4186 if (mip->mi_nactiveclients > 1) { 4187 switch (cap) { 4188 case MAC_CAPAB_NO_ZCOPY: 4189 return (B_TRUE); 4190 case MAC_CAPAB_LEGACY: 4191 case MAC_CAPAB_HCKSUM: 4192 case MAC_CAPAB_NO_NATIVEVLAN: 4193 break; 4194 default: 4195 return (B_FALSE); 4196 } 4197 } 4198 4199 /* else get capab from driver */ 4200 return (i_mac_capab_get(mh, cap, cap_data)); 4201 } 4202 4203 boolean_t 4204 mac_sap_verify(mac_handle_t mh, uint32_t sap, uint32_t *bind_sap) 4205 { 4206 mac_impl_t *mip = (mac_impl_t *)mh; 4207 4208 return (mip->mi_type->mt_ops.mtops_sap_verify(sap, bind_sap, 4209 mip->mi_pdata)); 4210 } 4211 4212 mblk_t * 4213 mac_header(mac_handle_t mh, const uint8_t *daddr, uint32_t sap, mblk_t *payload, 4214 size_t extra_len) 4215 { 4216 mac_impl_t *mip = (mac_impl_t *)mh; 4217 const uint8_t *hdr_daddr; 4218 4219 /* 4220 * If the MAC is point-to-point with a fixed destination address, then 4221 * we must always use that destination in the MAC header. 4222 */ 4223 hdr_daddr = (mip->mi_dstaddr_set ? mip->mi_dstaddr : daddr); 4224 return (mip->mi_type->mt_ops.mtops_header(mip->mi_addr, hdr_daddr, sap, 4225 mip->mi_pdata, payload, extra_len)); 4226 } 4227 4228 int 4229 mac_header_info(mac_handle_t mh, mblk_t *mp, mac_header_info_t *mhip) 4230 { 4231 mac_impl_t *mip = (mac_impl_t *)mh; 4232 4233 return (mip->mi_type->mt_ops.mtops_header_info(mp, mip->mi_pdata, 4234 mhip)); 4235 } 4236 4237 int 4238 mac_vlan_header_info(mac_handle_t mh, mblk_t *mp, mac_header_info_t *mhip) 4239 { 4240 mac_impl_t *mip = (mac_impl_t *)mh; 4241 boolean_t is_ethernet = (mip->mi_info.mi_media == DL_ETHER); 4242 int err = 0; 4243 4244 /* 4245 * Packets should always be at least 16 bit aligned. 4246 */ 4247 ASSERT(IS_P2ALIGNED(mp->b_rptr, sizeof (uint16_t))); 4248 4249 if ((err = mac_header_info(mh, mp, mhip)) != 0) 4250 return (err); 4251 4252 /* 4253 * If this is a VLAN-tagged Ethernet packet, then the SAP in the 4254 * mac_header_info_t as returned by mac_header_info() is 4255 * ETHERTYPE_VLAN. We need to grab the ethertype from the VLAN header. 4256 */ 4257 if (is_ethernet && (mhip->mhi_bindsap == ETHERTYPE_VLAN)) { 4258 struct ether_vlan_header *evhp; 4259 uint16_t sap; 4260 mblk_t *tmp = NULL; 4261 size_t size; 4262 4263 size = sizeof (struct ether_vlan_header); 4264 if (MBLKL(mp) < size) { 4265 /* 4266 * Pullup the message in order to get the MAC header 4267 * infomation. Note that this is a read-only function, 4268 * we keep the input packet intact. 4269 */ 4270 if ((tmp = msgpullup(mp, size)) == NULL) 4271 return (EINVAL); 4272 4273 mp = tmp; 4274 } 4275 evhp = (struct ether_vlan_header *)mp->b_rptr; 4276 sap = ntohs(evhp->ether_type); 4277 (void) mac_sap_verify(mh, sap, &mhip->mhi_bindsap); 4278 mhip->mhi_hdrsize = sizeof (struct ether_vlan_header); 4279 mhip->mhi_tci = ntohs(evhp->ether_tci); 4280 mhip->mhi_istagged = B_TRUE; 4281 freemsg(tmp); 4282 4283 if (VLAN_CFI(mhip->mhi_tci) != ETHER_CFI) 4284 return (EINVAL); 4285 } else { 4286 mhip->mhi_istagged = B_FALSE; 4287 mhip->mhi_tci = 0; 4288 } 4289 4290 return (0); 4291 } 4292 4293 mblk_t * 4294 mac_header_cook(mac_handle_t mh, mblk_t *mp) 4295 { 4296 mac_impl_t *mip = (mac_impl_t *)mh; 4297 4298 if (mip->mi_type->mt_ops.mtops_ops & MTOPS_HEADER_COOK) { 4299 if (DB_REF(mp) > 1) { 4300 mblk_t *newmp = copymsg(mp); 4301 if (newmp == NULL) 4302 return (NULL); 4303 freemsg(mp); 4304 mp = newmp; 4305 } 4306 return (mip->mi_type->mt_ops.mtops_header_cook(mp, 4307 mip->mi_pdata)); 4308 } 4309 return (mp); 4310 } 4311 4312 mblk_t * 4313 mac_header_uncook(mac_handle_t mh, mblk_t *mp) 4314 { 4315 mac_impl_t *mip = (mac_impl_t *)mh; 4316 4317 if (mip->mi_type->mt_ops.mtops_ops & MTOPS_HEADER_UNCOOK) { 4318 if (DB_REF(mp) > 1) { 4319 mblk_t *newmp = copymsg(mp); 4320 if (newmp == NULL) 4321 return (NULL); 4322 freemsg(mp); 4323 mp = newmp; 4324 } 4325 return (mip->mi_type->mt_ops.mtops_header_uncook(mp, 4326 mip->mi_pdata)); 4327 } 4328 return (mp); 4329 } 4330 4331 uint_t 4332 mac_addr_len(mac_handle_t mh) 4333 { 4334 mac_impl_t *mip = (mac_impl_t *)mh; 4335 4336 return (mip->mi_type->mt_addr_length); 4337 } 4338 4339 /* True if a MAC is a VNIC */ 4340 boolean_t 4341 mac_is_vnic(mac_handle_t mh) 4342 { 4343 return (((mac_impl_t *)mh)->mi_state_flags & MIS_IS_VNIC); 4344 } 4345 4346 mac_handle_t 4347 mac_get_lower_mac_handle(mac_handle_t mh) 4348 { 4349 mac_impl_t *mip = (mac_impl_t *)mh; 4350 4351 ASSERT(mac_is_vnic(mh)); 4352 return (((vnic_t *)mip->mi_driver)->vn_lower_mh); 4353 } 4354 4355 boolean_t 4356 mac_is_vnic_primary(mac_handle_t mh) 4357 { 4358 mac_impl_t *mip = (mac_impl_t *)mh; 4359 4360 ASSERT(mac_is_vnic(mh)); 4361 return (((vnic_t *)mip->mi_driver)->vn_addr_type == 4362 VNIC_MAC_ADDR_TYPE_PRIMARY); 4363 } 4364 4365 void 4366 mac_update_resources(mac_resource_props_t *nmrp, mac_resource_props_t *cmrp, 4367 boolean_t is_user_flow) 4368 { 4369 if (nmrp != NULL && cmrp != NULL) { 4370 if (nmrp->mrp_mask & MRP_PRIORITY) { 4371 if (nmrp->mrp_priority == MPL_RESET) { 4372 cmrp->mrp_mask &= ~MRP_PRIORITY; 4373 if (is_user_flow) { 4374 cmrp->mrp_priority = 4375 MPL_SUBFLOW_DEFAULT; 4376 } else { 4377 cmrp->mrp_priority = MPL_LINK_DEFAULT; 4378 } 4379 } else { 4380 cmrp->mrp_mask |= MRP_PRIORITY; 4381 cmrp->mrp_priority = nmrp->mrp_priority; 4382 } 4383 } 4384 if (nmrp->mrp_mask & MRP_MAXBW) { 4385 if (nmrp->mrp_maxbw == MRP_MAXBW_RESETVAL) { 4386 cmrp->mrp_mask &= ~MRP_MAXBW; 4387 cmrp->mrp_maxbw = 0; 4388 } else { 4389 cmrp->mrp_mask |= MRP_MAXBW; 4390 cmrp->mrp_maxbw = nmrp->mrp_maxbw; 4391 } 4392 } 4393 if (nmrp->mrp_mask & MRP_CPUS) 4394 MAC_COPY_CPUS(nmrp, cmrp); 4395 4396 if (nmrp->mrp_mask & MRP_POOL) { 4397 if (strlen(nmrp->mrp_pool) == 0) { 4398 cmrp->mrp_mask &= ~MRP_POOL; 4399 bzero(cmrp->mrp_pool, sizeof (cmrp->mrp_pool)); 4400 } else { 4401 cmrp->mrp_mask |= MRP_POOL; 4402 (void) strncpy(cmrp->mrp_pool, nmrp->mrp_pool, 4403 sizeof (cmrp->mrp_pool)); 4404 } 4405 4406 } 4407 4408 if (nmrp->mrp_mask & MRP_PROTECT) 4409 mac_protect_update(nmrp, cmrp); 4410 4411 /* 4412 * Update the rings specified. 4413 */ 4414 if (nmrp->mrp_mask & MRP_RX_RINGS) { 4415 if (nmrp->mrp_mask & MRP_RINGS_RESET) { 4416 cmrp->mrp_mask &= ~MRP_RX_RINGS; 4417 if (cmrp->mrp_mask & MRP_RXRINGS_UNSPEC) 4418 cmrp->mrp_mask &= ~MRP_RXRINGS_UNSPEC; 4419 cmrp->mrp_nrxrings = 0; 4420 } else { 4421 cmrp->mrp_mask |= MRP_RX_RINGS; 4422 cmrp->mrp_nrxrings = nmrp->mrp_nrxrings; 4423 } 4424 } 4425 if (nmrp->mrp_mask & MRP_TX_RINGS) { 4426 if (nmrp->mrp_mask & MRP_RINGS_RESET) { 4427 cmrp->mrp_mask &= ~MRP_TX_RINGS; 4428 if (cmrp->mrp_mask & MRP_TXRINGS_UNSPEC) 4429 cmrp->mrp_mask &= ~MRP_TXRINGS_UNSPEC; 4430 cmrp->mrp_ntxrings = 0; 4431 } else { 4432 cmrp->mrp_mask |= MRP_TX_RINGS; 4433 cmrp->mrp_ntxrings = nmrp->mrp_ntxrings; 4434 } 4435 } 4436 if (nmrp->mrp_mask & MRP_RXRINGS_UNSPEC) 4437 cmrp->mrp_mask |= MRP_RXRINGS_UNSPEC; 4438 else if (cmrp->mrp_mask & MRP_RXRINGS_UNSPEC) 4439 cmrp->mrp_mask &= ~MRP_RXRINGS_UNSPEC; 4440 4441 if (nmrp->mrp_mask & MRP_TXRINGS_UNSPEC) 4442 cmrp->mrp_mask |= MRP_TXRINGS_UNSPEC; 4443 else if (cmrp->mrp_mask & MRP_TXRINGS_UNSPEC) 4444 cmrp->mrp_mask &= ~MRP_TXRINGS_UNSPEC; 4445 } 4446 } 4447 4448 /* 4449 * i_mac_set_resources: 4450 * 4451 * This routine associates properties with the primary MAC client of 4452 * the specified MAC instance. 4453 * - Cache the properties in mac_impl_t 4454 * - Apply the properties to the primary MAC client if exists 4455 */ 4456 int 4457 i_mac_set_resources(mac_handle_t mh, mac_resource_props_t *mrp) 4458 { 4459 mac_impl_t *mip = (mac_impl_t *)mh; 4460 mac_client_impl_t *mcip; 4461 int err = 0; 4462 uint32_t resmask, newresmask; 4463 mac_resource_props_t *tmrp, *umrp; 4464 4465 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 4466 4467 err = mac_validate_props(mip, mrp); 4468 if (err != 0) 4469 return (err); 4470 4471 umrp = kmem_zalloc(sizeof (*umrp), KM_SLEEP); 4472 bcopy(&mip->mi_resource_props, umrp, sizeof (*umrp)); 4473 resmask = umrp->mrp_mask; 4474 mac_update_resources(mrp, umrp, B_FALSE); 4475 newresmask = umrp->mrp_mask; 4476 4477 if (resmask == 0 && newresmask != 0) { 4478 /* 4479 * Bandwidth, priority, cpu or pool link properties configured, 4480 * must disable fastpath. 4481 */ 4482 if ((err = mac_fastpath_disable((mac_handle_t)mip)) != 0) { 4483 kmem_free(umrp, sizeof (*umrp)); 4484 return (err); 4485 } 4486 } 4487 4488 /* 4489 * Since bind_cpu may be modified by mac_client_set_resources() 4490 * we use a copy of bind_cpu and finally cache bind_cpu in mip. 4491 * This allows us to cache only user edits in mip. 4492 */ 4493 tmrp = kmem_zalloc(sizeof (*tmrp), KM_SLEEP); 4494 bcopy(mrp, tmrp, sizeof (*tmrp)); 4495 mcip = mac_primary_client_handle(mip); 4496 if (mcip != NULL && (mcip->mci_state_flags & MCIS_IS_AGGR_PORT) == 0) { 4497 err = mac_client_set_resources((mac_client_handle_t)mcip, tmrp); 4498 } else if ((mrp->mrp_mask & MRP_RX_RINGS || 4499 mrp->mrp_mask & MRP_TX_RINGS)) { 4500 mac_client_impl_t *vmcip; 4501 4502 /* 4503 * If the primary is not up, we need to check if there 4504 * are any VLANs on this primary. If there are then 4505 * we need to set this property on the VLANs since 4506 * VLANs follow the primary they are based on. Just 4507 * look for the first VLAN and change its properties, 4508 * all the other VLANs should be in the same group. 4509 */ 4510 for (vmcip = mip->mi_clients_list; vmcip != NULL; 4511 vmcip = vmcip->mci_client_next) { 4512 if ((vmcip->mci_flent->fe_type & FLOW_PRIMARY_MAC) && 4513 mac_client_vid((mac_client_handle_t)vmcip) != 4514 VLAN_ID_NONE) { 4515 break; 4516 } 4517 } 4518 if (vmcip != NULL) { 4519 mac_resource_props_t *omrp; 4520 mac_resource_props_t *vmrp; 4521 4522 omrp = kmem_zalloc(sizeof (*omrp), KM_SLEEP); 4523 bcopy(MCIP_RESOURCE_PROPS(vmcip), omrp, sizeof (*omrp)); 4524 /* 4525 * We dont' call mac_update_resources since we 4526 * want to take only the ring properties and 4527 * not all the properties that may have changed. 4528 */ 4529 vmrp = MCIP_RESOURCE_PROPS(vmcip); 4530 if (mrp->mrp_mask & MRP_RX_RINGS) { 4531 if (mrp->mrp_mask & MRP_RINGS_RESET) { 4532 vmrp->mrp_mask &= ~MRP_RX_RINGS; 4533 if (vmrp->mrp_mask & 4534 MRP_RXRINGS_UNSPEC) { 4535 vmrp->mrp_mask &= 4536 ~MRP_RXRINGS_UNSPEC; 4537 } 4538 vmrp->mrp_nrxrings = 0; 4539 } else { 4540 vmrp->mrp_mask |= MRP_RX_RINGS; 4541 vmrp->mrp_nrxrings = mrp->mrp_nrxrings; 4542 } 4543 } 4544 if (mrp->mrp_mask & MRP_TX_RINGS) { 4545 if (mrp->mrp_mask & MRP_RINGS_RESET) { 4546 vmrp->mrp_mask &= ~MRP_TX_RINGS; 4547 if (vmrp->mrp_mask & 4548 MRP_TXRINGS_UNSPEC) { 4549 vmrp->mrp_mask &= 4550 ~MRP_TXRINGS_UNSPEC; 4551 } 4552 vmrp->mrp_ntxrings = 0; 4553 } else { 4554 vmrp->mrp_mask |= MRP_TX_RINGS; 4555 vmrp->mrp_ntxrings = mrp->mrp_ntxrings; 4556 } 4557 } 4558 if (mrp->mrp_mask & MRP_RXRINGS_UNSPEC) 4559 vmrp->mrp_mask |= MRP_RXRINGS_UNSPEC; 4560 4561 if (mrp->mrp_mask & MRP_TXRINGS_UNSPEC) 4562 vmrp->mrp_mask |= MRP_TXRINGS_UNSPEC; 4563 4564 if ((err = mac_client_set_rings_prop(vmcip, mrp, 4565 omrp)) != 0) { 4566 bcopy(omrp, MCIP_RESOURCE_PROPS(vmcip), 4567 sizeof (*omrp)); 4568 } else { 4569 mac_set_prim_vlan_rings(mip, vmrp); 4570 } 4571 kmem_free(omrp, sizeof (*omrp)); 4572 } 4573 } 4574 4575 /* Only update the values if mac_client_set_resources succeeded */ 4576 if (err == 0) { 4577 bcopy(umrp, &mip->mi_resource_props, sizeof (*umrp)); 4578 /* 4579 * If bandwidth, priority or cpu link properties cleared, 4580 * renable fastpath. 4581 */ 4582 if (resmask != 0 && newresmask == 0) 4583 mac_fastpath_enable((mac_handle_t)mip); 4584 } else if (resmask == 0 && newresmask != 0) { 4585 mac_fastpath_enable((mac_handle_t)mip); 4586 } 4587 kmem_free(tmrp, sizeof (*tmrp)); 4588 kmem_free(umrp, sizeof (*umrp)); 4589 return (err); 4590 } 4591 4592 int 4593 mac_set_resources(mac_handle_t mh, mac_resource_props_t *mrp) 4594 { 4595 int err; 4596 4597 i_mac_perim_enter((mac_impl_t *)mh); 4598 err = i_mac_set_resources(mh, mrp); 4599 i_mac_perim_exit((mac_impl_t *)mh); 4600 return (err); 4601 } 4602 4603 /* 4604 * Get the properties cached for the specified MAC instance. 4605 */ 4606 void 4607 mac_get_resources(mac_handle_t mh, mac_resource_props_t *mrp) 4608 { 4609 mac_impl_t *mip = (mac_impl_t *)mh; 4610 mac_client_impl_t *mcip; 4611 4612 mcip = mac_primary_client_handle(mip); 4613 if (mcip != NULL) { 4614 mac_client_get_resources((mac_client_handle_t)mcip, mrp); 4615 return; 4616 } 4617 bcopy(&mip->mi_resource_props, mrp, sizeof (mac_resource_props_t)); 4618 } 4619 4620 /* 4621 * Get the effective properties from the primary client of the 4622 * specified MAC instance. 4623 */ 4624 void 4625 mac_get_effective_resources(mac_handle_t mh, mac_resource_props_t *mrp) 4626 { 4627 mac_impl_t *mip = (mac_impl_t *)mh; 4628 mac_client_impl_t *mcip; 4629 4630 mcip = mac_primary_client_handle(mip); 4631 if (mcip != NULL) { 4632 mac_client_get_effective_resources((mac_client_handle_t)mcip, 4633 mrp); 4634 return; 4635 } 4636 bzero(mrp, sizeof (mac_resource_props_t)); 4637 } 4638 4639 int 4640 mac_set_pvid(mac_handle_t mh, uint16_t pvid) 4641 { 4642 mac_impl_t *mip = (mac_impl_t *)mh; 4643 mac_client_impl_t *mcip; 4644 mac_unicast_impl_t *muip; 4645 4646 i_mac_perim_enter(mip); 4647 if (pvid != 0) { 4648 for (mcip = mip->mi_clients_list; mcip != NULL; 4649 mcip = mcip->mci_client_next) { 4650 for (muip = mcip->mci_unicast_list; muip != NULL; 4651 muip = muip->mui_next) { 4652 if (muip->mui_vid == pvid) { 4653 i_mac_perim_exit(mip); 4654 return (EBUSY); 4655 } 4656 } 4657 } 4658 } 4659 mip->mi_pvid = pvid; 4660 i_mac_perim_exit(mip); 4661 return (0); 4662 } 4663 4664 uint16_t 4665 mac_get_pvid(mac_handle_t mh) 4666 { 4667 mac_impl_t *mip = (mac_impl_t *)mh; 4668 4669 return (mip->mi_pvid); 4670 } 4671 4672 uint32_t 4673 mac_get_llimit(mac_handle_t mh) 4674 { 4675 mac_impl_t *mip = (mac_impl_t *)mh; 4676 4677 return (mip->mi_llimit); 4678 } 4679 4680 uint32_t 4681 mac_get_ldecay(mac_handle_t mh) 4682 { 4683 mac_impl_t *mip = (mac_impl_t *)mh; 4684 4685 return (mip->mi_ldecay); 4686 } 4687 4688 /* 4689 * Rename a mac client, its flow, and the kstat. 4690 */ 4691 int 4692 mac_rename_primary(mac_handle_t mh, const char *new_name) 4693 { 4694 mac_impl_t *mip = (mac_impl_t *)mh; 4695 mac_client_impl_t *cur_clnt = NULL; 4696 flow_entry_t *fep; 4697 4698 i_mac_perim_enter(mip); 4699 4700 /* 4701 * VNICs: we need to change the sys flow name and 4702 * the associated flow kstat. 4703 */ 4704 if (mip->mi_state_flags & MIS_IS_VNIC) { 4705 mac_client_impl_t *mcip = mac_vnic_lower(mip); 4706 ASSERT(new_name != NULL); 4707 mac_rename_flow_names(mcip, new_name); 4708 mac_stat_rename(mcip); 4709 goto done; 4710 } 4711 /* 4712 * This mac may itself be an aggr link, or it may have some client 4713 * which is an aggr port. For both cases, we need to change the 4714 * aggr port's mac client name, its flow name and the associated flow 4715 * kstat. 4716 */ 4717 if (mip->mi_state_flags & MIS_IS_AGGR) { 4718 mac_capab_aggr_t aggr_cap; 4719 mac_rename_fn_t rename_fn; 4720 boolean_t ret; 4721 4722 ASSERT(new_name != NULL); 4723 ret = i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_AGGR, 4724 (void *)(&aggr_cap)); 4725 ASSERT(ret == B_TRUE); 4726 rename_fn = aggr_cap.mca_rename_fn; 4727 rename_fn(new_name, mip->mi_driver); 4728 /* 4729 * The aggr's client name and kstat flow name will be 4730 * updated below, i.e. via mac_rename_flow_names. 4731 */ 4732 } 4733 4734 for (cur_clnt = mip->mi_clients_list; cur_clnt != NULL; 4735 cur_clnt = cur_clnt->mci_client_next) { 4736 if (cur_clnt->mci_state_flags & MCIS_IS_AGGR_PORT) { 4737 if (new_name != NULL) { 4738 char *str_st = cur_clnt->mci_name; 4739 char *str_del = strchr(str_st, '-'); 4740 4741 ASSERT(str_del != NULL); 4742 bzero(str_del + 1, MAXNAMELEN - 4743 (str_del - str_st + 1)); 4744 bcopy(new_name, str_del + 1, 4745 strlen(new_name)); 4746 } 4747 fep = cur_clnt->mci_flent; 4748 mac_rename_flow(fep, cur_clnt->mci_name); 4749 break; 4750 } else if (new_name != NULL && 4751 cur_clnt->mci_state_flags & MCIS_USE_DATALINK_NAME) { 4752 mac_rename_flow_names(cur_clnt, new_name); 4753 break; 4754 } 4755 } 4756 4757 /* Recreate kstats associated with aggr pseudo rings */ 4758 if (mip->mi_state_flags & MIS_IS_AGGR) 4759 mac_pseudo_ring_stat_rename(mip); 4760 4761 done: 4762 i_mac_perim_exit(mip); 4763 return (0); 4764 } 4765 4766 /* 4767 * Rename the MAC client's flow names 4768 */ 4769 static void 4770 mac_rename_flow_names(mac_client_impl_t *mcip, const char *new_name) 4771 { 4772 flow_entry_t *flent; 4773 uint16_t vid; 4774 char flowname[MAXFLOWNAMELEN]; 4775 mac_impl_t *mip = mcip->mci_mip; 4776 4777 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip)); 4778 4779 /* 4780 * Use mi_rw_lock to ensure that threads not in the mac perimeter 4781 * see a self-consistent value for mci_name 4782 */ 4783 rw_enter(&mip->mi_rw_lock, RW_WRITER); 4784 (void) strlcpy(mcip->mci_name, new_name, sizeof (mcip->mci_name)); 4785 rw_exit(&mip->mi_rw_lock); 4786 4787 mac_rename_flow(mcip->mci_flent, new_name); 4788 4789 if (mcip->mci_nflents == 1) 4790 return; 4791 4792 /* 4793 * We have to rename all the others too, no stats to destroy for 4794 * these. 4795 */ 4796 for (flent = mcip->mci_flent_list; flent != NULL; 4797 flent = flent->fe_client_next) { 4798 if (flent != mcip->mci_flent) { 4799 vid = i_mac_flow_vid(flent); 4800 (void) sprintf(flowname, "%s%u", new_name, vid); 4801 mac_flow_set_name(flent, flowname); 4802 } 4803 } 4804 } 4805 4806 4807 /* 4808 * Add a flow to the MAC client's flow list - i.e list of MAC/VID tuples 4809 * defined for the specified MAC client. 4810 */ 4811 static void 4812 mac_client_add_to_flow_list(mac_client_impl_t *mcip, flow_entry_t *flent) 4813 { 4814 ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip)); 4815 /* 4816 * The promisc Rx data path walks the mci_flent_list. Protect by 4817 * using mi_rw_lock 4818 */ 4819 rw_enter(&mcip->mci_rw_lock, RW_WRITER); 4820 4821 mcip->mci_vidcache = MCIP_VIDCACHE_INVALID; 4822 4823 /* Add it to the head */ 4824 flent->fe_client_next = mcip->mci_flent_list; 4825 mcip->mci_flent_list = flent; 4826 mcip->mci_nflents++; 4827 4828 /* 4829 * Keep track of the number of non-zero VIDs addresses per MAC 4830 * client to avoid figuring it out in the data-path. 4831 */ 4832 if (i_mac_flow_vid(flent) != VLAN_ID_NONE) 4833 mcip->mci_nvids++; 4834 4835 rw_exit(&mcip->mci_rw_lock); 4836 } 4837 4838 /* 4839 * Remove a flow entry from the MAC client's list. 4840 */ 4841 static void 4842 mac_client_remove_flow_from_list(mac_client_impl_t *mcip, flow_entry_t *flent) 4843 { 4844 flow_entry_t *fe = mcip->mci_flent_list; 4845 flow_entry_t *prev_fe = NULL; 4846 4847 ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip)); 4848 /* 4849 * The promisc Rx data path walks the mci_flent_list. Protect by 4850 * using mci_rw_lock 4851 */ 4852 rw_enter(&mcip->mci_rw_lock, RW_WRITER); 4853 mcip->mci_vidcache = MCIP_VIDCACHE_INVALID; 4854 4855 while ((fe != NULL) && (fe != flent)) { 4856 prev_fe = fe; 4857 fe = fe->fe_client_next; 4858 } 4859 4860 ASSERT(fe != NULL); 4861 if (prev_fe == NULL) { 4862 /* Deleting the first node */ 4863 mcip->mci_flent_list = fe->fe_client_next; 4864 } else { 4865 prev_fe->fe_client_next = fe->fe_client_next; 4866 } 4867 mcip->mci_nflents--; 4868 4869 if (i_mac_flow_vid(flent) != VLAN_ID_NONE) 4870 mcip->mci_nvids--; 4871 4872 rw_exit(&mcip->mci_rw_lock); 4873 } 4874 4875 /* 4876 * Check if the given VID belongs to this MAC client. 4877 */ 4878 boolean_t 4879 mac_client_check_flow_vid(mac_client_impl_t *mcip, uint16_t vid) 4880 { 4881 flow_entry_t *flent; 4882 uint16_t mci_vid; 4883 uint32_t cache = mcip->mci_vidcache; 4884 4885 /* 4886 * In hopes of not having to touch the mci_rw_lock, check to see if 4887 * this vid matches our cached result. 4888 */ 4889 if (MCIP_VIDCACHE_ISVALID(cache) && MCIP_VIDCACHE_VID(cache) == vid) 4890 return (MCIP_VIDCACHE_BOOL(cache) ? B_TRUE : B_FALSE); 4891 4892 /* The mci_flent_list is protected by mci_rw_lock */ 4893 rw_enter(&mcip->mci_rw_lock, RW_WRITER); 4894 for (flent = mcip->mci_flent_list; flent != NULL; 4895 flent = flent->fe_client_next) { 4896 mci_vid = i_mac_flow_vid(flent); 4897 if (vid == mci_vid) { 4898 mcip->mci_vidcache = MCIP_VIDCACHE_CACHE(vid, B_TRUE); 4899 rw_exit(&mcip->mci_rw_lock); 4900 return (B_TRUE); 4901 } 4902 } 4903 4904 mcip->mci_vidcache = MCIP_VIDCACHE_CACHE(vid, B_FALSE); 4905 rw_exit(&mcip->mci_rw_lock); 4906 return (B_FALSE); 4907 } 4908 4909 /* 4910 * Get the flow entry for the specified <MAC addr, VID> tuple. 4911 */ 4912 static flow_entry_t * 4913 mac_client_get_flow(mac_client_impl_t *mcip, mac_unicast_impl_t *muip) 4914 { 4915 mac_address_t *map = mcip->mci_unicast; 4916 flow_entry_t *flent; 4917 uint16_t vid; 4918 flow_desc_t flow_desc; 4919 4920 ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip)); 4921 4922 mac_flow_get_desc(mcip->mci_flent, &flow_desc); 4923 if (bcmp(flow_desc.fd_dst_mac, map->ma_addr, map->ma_len) != 0) 4924 return (NULL); 4925 4926 for (flent = mcip->mci_flent_list; flent != NULL; 4927 flent = flent->fe_client_next) { 4928 vid = i_mac_flow_vid(flent); 4929 if (vid == muip->mui_vid) { 4930 return (flent); 4931 } 4932 } 4933 4934 return (NULL); 4935 } 4936 4937 /* 4938 * Since mci_flent has the SRSs, when we want to remove it, we replace 4939 * the flow_desc_t in mci_flent with that of an existing flent and then 4940 * remove that flent instead of mci_flent. 4941 */ 4942 static flow_entry_t * 4943 mac_client_swap_mciflent(mac_client_impl_t *mcip) 4944 { 4945 flow_entry_t *flent = mcip->mci_flent; 4946 flow_tab_t *ft = flent->fe_flow_tab; 4947 flow_entry_t *flent1; 4948 flow_desc_t fl_desc; 4949 char fl_name[MAXFLOWNAMELEN]; 4950 int err; 4951 4952 ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip)); 4953 ASSERT(mcip->mci_nflents > 1); 4954 4955 /* get the next flent following the primary flent */ 4956 flent1 = mcip->mci_flent_list->fe_client_next; 4957 ASSERT(flent1 != NULL && flent1->fe_flow_tab == ft); 4958 4959 /* 4960 * Remove the flent from the flow table before updating the 4961 * flow descriptor as the hash depends on the flow descriptor. 4962 * This also helps incoming packet classification avoid having 4963 * to grab fe_lock. Access to fe_flow_desc of a flent not in the 4964 * flow table is done under the fe_lock so that log or stat functions 4965 * see a self-consistent fe_flow_desc. The name and desc are specific 4966 * to a flow, the rest are shared by all the clients, including 4967 * resource control etc. 4968 */ 4969 mac_flow_remove(ft, flent, B_TRUE); 4970 mac_flow_remove(ft, flent1, B_TRUE); 4971 4972 bcopy(&flent->fe_flow_desc, &fl_desc, sizeof (flow_desc_t)); 4973 bcopy(flent->fe_flow_name, fl_name, MAXFLOWNAMELEN); 4974 4975 /* update the primary flow entry */ 4976 mutex_enter(&flent->fe_lock); 4977 bcopy(&flent1->fe_flow_desc, &flent->fe_flow_desc, 4978 sizeof (flow_desc_t)); 4979 bcopy(&flent1->fe_flow_name, &flent->fe_flow_name, MAXFLOWNAMELEN); 4980 mutex_exit(&flent->fe_lock); 4981 4982 /* update the flow entry that is to be freed */ 4983 mutex_enter(&flent1->fe_lock); 4984 bcopy(&fl_desc, &flent1->fe_flow_desc, sizeof (flow_desc_t)); 4985 bcopy(fl_name, &flent1->fe_flow_name, MAXFLOWNAMELEN); 4986 mutex_exit(&flent1->fe_lock); 4987 4988 /* now reinsert the flow entries in the table */ 4989 err = mac_flow_add(ft, flent); 4990 ASSERT(err == 0); 4991 4992 err = mac_flow_add(ft, flent1); 4993 ASSERT(err == 0); 4994 4995 return (flent1); 4996 } 4997 4998 /* 4999 * Return whether there is only one flow entry associated with this 5000 * MAC client. 5001 */ 5002 static boolean_t 5003 mac_client_single_rcvr(mac_client_impl_t *mcip) 5004 { 5005 return (mcip->mci_nflents == 1); 5006 } 5007 5008 int 5009 mac_validate_props(mac_impl_t *mip, mac_resource_props_t *mrp) 5010 { 5011 boolean_t reset; 5012 uint32_t rings_needed; 5013 uint32_t rings_avail; 5014 mac_group_type_t gtype; 5015 mac_resource_props_t *mip_mrp; 5016 5017 if (mrp == NULL) 5018 return (0); 5019 5020 if (mrp->mrp_mask & MRP_PRIORITY) { 5021 mac_priority_level_t pri = mrp->mrp_priority; 5022 5023 if (pri < MPL_LOW || pri > MPL_RESET) 5024 return (EINVAL); 5025 } 5026 5027 if (mrp->mrp_mask & MRP_MAXBW) { 5028 uint64_t maxbw = mrp->mrp_maxbw; 5029 5030 if (maxbw < MRP_MAXBW_MINVAL && maxbw != 0) 5031 return (EINVAL); 5032 } 5033 if (mrp->mrp_mask & MRP_CPUS) { 5034 int i, j; 5035 mac_cpu_mode_t fanout; 5036 5037 if (mrp->mrp_ncpus > ncpus) 5038 return (EINVAL); 5039 5040 for (i = 0; i < mrp->mrp_ncpus; i++) { 5041 for (j = 0; j < mrp->mrp_ncpus; j++) { 5042 if (i != j && 5043 mrp->mrp_cpu[i] == mrp->mrp_cpu[j]) { 5044 return (EINVAL); 5045 } 5046 } 5047 } 5048 5049 for (i = 0; i < mrp->mrp_ncpus; i++) { 5050 cpu_t *cp; 5051 int rv; 5052 5053 mutex_enter(&cpu_lock); 5054 cp = cpu_get(mrp->mrp_cpu[i]); 5055 if (cp != NULL) 5056 rv = cpu_is_online(cp); 5057 else 5058 rv = 0; 5059 mutex_exit(&cpu_lock); 5060 if (rv == 0) 5061 return (EINVAL); 5062 } 5063 5064 fanout = mrp->mrp_fanout_mode; 5065 if (fanout < 0 || fanout > MCM_CPUS) 5066 return (EINVAL); 5067 } 5068 5069 if (mrp->mrp_mask & MRP_PROTECT) { 5070 int err = mac_protect_validate(mrp); 5071 if (err != 0) 5072 return (err); 5073 } 5074 5075 if (!(mrp->mrp_mask & MRP_RX_RINGS) && 5076 !(mrp->mrp_mask & MRP_TX_RINGS)) { 5077 return (0); 5078 } 5079 5080 /* 5081 * mip will be null when we come from mac_flow_create or 5082 * mac_link_flow_modify. In the latter case it is a user flow, 5083 * for which we don't support rings. In the former we would 5084 * have validated the props beforehand (i_mac_unicast_add -> 5085 * mac_client_set_resources -> validate for the primary and 5086 * vnic_dev_create -> mac_client_set_resources -> validate for 5087 * a vnic. 5088 */ 5089 if (mip == NULL) 5090 return (0); 5091 5092 /* 5093 * We don't support setting rings property for a VNIC that is using a 5094 * primary address (VLAN) 5095 */ 5096 if ((mip->mi_state_flags & MIS_IS_VNIC) && 5097 mac_is_vnic_primary((mac_handle_t)mip)) { 5098 return (ENOTSUP); 5099 } 5100 5101 mip_mrp = &mip->mi_resource_props; 5102 /* 5103 * The rings property should be validated against the NICs 5104 * resources 5105 */ 5106 if (mip->mi_state_flags & MIS_IS_VNIC) 5107 mip = (mac_impl_t *)mac_get_lower_mac_handle((mac_handle_t)mip); 5108 5109 reset = mrp->mrp_mask & MRP_RINGS_RESET; 5110 /* 5111 * If groups are not supported, return error. 5112 */ 5113 if (((mrp->mrp_mask & MRP_RX_RINGS) && mip->mi_rx_groups == NULL) || 5114 ((mrp->mrp_mask & MRP_TX_RINGS) && mip->mi_tx_groups == NULL)) { 5115 return (EINVAL); 5116 } 5117 /* 5118 * If we are just resetting, there is no validation needed. 5119 */ 5120 if (reset) 5121 return (0); 5122 5123 if (mrp->mrp_mask & MRP_RX_RINGS) { 5124 rings_needed = mrp->mrp_nrxrings; 5125 /* 5126 * We just want to check if the number of additional 5127 * rings requested is available. 5128 */ 5129 if (mip_mrp->mrp_mask & MRP_RX_RINGS) { 5130 if (mrp->mrp_nrxrings > mip_mrp->mrp_nrxrings) 5131 /* Just check for the additional rings */ 5132 rings_needed -= mip_mrp->mrp_nrxrings; 5133 else 5134 /* We are not asking for additional rings */ 5135 rings_needed = 0; 5136 } 5137 rings_avail = mip->mi_rxrings_avail; 5138 gtype = mip->mi_rx_group_type; 5139 } else { 5140 rings_needed = mrp->mrp_ntxrings; 5141 /* Similarly for the TX rings */ 5142 if (mip_mrp->mrp_mask & MRP_TX_RINGS) { 5143 if (mrp->mrp_ntxrings > mip_mrp->mrp_ntxrings) 5144 /* Just check for the additional rings */ 5145 rings_needed -= mip_mrp->mrp_ntxrings; 5146 else 5147 /* We are not asking for additional rings */ 5148 rings_needed = 0; 5149 } 5150 rings_avail = mip->mi_txrings_avail; 5151 gtype = mip->mi_tx_group_type; 5152 } 5153 5154 /* Error if the group is dynamic .. */ 5155 if (gtype == MAC_GROUP_TYPE_DYNAMIC) { 5156 /* 5157 * .. and rings specified are more than available. 5158 */ 5159 if (rings_needed > rings_avail) 5160 return (EINVAL); 5161 } else { 5162 /* 5163 * OR group is static and we have specified some rings. 5164 */ 5165 if (rings_needed > 0) 5166 return (EINVAL); 5167 } 5168 return (0); 5169 } 5170 5171 /* 5172 * Send a MAC_NOTE_LINK notification to all the MAC clients whenever the 5173 * underlying physical link is down. This is to allow MAC clients to 5174 * communicate with other clients. 5175 */ 5176 void 5177 mac_virtual_link_update(mac_impl_t *mip) 5178 { 5179 if (mip->mi_linkstate != LINK_STATE_UP) 5180 i_mac_notify(mip, MAC_NOTE_LINK); 5181 } 5182 5183 /* 5184 * For clients that have a pass-thru MAC, e.g. VNIC, we set the VNIC's 5185 * mac handle in the client. 5186 */ 5187 void 5188 mac_set_upper_mac(mac_client_handle_t mch, mac_handle_t mh, 5189 mac_resource_props_t *mrp) 5190 { 5191 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 5192 mac_impl_t *mip = (mac_impl_t *)mh; 5193 5194 mcip->mci_upper_mip = mip; 5195 /* If there are any properties, copy it over too */ 5196 if (mrp != NULL) { 5197 bcopy(mrp, &mip->mi_resource_props, 5198 sizeof (mac_resource_props_t)); 5199 } 5200 } 5201 5202 /* 5203 * Mark the mac as being used exclusively by the single mac client that is 5204 * doing some control operation on this mac. No further opens of this mac 5205 * will be allowed until this client calls mac_unmark_exclusive. The mac 5206 * client calling this function must already be in the mac perimeter 5207 */ 5208 int 5209 mac_mark_exclusive(mac_handle_t mh) 5210 { 5211 mac_impl_t *mip = (mac_impl_t *)mh; 5212 5213 ASSERT(MAC_PERIM_HELD(mh)); 5214 /* 5215 * Look up its entry in the global hash table. 5216 */ 5217 rw_enter(&i_mac_impl_lock, RW_WRITER); 5218 if (mip->mi_state_flags & MIS_DISABLED) { 5219 rw_exit(&i_mac_impl_lock); 5220 return (ENOENT); 5221 } 5222 5223 /* 5224 * A reference to mac is held even if the link is not plumbed. 5225 * In i_dls_link_create() we open the MAC interface and hold the 5226 * reference. There is an additional reference for the mac_open 5227 * done in acquiring the mac perimeter 5228 */ 5229 if (mip->mi_ref != 2) { 5230 rw_exit(&i_mac_impl_lock); 5231 return (EBUSY); 5232 } 5233 5234 ASSERT(!(mip->mi_state_flags & MIS_EXCLUSIVE_HELD)); 5235 mip->mi_state_flags |= MIS_EXCLUSIVE_HELD; 5236 rw_exit(&i_mac_impl_lock); 5237 return (0); 5238 } 5239 5240 void 5241 mac_unmark_exclusive(mac_handle_t mh) 5242 { 5243 mac_impl_t *mip = (mac_impl_t *)mh; 5244 5245 ASSERT(MAC_PERIM_HELD(mh)); 5246 5247 rw_enter(&i_mac_impl_lock, RW_WRITER); 5248 /* 1 for the creation and another for the perimeter */ 5249 ASSERT(mip->mi_ref == 2 && (mip->mi_state_flags & MIS_EXCLUSIVE_HELD)); 5250 mip->mi_state_flags &= ~MIS_EXCLUSIVE_HELD; 5251 rw_exit(&i_mac_impl_lock); 5252 } 5253 5254 /* 5255 * Set the MTU for the specified MAC. 5256 */ 5257 int 5258 mac_set_mtu(mac_handle_t mh, uint_t new_mtu, uint_t *old_mtu_arg) 5259 { 5260 mac_impl_t *mip = (mac_impl_t *)mh; 5261 uint_t old_mtu; 5262 int rv = 0; 5263 5264 i_mac_perim_enter(mip); 5265 5266 if (!(mip->mi_callbacks->mc_callbacks & (MC_SETPROP|MC_GETPROP))) { 5267 rv = ENOTSUP; 5268 goto bail; 5269 } 5270 5271 old_mtu = mip->mi_sdu_max; 5272 5273 if (new_mtu == 0 || new_mtu < mip->mi_sdu_min) { 5274 rv = EINVAL; 5275 goto bail; 5276 } 5277 5278 rw_enter(&mip->mi_rw_lock, RW_READER); 5279 if (mip->mi_mtrp != NULL && new_mtu < mip->mi_mtrp->mtr_mtu) { 5280 rv = EBUSY; 5281 rw_exit(&mip->mi_rw_lock); 5282 goto bail; 5283 } 5284 rw_exit(&mip->mi_rw_lock); 5285 5286 if (old_mtu != new_mtu) { 5287 rv = mip->mi_callbacks->mc_setprop(mip->mi_driver, 5288 "mtu", MAC_PROP_MTU, sizeof (uint_t), &new_mtu); 5289 if (rv != 0) 5290 goto bail; 5291 rv = mac_maxsdu_update(mh, new_mtu); 5292 ASSERT(rv == 0); 5293 } 5294 5295 bail: 5296 i_mac_perim_exit(mip); 5297 5298 if (rv == 0 && old_mtu_arg != NULL) 5299 *old_mtu_arg = old_mtu; 5300 return (rv); 5301 } 5302 5303 /* 5304 * Return the RX h/w information for the group indexed by grp_num. 5305 */ 5306 void 5307 mac_get_hwrxgrp_info(mac_handle_t mh, int grp_index, uint_t *grp_num, 5308 uint_t *n_rings, uint_t *rings, uint_t *type, uint_t *n_clnts, 5309 char *clnts_name) 5310 { 5311 mac_impl_t *mip = (mac_impl_t *)mh; 5312 mac_grp_client_t *mcip; 5313 uint_t i = 0, index = 0; 5314 mac_ring_t *ring; 5315 5316 /* Revisit when we implement fully dynamic group allocation */ 5317 ASSERT(grp_index >= 0 && grp_index < mip->mi_rx_group_count); 5318 5319 rw_enter(&mip->mi_rw_lock, RW_READER); 5320 *grp_num = mip->mi_rx_groups[grp_index].mrg_index; 5321 *type = mip->mi_rx_groups[grp_index].mrg_type; 5322 *n_rings = mip->mi_rx_groups[grp_index].mrg_cur_count; 5323 ring = mip->mi_rx_groups[grp_index].mrg_rings; 5324 for (index = 0; index < mip->mi_rx_groups[grp_index].mrg_cur_count; 5325 index++) { 5326 rings[index] = ring->mr_index; 5327 ring = ring->mr_next; 5328 } 5329 /* Assuming the 1st is the default group */ 5330 index = 0; 5331 if (grp_index == 0) { 5332 (void) strlcpy(clnts_name, "<default,mcast>,", 5333 MAXCLIENTNAMELEN); 5334 index += strlen("<default,mcast>,"); 5335 } 5336 for (mcip = mip->mi_rx_groups[grp_index].mrg_clients; mcip != NULL; 5337 mcip = mcip->mgc_next) { 5338 int name_len = strlen(mcip->mgc_client->mci_name); 5339 5340 /* 5341 * MAXCLIENTNAMELEN is the buffer size reserved for client 5342 * names. 5343 * XXXX Formating the client name string needs to be moved 5344 * to user land when fixing the size of dhi_clnts in 5345 * dld_hwgrpinfo_t. We should use n_clients * client_name for 5346 * dhi_clntsin instead of MAXCLIENTNAMELEN 5347 */ 5348 if (index + name_len >= MAXCLIENTNAMELEN) { 5349 index = MAXCLIENTNAMELEN; 5350 break; 5351 } 5352 bcopy(mcip->mgc_client->mci_name, &(clnts_name[index]), 5353 name_len); 5354 index += name_len; 5355 clnts_name[index++] = ','; 5356 i++; 5357 } 5358 5359 /* Get rid of the last , */ 5360 if (index > 0) 5361 clnts_name[index - 1] = '\0'; 5362 *n_clnts = i; 5363 rw_exit(&mip->mi_rw_lock); 5364 } 5365 5366 /* 5367 * Return the TX h/w information for the group indexed by grp_num. 5368 */ 5369 void 5370 mac_get_hwtxgrp_info(mac_handle_t mh, int grp_index, uint_t *grp_num, 5371 uint_t *n_rings, uint_t *rings, uint_t *type, uint_t *n_clnts, 5372 char *clnts_name) 5373 { 5374 mac_impl_t *mip = (mac_impl_t *)mh; 5375 mac_grp_client_t *mcip; 5376 uint_t i = 0, index = 0; 5377 mac_ring_t *ring; 5378 5379 /* Revisit when we implement fully dynamic group allocation */ 5380 ASSERT(grp_index >= 0 && grp_index <= mip->mi_tx_group_count); 5381 5382 rw_enter(&mip->mi_rw_lock, RW_READER); 5383 *grp_num = mip->mi_tx_groups[grp_index].mrg_index > 0 ? 5384 mip->mi_tx_groups[grp_index].mrg_index : grp_index; 5385 *type = mip->mi_tx_groups[grp_index].mrg_type; 5386 *n_rings = mip->mi_tx_groups[grp_index].mrg_cur_count; 5387 ring = mip->mi_tx_groups[grp_index].mrg_rings; 5388 for (index = 0; index < mip->mi_tx_groups[grp_index].mrg_cur_count; 5389 index++) { 5390 rings[index] = ring->mr_index; 5391 ring = ring->mr_next; 5392 } 5393 index = 0; 5394 /* Default group has an index of -1 */ 5395 if (mip->mi_tx_groups[grp_index].mrg_index < 0) { 5396 (void) strlcpy(clnts_name, "<default>,", 5397 MAXCLIENTNAMELEN); 5398 index += strlen("<default>,"); 5399 } 5400 for (mcip = mip->mi_tx_groups[grp_index].mrg_clients; mcip != NULL; 5401 mcip = mcip->mgc_next) { 5402 int name_len = strlen(mcip->mgc_client->mci_name); 5403 5404 /* 5405 * MAXCLIENTNAMELEN is the buffer size reserved for client 5406 * names. 5407 * XXXX Formating the client name string needs to be moved 5408 * to user land when fixing the size of dhi_clnts in 5409 * dld_hwgrpinfo_t. We should use n_clients * client_name for 5410 * dhi_clntsin instead of MAXCLIENTNAMELEN 5411 */ 5412 if (index + name_len >= MAXCLIENTNAMELEN) { 5413 index = MAXCLIENTNAMELEN; 5414 break; 5415 } 5416 bcopy(mcip->mgc_client->mci_name, &(clnts_name[index]), 5417 name_len); 5418 index += name_len; 5419 clnts_name[index++] = ','; 5420 i++; 5421 } 5422 5423 /* Get rid of the last , */ 5424 if (index > 0) 5425 clnts_name[index - 1] = '\0'; 5426 *n_clnts = i; 5427 rw_exit(&mip->mi_rw_lock); 5428 } 5429 5430 /* 5431 * Return the group count for RX or TX. 5432 */ 5433 uint_t 5434 mac_hwgrp_num(mac_handle_t mh, int type) 5435 { 5436 mac_impl_t *mip = (mac_impl_t *)mh; 5437 5438 /* 5439 * Return the Rx and Tx group count; for the Tx we need to 5440 * include the default too. 5441 */ 5442 return (type == MAC_RING_TYPE_RX ? mip->mi_rx_group_count : 5443 mip->mi_tx_groups != NULL ? mip->mi_tx_group_count + 1 : 0); 5444 } 5445 5446 /* 5447 * The total number of free TX rings for this MAC. 5448 */ 5449 uint_t 5450 mac_txavail_get(mac_handle_t mh) 5451 { 5452 mac_impl_t *mip = (mac_impl_t *)mh; 5453 5454 return (mip->mi_txrings_avail); 5455 } 5456 5457 /* 5458 * The total number of free RX rings for this MAC. 5459 */ 5460 uint_t 5461 mac_rxavail_get(mac_handle_t mh) 5462 { 5463 mac_impl_t *mip = (mac_impl_t *)mh; 5464 5465 return (mip->mi_rxrings_avail); 5466 } 5467 5468 /* 5469 * The total number of reserved RX rings on this MAC. 5470 */ 5471 uint_t 5472 mac_rxrsvd_get(mac_handle_t mh) 5473 { 5474 mac_impl_t *mip = (mac_impl_t *)mh; 5475 5476 return (mip->mi_rxrings_rsvd); 5477 } 5478 5479 /* 5480 * The total number of reserved TX rings on this MAC. 5481 */ 5482 uint_t 5483 mac_txrsvd_get(mac_handle_t mh) 5484 { 5485 mac_impl_t *mip = (mac_impl_t *)mh; 5486 5487 return (mip->mi_txrings_rsvd); 5488 } 5489 5490 /* 5491 * Total number of free RX groups on this MAC. 5492 */ 5493 uint_t 5494 mac_rxhwlnksavail_get(mac_handle_t mh) 5495 { 5496 mac_impl_t *mip = (mac_impl_t *)mh; 5497 5498 return (mip->mi_rxhwclnt_avail); 5499 } 5500 5501 /* 5502 * Total number of RX groups reserved on this MAC. 5503 */ 5504 uint_t 5505 mac_rxhwlnksrsvd_get(mac_handle_t mh) 5506 { 5507 mac_impl_t *mip = (mac_impl_t *)mh; 5508 5509 return (mip->mi_rxhwclnt_used); 5510 } 5511 5512 /* 5513 * Total number of free TX groups on this MAC. 5514 */ 5515 uint_t 5516 mac_txhwlnksavail_get(mac_handle_t mh) 5517 { 5518 mac_impl_t *mip = (mac_impl_t *)mh; 5519 5520 return (mip->mi_txhwclnt_avail); 5521 } 5522 5523 /* 5524 * Total number of TX groups reserved on this MAC. 5525 */ 5526 uint_t 5527 mac_txhwlnksrsvd_get(mac_handle_t mh) 5528 { 5529 mac_impl_t *mip = (mac_impl_t *)mh; 5530 5531 return (mip->mi_txhwclnt_used); 5532 } 5533 5534 /* 5535 * Initialize the rings property for a mac client. A non-0 value for 5536 * rxring or txring specifies the number of rings required, a value 5537 * of MAC_RXRINGS_NONE/MAC_TXRINGS_NONE specifies that it doesn't need 5538 * any RX/TX rings and a value of MAC_RXRINGS_DONTCARE/MAC_TXRINGS_DONTCARE 5539 * means the system can decide whether it can give any rings or not. 5540 */ 5541 void 5542 mac_client_set_rings(mac_client_handle_t mch, int rxrings, int txrings) 5543 { 5544 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 5545 mac_resource_props_t *mrp = MCIP_RESOURCE_PROPS(mcip); 5546 5547 if (rxrings != MAC_RXRINGS_DONTCARE) { 5548 mrp->mrp_mask |= MRP_RX_RINGS; 5549 mrp->mrp_nrxrings = rxrings; 5550 } 5551 5552 if (txrings != MAC_TXRINGS_DONTCARE) { 5553 mrp->mrp_mask |= MRP_TX_RINGS; 5554 mrp->mrp_ntxrings = txrings; 5555 } 5556 } 5557 5558 boolean_t 5559 mac_get_promisc_filtered(mac_client_handle_t mch) 5560 { 5561 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 5562 5563 return (mcip->mci_protect_flags & MPT_FLAG_PROMISC_FILTERED); 5564 } 5565 5566 void 5567 mac_set_promisc_filtered(mac_client_handle_t mch, boolean_t enable) 5568 { 5569 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 5570 5571 ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip)); 5572 if (enable) 5573 mcip->mci_protect_flags |= MPT_FLAG_PROMISC_FILTERED; 5574 else 5575 mcip->mci_protect_flags &= ~MPT_FLAG_PROMISC_FILTERED; 5576 } 5577