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 2017 OmniTI Computer Consulting, Inc. All rights reserved. 25 */ 26 27 #include <sys/types.h> 28 #include <sys/conf.h> 29 #include <sys/id_space.h> 30 #include <sys/esunddi.h> 31 #include <sys/stat.h> 32 #include <sys/mkdev.h> 33 #include <sys/stream.h> 34 #include <sys/strsubr.h> 35 #include <sys/dlpi.h> 36 #include <sys/modhash.h> 37 #include <sys/mac.h> 38 #include <sys/mac_provider.h> 39 #include <sys/mac_impl.h> 40 #include <sys/mac_client_impl.h> 41 #include <sys/mac_client_priv.h> 42 #include <sys/mac_soft_ring.h> 43 #include <sys/mac_stat.h> 44 #include <sys/dld.h> 45 #include <sys/modctl.h> 46 #include <sys/fs/dv_node.h> 47 #include <sys/thread.h> 48 #include <sys/proc.h> 49 #include <sys/callb.h> 50 #include <sys/cpuvar.h> 51 #include <sys/atomic.h> 52 #include <sys/sdt.h> 53 #include <sys/mac_flow.h> 54 #include <sys/ddi_intr_impl.h> 55 #include <sys/disp.h> 56 #include <sys/sdt.h> 57 #include <sys/pattr.h> 58 #include <sys/strsun.h> 59 60 /* 61 * MAC Provider Interface. 62 * 63 * Interface for GLDv3 compatible NIC drivers. 64 */ 65 66 static void i_mac_notify_thread(void *); 67 68 typedef void (*mac_notify_default_cb_fn_t)(mac_impl_t *); 69 70 static const mac_notify_default_cb_fn_t mac_notify_cb_list[MAC_NNOTE] = { 71 mac_fanout_recompute, /* MAC_NOTE_LINK */ 72 NULL, /* MAC_NOTE_UNICST */ 73 NULL, /* MAC_NOTE_TX */ 74 NULL, /* MAC_NOTE_DEVPROMISC */ 75 NULL, /* MAC_NOTE_FASTPATH_FLUSH */ 76 NULL, /* MAC_NOTE_SDU_SIZE */ 77 NULL, /* MAC_NOTE_MARGIN */ 78 NULL, /* MAC_NOTE_CAPAB_CHG */ 79 NULL /* MAC_NOTE_LOWLINK */ 80 }; 81 82 /* 83 * Driver support functions. 84 */ 85 86 /* REGISTRATION */ 87 88 mac_register_t * 89 mac_alloc(uint_t mac_version) 90 { 91 mac_register_t *mregp; 92 93 /* 94 * Make sure there isn't a version mismatch between the driver and 95 * the framework. In the future, if multiple versions are 96 * supported, this check could become more sophisticated. 97 */ 98 if (mac_version != MAC_VERSION) 99 return (NULL); 100 101 mregp = kmem_zalloc(sizeof (mac_register_t), KM_SLEEP); 102 mregp->m_version = mac_version; 103 return (mregp); 104 } 105 106 void 107 mac_free(mac_register_t *mregp) 108 { 109 kmem_free(mregp, sizeof (mac_register_t)); 110 } 111 112 /* 113 * mac_register() is how drivers register new MACs with the GLDv3 114 * framework. The mregp argument is allocated by drivers using the 115 * mac_alloc() function, and can be freed using mac_free() immediately upon 116 * return from mac_register(). Upon success (0 return value), the mhp 117 * opaque pointer becomes the driver's handle to its MAC interface, and is 118 * the argument to all other mac module entry points. 119 */ 120 /* ARGSUSED */ 121 int 122 mac_register(mac_register_t *mregp, mac_handle_t *mhp) 123 { 124 mac_impl_t *mip; 125 mactype_t *mtype; 126 int err = EINVAL; 127 struct devnames *dnp = NULL; 128 uint_t instance; 129 boolean_t style1_created = B_FALSE; 130 boolean_t style2_created = B_FALSE; 131 char *driver; 132 minor_t minor = 0; 133 134 /* A successful call to mac_init_ops() sets the DN_GLDV3_DRIVER flag. */ 135 if (!GLDV3_DRV(ddi_driver_major(mregp->m_dip))) 136 return (EINVAL); 137 138 /* Find the required MAC-Type plugin. */ 139 if ((mtype = mactype_getplugin(mregp->m_type_ident)) == NULL) 140 return (EINVAL); 141 142 /* Create a mac_impl_t to represent this MAC. */ 143 mip = kmem_cache_alloc(i_mac_impl_cachep, KM_SLEEP); 144 145 /* 146 * The mac is not ready for open yet. 147 */ 148 mip->mi_state_flags |= MIS_DISABLED; 149 150 /* 151 * When a mac is registered, the m_instance field can be set to: 152 * 153 * 0: Get the mac's instance number from m_dip. 154 * This is usually used for physical device dips. 155 * 156 * [1 .. MAC_MAX_MINOR-1]: Use the value as the mac's instance number. 157 * For example, when an aggregation is created with the key option, 158 * "key" will be used as the instance number. 159 * 160 * -1: Assign an instance number from [MAC_MAX_MINOR .. MAXMIN-1]. 161 * This is often used when a MAC of a virtual link is registered 162 * (e.g., aggregation when "key" is not specified, or vnic). 163 * 164 * Note that the instance number is used to derive the mi_minor field 165 * of mac_impl_t, which will then be used to derive the name of kstats 166 * and the devfs nodes. The first 2 cases are needed to preserve 167 * backward compatibility. 168 */ 169 switch (mregp->m_instance) { 170 case 0: 171 instance = ddi_get_instance(mregp->m_dip); 172 break; 173 case ((uint_t)-1): 174 minor = mac_minor_hold(B_TRUE); 175 if (minor == 0) { 176 err = ENOSPC; 177 goto fail; 178 } 179 instance = minor - 1; 180 break; 181 default: 182 instance = mregp->m_instance; 183 if (instance >= MAC_MAX_MINOR) { 184 err = EINVAL; 185 goto fail; 186 } 187 break; 188 } 189 190 mip->mi_minor = (minor_t)(instance + 1); 191 mip->mi_dip = mregp->m_dip; 192 mip->mi_clients_list = NULL; 193 mip->mi_nclients = 0; 194 195 /* Set the default IEEE Port VLAN Identifier */ 196 mip->mi_pvid = 1; 197 198 /* Default bridge link learning protection values */ 199 mip->mi_llimit = 1000; 200 mip->mi_ldecay = 200; 201 202 driver = (char *)ddi_driver_name(mip->mi_dip); 203 204 /* Construct the MAC name as <drvname><instance> */ 205 (void) snprintf(mip->mi_name, sizeof (mip->mi_name), "%s%d", 206 driver, instance); 207 208 mip->mi_driver = mregp->m_driver; 209 210 mip->mi_type = mtype; 211 mip->mi_margin = mregp->m_margin; 212 mip->mi_info.mi_media = mtype->mt_type; 213 mip->mi_info.mi_nativemedia = mtype->mt_nativetype; 214 if (mregp->m_max_sdu <= mregp->m_min_sdu) 215 goto fail; 216 if (mregp->m_multicast_sdu == 0) 217 mregp->m_multicast_sdu = mregp->m_max_sdu; 218 if (mregp->m_multicast_sdu < mregp->m_min_sdu || 219 mregp->m_multicast_sdu > mregp->m_max_sdu) 220 goto fail; 221 mip->mi_sdu_min = mregp->m_min_sdu; 222 mip->mi_sdu_max = mregp->m_max_sdu; 223 mip->mi_sdu_multicast = mregp->m_multicast_sdu; 224 mip->mi_info.mi_addr_length = mip->mi_type->mt_addr_length; 225 /* 226 * If the media supports a broadcast address, cache a pointer to it 227 * in the mac_info_t so that upper layers can use it. 228 */ 229 mip->mi_info.mi_brdcst_addr = mip->mi_type->mt_brdcst_addr; 230 231 mip->mi_v12n_level = mregp->m_v12n; 232 233 /* 234 * Copy the unicast source address into the mac_info_t, but only if 235 * the MAC-Type defines a non-zero address length. We need to 236 * handle MAC-Types that have an address length of 0 237 * (point-to-point protocol MACs for example). 238 */ 239 if (mip->mi_type->mt_addr_length > 0) { 240 if (mregp->m_src_addr == NULL) 241 goto fail; 242 mip->mi_info.mi_unicst_addr = 243 kmem_alloc(mip->mi_type->mt_addr_length, KM_SLEEP); 244 bcopy(mregp->m_src_addr, mip->mi_info.mi_unicst_addr, 245 mip->mi_type->mt_addr_length); 246 247 /* 248 * Copy the fixed 'factory' MAC address from the immutable 249 * info. This is taken to be the MAC address currently in 250 * use. 251 */ 252 bcopy(mip->mi_info.mi_unicst_addr, mip->mi_addr, 253 mip->mi_type->mt_addr_length); 254 255 /* 256 * At this point, we should set up the classification 257 * rules etc but we delay it till mac_open() so that 258 * the resource discovery has taken place and we 259 * know someone wants to use the device. Otherwise 260 * memory gets allocated for Rx ring structures even 261 * during probe. 262 */ 263 264 /* Copy the destination address if one is provided. */ 265 if (mregp->m_dst_addr != NULL) { 266 bcopy(mregp->m_dst_addr, mip->mi_dstaddr, 267 mip->mi_type->mt_addr_length); 268 mip->mi_dstaddr_set = B_TRUE; 269 } 270 } else if (mregp->m_src_addr != NULL) { 271 goto fail; 272 } 273 274 /* 275 * The format of the m_pdata is specific to the plugin. It is 276 * passed in as an argument to all of the plugin callbacks. The 277 * driver can update this information by calling 278 * mac_pdata_update(). 279 */ 280 if (mip->mi_type->mt_ops.mtops_ops & MTOPS_PDATA_VERIFY) { 281 /* 282 * Verify if the supplied plugin data is valid. Note that 283 * even if the caller passed in a NULL pointer as plugin data, 284 * we still need to verify if that's valid as the plugin may 285 * require plugin data to function. 286 */ 287 if (!mip->mi_type->mt_ops.mtops_pdata_verify(mregp->m_pdata, 288 mregp->m_pdata_size)) { 289 goto fail; 290 } 291 if (mregp->m_pdata != NULL) { 292 mip->mi_pdata = 293 kmem_alloc(mregp->m_pdata_size, KM_SLEEP); 294 bcopy(mregp->m_pdata, mip->mi_pdata, 295 mregp->m_pdata_size); 296 mip->mi_pdata_size = mregp->m_pdata_size; 297 } 298 } else if (mregp->m_pdata != NULL) { 299 /* 300 * The caller supplied non-NULL plugin data, but the plugin 301 * does not recognize plugin data. 302 */ 303 err = EINVAL; 304 goto fail; 305 } 306 307 /* 308 * Register the private properties. 309 */ 310 mac_register_priv_prop(mip, mregp->m_priv_props); 311 312 /* 313 * Stash the driver callbacks into the mac_impl_t, but first sanity 314 * check to make sure all mandatory callbacks are set. 315 */ 316 if (mregp->m_callbacks->mc_getstat == NULL || 317 mregp->m_callbacks->mc_start == NULL || 318 mregp->m_callbacks->mc_stop == NULL || 319 mregp->m_callbacks->mc_setpromisc == NULL || 320 mregp->m_callbacks->mc_multicst == NULL) { 321 goto fail; 322 } 323 mip->mi_callbacks = mregp->m_callbacks; 324 325 if (mac_capab_get((mac_handle_t)mip, MAC_CAPAB_LEGACY, 326 &mip->mi_capab_legacy)) { 327 mip->mi_state_flags |= MIS_LEGACY; 328 mip->mi_phy_dev = mip->mi_capab_legacy.ml_dev; 329 } else { 330 mip->mi_phy_dev = makedevice(ddi_driver_major(mip->mi_dip), 331 mip->mi_minor); 332 } 333 334 /* 335 * Allocate a notification thread. thread_create blocks for memory 336 * if needed, it never fails. 337 */ 338 mip->mi_notify_thread = thread_create(NULL, 0, i_mac_notify_thread, 339 mip, 0, &p0, TS_RUN, minclsyspri); 340 341 /* 342 * Initialize the capabilities 343 */ 344 345 bzero(&mip->mi_rx_rings_cap, sizeof (mac_capab_rings_t)); 346 bzero(&mip->mi_tx_rings_cap, sizeof (mac_capab_rings_t)); 347 348 if (i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_VNIC, NULL)) 349 mip->mi_state_flags |= MIS_IS_VNIC; 350 351 if (i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_AGGR, NULL)) 352 mip->mi_state_flags |= MIS_IS_AGGR; 353 354 mac_addr_factory_init(mip); 355 356 mac_transceiver_init(mip); 357 358 mac_led_init(mip); 359 360 /* 361 * Enforce the virtrualization level registered. 362 */ 363 if (mip->mi_v12n_level & MAC_VIRT_LEVEL1) { 364 if (mac_init_rings(mip, MAC_RING_TYPE_RX) != 0 || 365 mac_init_rings(mip, MAC_RING_TYPE_TX) != 0) 366 goto fail; 367 368 /* 369 * The driver needs to register at least rx rings for this 370 * virtualization level. 371 */ 372 if (mip->mi_rx_groups == NULL) 373 goto fail; 374 } 375 376 /* 377 * The driver must set mc_unicst entry point to NULL when it advertises 378 * CAP_RINGS for rx groups. 379 */ 380 if (mip->mi_rx_groups != NULL) { 381 if (mregp->m_callbacks->mc_unicst != NULL) 382 goto fail; 383 } else { 384 if (mregp->m_callbacks->mc_unicst == NULL) 385 goto fail; 386 } 387 388 /* 389 * Initialize MAC addresses. Must be called after mac_init_rings(). 390 */ 391 mac_init_macaddr(mip); 392 393 mip->mi_share_capab.ms_snum = 0; 394 if (mip->mi_v12n_level & MAC_VIRT_HIO) { 395 (void) mac_capab_get((mac_handle_t)mip, MAC_CAPAB_SHARES, 396 &mip->mi_share_capab); 397 } 398 399 /* 400 * Initialize the kstats for this device. 401 */ 402 mac_driver_stat_create(mip); 403 404 /* Zero out any properties. */ 405 bzero(&mip->mi_resource_props, sizeof (mac_resource_props_t)); 406 407 if (mip->mi_minor <= MAC_MAX_MINOR) { 408 /* Create a style-2 DLPI device */ 409 if (ddi_create_minor_node(mip->mi_dip, driver, S_IFCHR, 0, 410 DDI_NT_NET, CLONE_DEV) != DDI_SUCCESS) 411 goto fail; 412 style2_created = B_TRUE; 413 414 /* Create a style-1 DLPI device */ 415 if (ddi_create_minor_node(mip->mi_dip, mip->mi_name, S_IFCHR, 416 mip->mi_minor, DDI_NT_NET, 0) != DDI_SUCCESS) 417 goto fail; 418 style1_created = B_TRUE; 419 } 420 421 mac_flow_l2tab_create(mip, &mip->mi_flow_tab); 422 423 rw_enter(&i_mac_impl_lock, RW_WRITER); 424 if (mod_hash_insert(i_mac_impl_hash, 425 (mod_hash_key_t)mip->mi_name, (mod_hash_val_t)mip) != 0) { 426 rw_exit(&i_mac_impl_lock); 427 err = EEXIST; 428 goto fail; 429 } 430 431 DTRACE_PROBE2(mac__register, struct devnames *, dnp, 432 (mac_impl_t *), mip); 433 434 /* 435 * Mark the MAC to be ready for open. 436 */ 437 mip->mi_state_flags &= ~MIS_DISABLED; 438 rw_exit(&i_mac_impl_lock); 439 440 atomic_inc_32(&i_mac_impl_count); 441 442 cmn_err(CE_NOTE, "!%s registered", mip->mi_name); 443 *mhp = (mac_handle_t)mip; 444 return (0); 445 446 fail: 447 if (style1_created) 448 ddi_remove_minor_node(mip->mi_dip, mip->mi_name); 449 450 if (style2_created) 451 ddi_remove_minor_node(mip->mi_dip, driver); 452 453 mac_addr_factory_fini(mip); 454 455 /* Clean up registered MAC addresses */ 456 mac_fini_macaddr(mip); 457 458 /* Clean up registered rings */ 459 mac_free_rings(mip, MAC_RING_TYPE_RX); 460 mac_free_rings(mip, MAC_RING_TYPE_TX); 461 462 /* Clean up notification thread */ 463 if (mip->mi_notify_thread != NULL) 464 i_mac_notify_exit(mip); 465 466 if (mip->mi_info.mi_unicst_addr != NULL) { 467 kmem_free(mip->mi_info.mi_unicst_addr, 468 mip->mi_type->mt_addr_length); 469 mip->mi_info.mi_unicst_addr = NULL; 470 } 471 472 mac_driver_stat_delete(mip); 473 474 if (mip->mi_type != NULL) { 475 atomic_dec_32(&mip->mi_type->mt_ref); 476 mip->mi_type = NULL; 477 } 478 479 if (mip->mi_pdata != NULL) { 480 kmem_free(mip->mi_pdata, mip->mi_pdata_size); 481 mip->mi_pdata = NULL; 482 mip->mi_pdata_size = 0; 483 } 484 485 if (minor != 0) { 486 ASSERT(minor > MAC_MAX_MINOR); 487 mac_minor_rele(minor); 488 } 489 490 mip->mi_state_flags = 0; 491 mac_unregister_priv_prop(mip); 492 493 /* 494 * Clear the state before destroying the mac_impl_t 495 */ 496 mip->mi_state_flags = 0; 497 498 kmem_cache_free(i_mac_impl_cachep, mip); 499 return (err); 500 } 501 502 /* 503 * Unregister from the GLDv3 framework 504 */ 505 int 506 mac_unregister(mac_handle_t mh) 507 { 508 int err; 509 mac_impl_t *mip = (mac_impl_t *)mh; 510 mod_hash_val_t val; 511 mac_margin_req_t *mmr, *nextmmr; 512 513 /* Fail the unregister if there are any open references to this mac. */ 514 if ((err = mac_disable_nowait(mh)) != 0) 515 return (err); 516 517 /* 518 * Clean up notification thread and wait for it to exit. 519 */ 520 i_mac_notify_exit(mip); 521 522 /* 523 * Prior to acquiring the MAC perimeter, remove the MAC instance from 524 * the internal hash table. Such removal means table-walkers that 525 * acquire the perimeter will not do so on behalf of what we are 526 * unregistering, which prevents a deadlock. 527 */ 528 rw_enter(&i_mac_impl_lock, RW_WRITER); 529 (void) mod_hash_remove(i_mac_impl_hash, 530 (mod_hash_key_t)mip->mi_name, &val); 531 rw_exit(&i_mac_impl_lock); 532 ASSERT(mip == (mac_impl_t *)val); 533 534 i_mac_perim_enter(mip); 535 536 /* 537 * There is still resource properties configured over this mac. 538 */ 539 if (mip->mi_resource_props.mrp_mask != 0) 540 mac_fastpath_enable((mac_handle_t)mip); 541 542 if (mip->mi_minor < MAC_MAX_MINOR + 1) { 543 ddi_remove_minor_node(mip->mi_dip, mip->mi_name); 544 ddi_remove_minor_node(mip->mi_dip, 545 (char *)ddi_driver_name(mip->mi_dip)); 546 } 547 548 ASSERT(mip->mi_nactiveclients == 0 && !(mip->mi_state_flags & 549 MIS_EXCLUSIVE)); 550 551 mac_driver_stat_delete(mip); 552 553 ASSERT(i_mac_impl_count > 0); 554 atomic_dec_32(&i_mac_impl_count); 555 556 if (mip->mi_pdata != NULL) 557 kmem_free(mip->mi_pdata, mip->mi_pdata_size); 558 mip->mi_pdata = NULL; 559 mip->mi_pdata_size = 0; 560 561 /* 562 * Free the list of margin request. 563 */ 564 for (mmr = mip->mi_mmrp; mmr != NULL; mmr = nextmmr) { 565 nextmmr = mmr->mmr_nextp; 566 kmem_free(mmr, sizeof (mac_margin_req_t)); 567 } 568 mip->mi_mmrp = NULL; 569 570 mip->mi_linkstate = mip->mi_lowlinkstate = LINK_STATE_UNKNOWN; 571 kmem_free(mip->mi_info.mi_unicst_addr, mip->mi_type->mt_addr_length); 572 mip->mi_info.mi_unicst_addr = NULL; 573 574 atomic_dec_32(&mip->mi_type->mt_ref); 575 mip->mi_type = NULL; 576 577 /* 578 * Free the primary MAC address. 579 */ 580 mac_fini_macaddr(mip); 581 582 /* 583 * free all rings 584 */ 585 mac_free_rings(mip, MAC_RING_TYPE_RX); 586 mac_free_rings(mip, MAC_RING_TYPE_TX); 587 588 mac_addr_factory_fini(mip); 589 590 bzero(mip->mi_addr, MAXMACADDRLEN); 591 bzero(mip->mi_dstaddr, MAXMACADDRLEN); 592 mip->mi_dstaddr_set = B_FALSE; 593 594 /* and the flows */ 595 mac_flow_tab_destroy(mip->mi_flow_tab); 596 mip->mi_flow_tab = NULL; 597 598 if (mip->mi_minor > MAC_MAX_MINOR) 599 mac_minor_rele(mip->mi_minor); 600 601 cmn_err(CE_NOTE, "!%s unregistered", mip->mi_name); 602 603 /* 604 * Reset the perim related fields to default values before 605 * kmem_cache_free 606 */ 607 i_mac_perim_exit(mip); 608 mip->mi_state_flags = 0; 609 610 mac_unregister_priv_prop(mip); 611 612 ASSERT(mip->mi_bridge_link == NULL); 613 kmem_cache_free(i_mac_impl_cachep, mip); 614 615 return (0); 616 } 617 618 /* DATA RECEPTION */ 619 620 /* 621 * This function is invoked for packets received by the MAC driver in 622 * interrupt context. The ring generation number provided by the driver 623 * is matched with the ring generation number held in MAC. If they do not 624 * match, received packets are considered stale packets coming from an older 625 * assignment of the ring. Drop them. 626 */ 627 void 628 mac_rx_ring(mac_handle_t mh, mac_ring_handle_t mrh, mblk_t *mp_chain, 629 uint64_t mr_gen_num) 630 { 631 mac_ring_t *mr = (mac_ring_t *)mrh; 632 633 if ((mr != NULL) && (mr->mr_gen_num != mr_gen_num)) { 634 DTRACE_PROBE2(mac__rx__rings__stale__packet, uint64_t, 635 mr->mr_gen_num, uint64_t, mr_gen_num); 636 freemsgchain(mp_chain); 637 return; 638 } 639 mac_rx(mh, (mac_resource_handle_t)mrh, mp_chain); 640 } 641 642 /* 643 * This function is invoked for each packet received by the underlying driver. 644 */ 645 void 646 mac_rx(mac_handle_t mh, mac_resource_handle_t mrh, mblk_t *mp_chain) 647 { 648 mac_impl_t *mip = (mac_impl_t *)mh; 649 650 /* 651 * Check if the link is part of a bridge. If not, then we don't need 652 * to take the lock to remain consistent. Make this common case 653 * lock-free and tail-call optimized. 654 */ 655 if (mip->mi_bridge_link == NULL) { 656 mac_rx_common(mh, mrh, mp_chain); 657 } else { 658 /* 659 * Once we take a reference on the bridge link, the bridge 660 * module itself can't unload, so the callback pointers are 661 * stable. 662 */ 663 mutex_enter(&mip->mi_bridge_lock); 664 if ((mh = mip->mi_bridge_link) != NULL) 665 mac_bridge_ref_cb(mh, B_TRUE); 666 mutex_exit(&mip->mi_bridge_lock); 667 if (mh == NULL) { 668 mac_rx_common((mac_handle_t)mip, mrh, mp_chain); 669 } else { 670 mac_bridge_rx_cb(mh, mrh, mp_chain); 671 mac_bridge_ref_cb(mh, B_FALSE); 672 } 673 } 674 } 675 676 /* 677 * Special case function: this allows snooping of packets transmitted and 678 * received by TRILL. By design, they go directly into the TRILL module. 679 */ 680 void 681 mac_trill_snoop(mac_handle_t mh, mblk_t *mp) 682 { 683 mac_impl_t *mip = (mac_impl_t *)mh; 684 685 if (mip->mi_promisc_list != NULL) 686 mac_promisc_dispatch(mip, mp, NULL); 687 } 688 689 /* 690 * This is the upward reentry point for packets arriving from the bridging 691 * module and from mac_rx for links not part of a bridge. 692 */ 693 void 694 mac_rx_common(mac_handle_t mh, mac_resource_handle_t mrh, mblk_t *mp_chain) 695 { 696 mac_impl_t *mip = (mac_impl_t *)mh; 697 mac_ring_t *mr = (mac_ring_t *)mrh; 698 mac_soft_ring_set_t *mac_srs; 699 mblk_t *bp = mp_chain; 700 boolean_t hw_classified = B_FALSE; 701 702 /* 703 * If there are any promiscuous mode callbacks defined for 704 * this MAC, pass them a copy if appropriate. 705 */ 706 if (mip->mi_promisc_list != NULL) 707 mac_promisc_dispatch(mip, mp_chain, NULL); 708 709 if (mr != NULL) { 710 /* 711 * If the SRS teardown has started, just return. The 'mr' 712 * continues to be valid until the driver unregisters the mac. 713 * Hardware classified packets will not make their way up 714 * beyond this point once the teardown has started. The driver 715 * is never passed a pointer to a flow entry or SRS or any 716 * structure that can be freed much before mac_unregister. 717 */ 718 mutex_enter(&mr->mr_lock); 719 if ((mr->mr_state != MR_INUSE) || (mr->mr_flag & 720 (MR_INCIPIENT | MR_CONDEMNED | MR_QUIESCE))) { 721 mutex_exit(&mr->mr_lock); 722 freemsgchain(mp_chain); 723 return; 724 } 725 if (mr->mr_classify_type == MAC_HW_CLASSIFIER) { 726 hw_classified = B_TRUE; 727 MR_REFHOLD_LOCKED(mr); 728 } 729 mutex_exit(&mr->mr_lock); 730 731 /* 732 * We check if an SRS is controlling this ring. 733 * If so, we can directly call the srs_lower_proc 734 * routine otherwise we need to go through mac_rx_classify 735 * to reach the right place. 736 */ 737 if (hw_classified) { 738 mac_srs = mr->mr_srs; 739 /* 740 * This is supposed to be the fast path. 741 * All packets received though here were steered by 742 * the hardware classifier, and share the same 743 * MAC header info. 744 */ 745 mac_srs->srs_rx.sr_lower_proc(mh, 746 (mac_resource_handle_t)mac_srs, mp_chain, B_FALSE); 747 MR_REFRELE(mr); 748 return; 749 } 750 /* We'll fall through to software classification */ 751 } else { 752 flow_entry_t *flent; 753 int err; 754 755 rw_enter(&mip->mi_rw_lock, RW_READER); 756 if (mip->mi_single_active_client != NULL) { 757 flent = mip->mi_single_active_client->mci_flent_list; 758 FLOW_TRY_REFHOLD(flent, err); 759 rw_exit(&mip->mi_rw_lock); 760 if (err == 0) { 761 (flent->fe_cb_fn)(flent->fe_cb_arg1, 762 flent->fe_cb_arg2, mp_chain, B_FALSE); 763 FLOW_REFRELE(flent); 764 return; 765 } 766 } else { 767 rw_exit(&mip->mi_rw_lock); 768 } 769 } 770 771 if (!FLOW_TAB_EMPTY(mip->mi_flow_tab)) { 772 if ((bp = mac_rx_flow(mh, mrh, bp)) == NULL) 773 return; 774 } 775 776 freemsgchain(bp); 777 } 778 779 /* DATA TRANSMISSION */ 780 781 /* 782 * A driver's notification to resume transmission, in case of a provider 783 * without TX rings. 784 */ 785 void 786 mac_tx_update(mac_handle_t mh) 787 { 788 mac_tx_ring_update(mh, NULL); 789 } 790 791 /* 792 * A driver's notification to resume transmission on the specified TX ring. 793 */ 794 void 795 mac_tx_ring_update(mac_handle_t mh, mac_ring_handle_t rh) 796 { 797 i_mac_tx_srs_notify((mac_impl_t *)mh, rh); 798 } 799 800 /* LINK STATE */ 801 /* 802 * Notify the MAC layer about a link state change 803 */ 804 void 805 mac_link_update(mac_handle_t mh, link_state_t link) 806 { 807 mac_impl_t *mip = (mac_impl_t *)mh; 808 809 /* 810 * Save the link state. 811 */ 812 mip->mi_lowlinkstate = link; 813 814 /* 815 * Send a MAC_NOTE_LOWLINK notification. This tells the notification 816 * thread to deliver both lower and upper notifications. 817 */ 818 i_mac_notify(mip, MAC_NOTE_LOWLINK); 819 } 820 821 /* 822 * Notify the MAC layer about a link state change due to bridging. 823 */ 824 void 825 mac_link_redo(mac_handle_t mh, link_state_t link) 826 { 827 mac_impl_t *mip = (mac_impl_t *)mh; 828 829 /* 830 * Save the link state. 831 */ 832 mip->mi_linkstate = link; 833 834 /* 835 * Send a MAC_NOTE_LINK notification. Only upper notifications are 836 * made. 837 */ 838 i_mac_notify(mip, MAC_NOTE_LINK); 839 } 840 841 /* MINOR NODE HANDLING */ 842 843 /* 844 * Given a dev_t, return the instance number (PPA) associated with it. 845 * Drivers can use this in their getinfo(9e) implementation to lookup 846 * the instance number (i.e. PPA) of the device, to use as an index to 847 * their own array of soft state structures. 848 * 849 * Returns -1 on error. 850 */ 851 int 852 mac_devt_to_instance(dev_t devt) 853 { 854 return (dld_devt_to_instance(devt)); 855 } 856 857 /* 858 * This function returns the first minor number that is available for 859 * driver private use. All minor numbers smaller than this are 860 * reserved for GLDv3 use. 861 */ 862 minor_t 863 mac_private_minor(void) 864 { 865 return (MAC_PRIVATE_MINOR); 866 } 867 868 /* OTHER CONTROL INFORMATION */ 869 870 /* 871 * A driver notified us that its primary MAC address has changed. 872 */ 873 void 874 mac_unicst_update(mac_handle_t mh, const uint8_t *addr) 875 { 876 mac_impl_t *mip = (mac_impl_t *)mh; 877 878 if (mip->mi_type->mt_addr_length == 0) 879 return; 880 881 i_mac_perim_enter(mip); 882 883 /* 884 * If address changes, freshen the MAC address value and update 885 * all MAC clients that share this MAC address. 886 */ 887 if (bcmp(addr, mip->mi_addr, mip->mi_type->mt_addr_length) != 0) { 888 mac_freshen_macaddr(mac_find_macaddr(mip, mip->mi_addr), 889 (uint8_t *)addr); 890 } 891 892 i_mac_perim_exit(mip); 893 894 /* 895 * Send a MAC_NOTE_UNICST notification. 896 */ 897 i_mac_notify(mip, MAC_NOTE_UNICST); 898 } 899 900 void 901 mac_dst_update(mac_handle_t mh, const uint8_t *addr) 902 { 903 mac_impl_t *mip = (mac_impl_t *)mh; 904 905 if (mip->mi_type->mt_addr_length == 0) 906 return; 907 908 i_mac_perim_enter(mip); 909 bcopy(addr, mip->mi_dstaddr, mip->mi_type->mt_addr_length); 910 i_mac_perim_exit(mip); 911 i_mac_notify(mip, MAC_NOTE_DEST); 912 } 913 914 /* 915 * MAC plugin information changed. 916 */ 917 int 918 mac_pdata_update(mac_handle_t mh, void *mac_pdata, size_t dsize) 919 { 920 mac_impl_t *mip = (mac_impl_t *)mh; 921 922 /* 923 * Verify that the plugin supports MAC plugin data and that the 924 * supplied data is valid. 925 */ 926 if (!(mip->mi_type->mt_ops.mtops_ops & MTOPS_PDATA_VERIFY)) 927 return (EINVAL); 928 if (!mip->mi_type->mt_ops.mtops_pdata_verify(mac_pdata, dsize)) 929 return (EINVAL); 930 931 if (mip->mi_pdata != NULL) 932 kmem_free(mip->mi_pdata, mip->mi_pdata_size); 933 934 mip->mi_pdata = kmem_alloc(dsize, KM_SLEEP); 935 bcopy(mac_pdata, mip->mi_pdata, dsize); 936 mip->mi_pdata_size = dsize; 937 938 /* 939 * Since the MAC plugin data is used to construct MAC headers that 940 * were cached in fast-path headers, we need to flush fast-path 941 * information for links associated with this mac. 942 */ 943 i_mac_notify(mip, MAC_NOTE_FASTPATH_FLUSH); 944 return (0); 945 } 946 947 /* 948 * Invoked by driver as well as the framework to notify its capability change. 949 */ 950 void 951 mac_capab_update(mac_handle_t mh) 952 { 953 /* Send MAC_NOTE_CAPAB_CHG notification */ 954 i_mac_notify((mac_impl_t *)mh, MAC_NOTE_CAPAB_CHG); 955 } 956 957 /* 958 * Used by normal drivers to update the max sdu size. 959 * We need to handle the case of a smaller mi_sdu_multicast 960 * since this is called by mac_set_mtu() even for drivers that 961 * have differing unicast and multicast mtu and we don't want to 962 * increase the multicast mtu by accident in that case. 963 */ 964 int 965 mac_maxsdu_update(mac_handle_t mh, uint_t sdu_max) 966 { 967 mac_impl_t *mip = (mac_impl_t *)mh; 968 969 if (sdu_max == 0 || sdu_max < mip->mi_sdu_min) 970 return (EINVAL); 971 mip->mi_sdu_max = sdu_max; 972 if (mip->mi_sdu_multicast > mip->mi_sdu_max) 973 mip->mi_sdu_multicast = mip->mi_sdu_max; 974 975 /* Send a MAC_NOTE_SDU_SIZE notification. */ 976 i_mac_notify(mip, MAC_NOTE_SDU_SIZE); 977 return (0); 978 } 979 980 /* 981 * Version of the above function that is used by drivers that have a different 982 * max sdu size for multicast/broadcast vs. unicast. 983 */ 984 int 985 mac_maxsdu_update2(mac_handle_t mh, uint_t sdu_max, uint_t sdu_multicast) 986 { 987 mac_impl_t *mip = (mac_impl_t *)mh; 988 989 if (sdu_max == 0 || sdu_max < mip->mi_sdu_min) 990 return (EINVAL); 991 if (sdu_multicast == 0) 992 sdu_multicast = sdu_max; 993 if (sdu_multicast > sdu_max || sdu_multicast < mip->mi_sdu_min) 994 return (EINVAL); 995 mip->mi_sdu_max = sdu_max; 996 mip->mi_sdu_multicast = sdu_multicast; 997 998 /* Send a MAC_NOTE_SDU_SIZE notification. */ 999 i_mac_notify(mip, MAC_NOTE_SDU_SIZE); 1000 return (0); 1001 } 1002 1003 static void 1004 mac_ring_intr_retarget(mac_group_t *group, mac_ring_t *ring) 1005 { 1006 mac_client_impl_t *mcip; 1007 flow_entry_t *flent; 1008 mac_soft_ring_set_t *mac_rx_srs; 1009 mac_cpus_t *srs_cpu; 1010 int i; 1011 1012 if (((mcip = MAC_GROUP_ONLY_CLIENT(group)) != NULL) && 1013 (!ring->mr_info.mri_intr.mi_ddi_shared)) { 1014 /* interrupt can be re-targeted */ 1015 ASSERT(group->mrg_state == MAC_GROUP_STATE_RESERVED); 1016 flent = mcip->mci_flent; 1017 if (ring->mr_type == MAC_RING_TYPE_RX) { 1018 for (i = 0; i < flent->fe_rx_srs_cnt; i++) { 1019 mac_rx_srs = flent->fe_rx_srs[i]; 1020 if (mac_rx_srs->srs_ring != ring) 1021 continue; 1022 srs_cpu = &mac_rx_srs->srs_cpu; 1023 mutex_enter(&cpu_lock); 1024 mac_rx_srs_retarget_intr(mac_rx_srs, 1025 srs_cpu->mc_rx_intr_cpu); 1026 mutex_exit(&cpu_lock); 1027 break; 1028 } 1029 } else { 1030 if (flent->fe_tx_srs != NULL) { 1031 mutex_enter(&cpu_lock); 1032 mac_tx_srs_retarget_intr( 1033 flent->fe_tx_srs); 1034 mutex_exit(&cpu_lock); 1035 } 1036 } 1037 } 1038 } 1039 1040 /* 1041 * Clients like aggr create pseudo rings (mac_ring_t) and expose them to 1042 * their clients. There is a 1-1 mapping pseudo ring and the hardware 1043 * ring. ddi interrupt handles are exported from the hardware ring to 1044 * the pseudo ring. Thus when the interrupt handle changes, clients of 1045 * aggr that are using the handle need to use the new handle and 1046 * re-target their interrupts. 1047 */ 1048 static void 1049 mac_pseudo_ring_intr_retarget(mac_impl_t *mip, mac_ring_t *ring, 1050 ddi_intr_handle_t ddh) 1051 { 1052 mac_ring_t *pring; 1053 mac_group_t *pgroup; 1054 mac_impl_t *pmip; 1055 char macname[MAXNAMELEN]; 1056 mac_perim_handle_t p_mph; 1057 uint64_t saved_gen_num; 1058 1059 again: 1060 pring = (mac_ring_t *)ring->mr_prh; 1061 pgroup = (mac_group_t *)pring->mr_gh; 1062 pmip = (mac_impl_t *)pgroup->mrg_mh; 1063 saved_gen_num = ring->mr_gen_num; 1064 (void) strlcpy(macname, pmip->mi_name, MAXNAMELEN); 1065 /* 1066 * We need to enter aggr's perimeter. The locking hierarchy 1067 * dictates that aggr's perimeter should be entered first 1068 * and then the port's perimeter. So drop the port's 1069 * perimeter, enter aggr's and then re-enter port's 1070 * perimeter. 1071 */ 1072 i_mac_perim_exit(mip); 1073 /* 1074 * While we know pmip is the aggr's mip, there is a 1075 * possibility that aggr could have unregistered by 1076 * the time we exit port's perimeter (mip) and 1077 * enter aggr's perimeter (pmip). To avoid that 1078 * scenario, enter aggr's perimeter using its name. 1079 */ 1080 if (mac_perim_enter_by_macname(macname, &p_mph) != 0) 1081 return; 1082 i_mac_perim_enter(mip); 1083 /* 1084 * Check if the ring got assigned to another aggregation before 1085 * be could enter aggr's and the port's perimeter. When a ring 1086 * gets deleted from an aggregation, it calls mac_stop_ring() 1087 * which increments the generation number. So checking 1088 * generation number will be enough. 1089 */ 1090 if (ring->mr_gen_num != saved_gen_num && ring->mr_prh != NULL) { 1091 i_mac_perim_exit(mip); 1092 mac_perim_exit(p_mph); 1093 i_mac_perim_enter(mip); 1094 goto again; 1095 } 1096 1097 /* Check if pseudo ring is still present */ 1098 if (ring->mr_prh != NULL) { 1099 pring->mr_info.mri_intr.mi_ddi_handle = ddh; 1100 pring->mr_info.mri_intr.mi_ddi_shared = 1101 ring->mr_info.mri_intr.mi_ddi_shared; 1102 if (ddh != NULL) 1103 mac_ring_intr_retarget(pgroup, pring); 1104 } 1105 i_mac_perim_exit(mip); 1106 mac_perim_exit(p_mph); 1107 } 1108 /* 1109 * API called by driver to provide new interrupt handle for TX/RX rings. 1110 * This usually happens when IRM (Interrupt Resource Manangement) 1111 * framework either gives the driver more MSI-x interrupts or takes 1112 * away MSI-x interrupts from the driver. 1113 */ 1114 void 1115 mac_ring_intr_set(mac_ring_handle_t mrh, ddi_intr_handle_t ddh) 1116 { 1117 mac_ring_t *ring = (mac_ring_t *)mrh; 1118 mac_group_t *group = (mac_group_t *)ring->mr_gh; 1119 mac_impl_t *mip = (mac_impl_t *)group->mrg_mh; 1120 1121 i_mac_perim_enter(mip); 1122 ring->mr_info.mri_intr.mi_ddi_handle = ddh; 1123 if (ddh == NULL) { 1124 /* Interrupts being reset */ 1125 ring->mr_info.mri_intr.mi_ddi_shared = B_FALSE; 1126 if (ring->mr_prh != NULL) { 1127 mac_pseudo_ring_intr_retarget(mip, ring, ddh); 1128 return; 1129 } 1130 } else { 1131 /* New interrupt handle */ 1132 mac_compare_ddi_handle(mip->mi_rx_groups, 1133 mip->mi_rx_group_count, ring); 1134 if (!ring->mr_info.mri_intr.mi_ddi_shared) { 1135 mac_compare_ddi_handle(mip->mi_tx_groups, 1136 mip->mi_tx_group_count, ring); 1137 } 1138 if (ring->mr_prh != NULL) { 1139 mac_pseudo_ring_intr_retarget(mip, ring, ddh); 1140 return; 1141 } else { 1142 mac_ring_intr_retarget(group, ring); 1143 } 1144 } 1145 i_mac_perim_exit(mip); 1146 } 1147 1148 /* PRIVATE FUNCTIONS, FOR INTERNAL USE ONLY */ 1149 1150 /* 1151 * Updates the mac_impl structure with the current state of the link 1152 */ 1153 static void 1154 i_mac_log_link_state(mac_impl_t *mip) 1155 { 1156 /* 1157 * If no change, then it is not interesting. 1158 */ 1159 if (mip->mi_lastlowlinkstate == mip->mi_lowlinkstate) 1160 return; 1161 1162 switch (mip->mi_lowlinkstate) { 1163 case LINK_STATE_UP: 1164 if (mip->mi_type->mt_ops.mtops_ops & MTOPS_LINK_DETAILS) { 1165 char det[200]; 1166 1167 mip->mi_type->mt_ops.mtops_link_details(det, 1168 sizeof (det), (mac_handle_t)mip, mip->mi_pdata); 1169 1170 cmn_err(CE_NOTE, "!%s link up, %s", mip->mi_name, det); 1171 } else { 1172 cmn_err(CE_NOTE, "!%s link up", mip->mi_name); 1173 } 1174 break; 1175 1176 case LINK_STATE_DOWN: 1177 /* 1178 * Only transitions from UP to DOWN are interesting 1179 */ 1180 if (mip->mi_lastlowlinkstate != LINK_STATE_UNKNOWN) 1181 cmn_err(CE_NOTE, "!%s link down", mip->mi_name); 1182 break; 1183 1184 case LINK_STATE_UNKNOWN: 1185 /* 1186 * This case is normally not interesting. 1187 */ 1188 break; 1189 } 1190 mip->mi_lastlowlinkstate = mip->mi_lowlinkstate; 1191 } 1192 1193 /* 1194 * Main routine for the callbacks notifications thread 1195 */ 1196 static void 1197 i_mac_notify_thread(void *arg) 1198 { 1199 mac_impl_t *mip = arg; 1200 callb_cpr_t cprinfo; 1201 mac_cb_t *mcb; 1202 mac_cb_info_t *mcbi; 1203 mac_notify_cb_t *mncb; 1204 1205 mcbi = &mip->mi_notify_cb_info; 1206 CALLB_CPR_INIT(&cprinfo, mcbi->mcbi_lockp, callb_generic_cpr, 1207 "i_mac_notify_thread"); 1208 1209 mutex_enter(mcbi->mcbi_lockp); 1210 1211 for (;;) { 1212 uint32_t bits; 1213 uint32_t type; 1214 1215 bits = mip->mi_notify_bits; 1216 if (bits == 0) { 1217 CALLB_CPR_SAFE_BEGIN(&cprinfo); 1218 cv_wait(&mcbi->mcbi_cv, mcbi->mcbi_lockp); 1219 CALLB_CPR_SAFE_END(&cprinfo, mcbi->mcbi_lockp); 1220 continue; 1221 } 1222 mip->mi_notify_bits = 0; 1223 if ((bits & (1 << MAC_NNOTE)) != 0) { 1224 /* request to quit */ 1225 ASSERT(mip->mi_state_flags & MIS_DISABLED); 1226 break; 1227 } 1228 1229 mutex_exit(mcbi->mcbi_lockp); 1230 1231 /* 1232 * Log link changes on the actual link, but then do reports on 1233 * synthetic state (if part of a bridge). 1234 */ 1235 if ((bits & (1 << MAC_NOTE_LOWLINK)) != 0) { 1236 link_state_t newstate; 1237 mac_handle_t mh; 1238 1239 i_mac_log_link_state(mip); 1240 newstate = mip->mi_lowlinkstate; 1241 if (mip->mi_bridge_link != NULL) { 1242 mutex_enter(&mip->mi_bridge_lock); 1243 if ((mh = mip->mi_bridge_link) != NULL) { 1244 newstate = mac_bridge_ls_cb(mh, 1245 newstate); 1246 } 1247 mutex_exit(&mip->mi_bridge_lock); 1248 } 1249 if (newstate != mip->mi_linkstate) { 1250 mip->mi_linkstate = newstate; 1251 bits |= 1 << MAC_NOTE_LINK; 1252 } 1253 } 1254 1255 /* 1256 * Do notification callbacks for each notification type. 1257 */ 1258 for (type = 0; type < MAC_NNOTE; type++) { 1259 if ((bits & (1 << type)) == 0) { 1260 continue; 1261 } 1262 1263 if (mac_notify_cb_list[type] != NULL) 1264 (*mac_notify_cb_list[type])(mip); 1265 1266 /* 1267 * Walk the list of notifications. 1268 */ 1269 MAC_CALLBACK_WALKER_INC(&mip->mi_notify_cb_info); 1270 for (mcb = mip->mi_notify_cb_list; mcb != NULL; 1271 mcb = mcb->mcb_nextp) { 1272 mncb = (mac_notify_cb_t *)mcb->mcb_objp; 1273 mncb->mncb_fn(mncb->mncb_arg, type); 1274 } 1275 MAC_CALLBACK_WALKER_DCR(&mip->mi_notify_cb_info, 1276 &mip->mi_notify_cb_list); 1277 } 1278 1279 mutex_enter(mcbi->mcbi_lockp); 1280 } 1281 1282 mip->mi_state_flags |= MIS_NOTIFY_DONE; 1283 cv_broadcast(&mcbi->mcbi_cv); 1284 1285 /* CALLB_CPR_EXIT drops the lock */ 1286 CALLB_CPR_EXIT(&cprinfo); 1287 thread_exit(); 1288 } 1289 1290 /* 1291 * Signal the i_mac_notify_thread asking it to quit. 1292 * Then wait till it is done. 1293 */ 1294 void 1295 i_mac_notify_exit(mac_impl_t *mip) 1296 { 1297 mac_cb_info_t *mcbi; 1298 1299 mcbi = &mip->mi_notify_cb_info; 1300 1301 mutex_enter(mcbi->mcbi_lockp); 1302 mip->mi_notify_bits = (1 << MAC_NNOTE); 1303 cv_broadcast(&mcbi->mcbi_cv); 1304 1305 1306 while ((mip->mi_notify_thread != NULL) && 1307 !(mip->mi_state_flags & MIS_NOTIFY_DONE)) { 1308 cv_wait(&mcbi->mcbi_cv, mcbi->mcbi_lockp); 1309 } 1310 1311 /* Necessary clean up before doing kmem_cache_free */ 1312 mip->mi_state_flags &= ~MIS_NOTIFY_DONE; 1313 mip->mi_notify_bits = 0; 1314 mip->mi_notify_thread = NULL; 1315 mutex_exit(mcbi->mcbi_lockp); 1316 } 1317 1318 /* 1319 * Entry point invoked by drivers to dynamically add a ring to an 1320 * existing group. 1321 */ 1322 int 1323 mac_group_add_ring(mac_group_handle_t gh, int index) 1324 { 1325 mac_group_t *group = (mac_group_t *)gh; 1326 mac_impl_t *mip = (mac_impl_t *)group->mrg_mh; 1327 int ret; 1328 1329 i_mac_perim_enter(mip); 1330 ret = i_mac_group_add_ring(group, NULL, index); 1331 i_mac_perim_exit(mip); 1332 return (ret); 1333 } 1334 1335 /* 1336 * Entry point invoked by drivers to dynamically remove a ring 1337 * from an existing group. The specified ring handle must no longer 1338 * be used by the driver after a call to this function. 1339 */ 1340 void 1341 mac_group_rem_ring(mac_group_handle_t gh, mac_ring_handle_t rh) 1342 { 1343 mac_group_t *group = (mac_group_t *)gh; 1344 mac_impl_t *mip = (mac_impl_t *)group->mrg_mh; 1345 1346 i_mac_perim_enter(mip); 1347 i_mac_group_rem_ring(group, (mac_ring_t *)rh, B_TRUE); 1348 i_mac_perim_exit(mip); 1349 } 1350 1351 /* 1352 * mac_prop_info_*() callbacks called from the driver's prefix_propinfo() 1353 * entry points. 1354 */ 1355 1356 void 1357 mac_prop_info_set_default_uint8(mac_prop_info_handle_t ph, uint8_t val) 1358 { 1359 mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph; 1360 1361 /* nothing to do if the caller doesn't want the default value */ 1362 if (pr->pr_default == NULL) 1363 return; 1364 1365 ASSERT(pr->pr_default_size >= sizeof (uint8_t)); 1366 1367 *(uint8_t *)(pr->pr_default) = val; 1368 pr->pr_flags |= MAC_PROP_INFO_DEFAULT; 1369 } 1370 1371 void 1372 mac_prop_info_set_default_uint64(mac_prop_info_handle_t ph, uint64_t val) 1373 { 1374 mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph; 1375 1376 /* nothing to do if the caller doesn't want the default value */ 1377 if (pr->pr_default == NULL) 1378 return; 1379 1380 ASSERT(pr->pr_default_size >= sizeof (uint64_t)); 1381 1382 bcopy(&val, pr->pr_default, sizeof (val)); 1383 1384 pr->pr_flags |= MAC_PROP_INFO_DEFAULT; 1385 } 1386 1387 void 1388 mac_prop_info_set_default_uint32(mac_prop_info_handle_t ph, uint32_t val) 1389 { 1390 mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph; 1391 1392 /* nothing to do if the caller doesn't want the default value */ 1393 if (pr->pr_default == NULL) 1394 return; 1395 1396 ASSERT(pr->pr_default_size >= sizeof (uint32_t)); 1397 1398 bcopy(&val, pr->pr_default, sizeof (val)); 1399 1400 pr->pr_flags |= MAC_PROP_INFO_DEFAULT; 1401 } 1402 1403 void 1404 mac_prop_info_set_default_str(mac_prop_info_handle_t ph, const char *str) 1405 { 1406 mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph; 1407 1408 /* nothing to do if the caller doesn't want the default value */ 1409 if (pr->pr_default == NULL) 1410 return; 1411 1412 if (strlen(str) >= pr->pr_default_size) 1413 pr->pr_errno = ENOBUFS; 1414 else 1415 (void) strlcpy(pr->pr_default, str, pr->pr_default_size); 1416 pr->pr_flags |= MAC_PROP_INFO_DEFAULT; 1417 } 1418 1419 void 1420 mac_prop_info_set_default_link_flowctrl(mac_prop_info_handle_t ph, 1421 link_flowctrl_t val) 1422 { 1423 mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph; 1424 1425 /* nothing to do if the caller doesn't want the default value */ 1426 if (pr->pr_default == NULL) 1427 return; 1428 1429 ASSERT(pr->pr_default_size >= sizeof (link_flowctrl_t)); 1430 1431 bcopy(&val, pr->pr_default, sizeof (val)); 1432 1433 pr->pr_flags |= MAC_PROP_INFO_DEFAULT; 1434 } 1435 1436 void 1437 mac_prop_info_set_range_uint32(mac_prop_info_handle_t ph, uint32_t min, 1438 uint32_t max) 1439 { 1440 mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph; 1441 mac_propval_range_t *range = pr->pr_range; 1442 mac_propval_uint32_range_t *range32; 1443 1444 /* nothing to do if the caller doesn't want the range info */ 1445 if (range == NULL) 1446 return; 1447 1448 if (pr->pr_range_cur_count++ == 0) { 1449 /* first range */ 1450 pr->pr_flags |= MAC_PROP_INFO_RANGE; 1451 range->mpr_type = MAC_PROPVAL_UINT32; 1452 } else { 1453 /* all ranges of a property should be of the same type */ 1454 ASSERT(range->mpr_type == MAC_PROPVAL_UINT32); 1455 if (pr->pr_range_cur_count > range->mpr_count) { 1456 pr->pr_errno = ENOSPC; 1457 return; 1458 } 1459 } 1460 1461 range32 = range->mpr_range_uint32; 1462 range32[pr->pr_range_cur_count - 1].mpur_min = min; 1463 range32[pr->pr_range_cur_count - 1].mpur_max = max; 1464 } 1465 1466 void 1467 mac_prop_info_set_perm(mac_prop_info_handle_t ph, uint8_t perm) 1468 { 1469 mac_prop_info_state_t *pr = (mac_prop_info_state_t *)ph; 1470 1471 pr->pr_perm = perm; 1472 pr->pr_flags |= MAC_PROP_INFO_PERM; 1473 } 1474 1475 void mac_hcksum_get(mblk_t *mp, uint32_t *start, uint32_t *stuff, 1476 uint32_t *end, uint32_t *value, uint32_t *flags_ptr) 1477 { 1478 uint32_t flags; 1479 1480 ASSERT(DB_TYPE(mp) == M_DATA); 1481 1482 flags = DB_CKSUMFLAGS(mp) & HCK_FLAGS; 1483 if ((flags & (HCK_PARTIALCKSUM | HCK_FULLCKSUM)) != 0) { 1484 if (value != NULL) 1485 *value = (uint32_t)DB_CKSUM16(mp); 1486 if ((flags & HCK_PARTIALCKSUM) != 0) { 1487 if (start != NULL) 1488 *start = (uint32_t)DB_CKSUMSTART(mp); 1489 if (stuff != NULL) 1490 *stuff = (uint32_t)DB_CKSUMSTUFF(mp); 1491 if (end != NULL) 1492 *end = (uint32_t)DB_CKSUMEND(mp); 1493 } 1494 } 1495 1496 if (flags_ptr != NULL) 1497 *flags_ptr = flags; 1498 } 1499 1500 void mac_hcksum_set(mblk_t *mp, uint32_t start, uint32_t stuff, 1501 uint32_t end, uint32_t value, uint32_t flags) 1502 { 1503 ASSERT(DB_TYPE(mp) == M_DATA); 1504 1505 DB_CKSUMSTART(mp) = (intptr_t)start; 1506 DB_CKSUMSTUFF(mp) = (intptr_t)stuff; 1507 DB_CKSUMEND(mp) = (intptr_t)end; 1508 DB_CKSUMFLAGS(mp) = (uint16_t)flags; 1509 DB_CKSUM16(mp) = (uint16_t)value; 1510 } 1511 1512 void 1513 mac_lso_get(mblk_t *mp, uint32_t *mss, uint32_t *flags) 1514 { 1515 ASSERT(DB_TYPE(mp) == M_DATA); 1516 1517 if (flags != NULL) { 1518 *flags = DB_CKSUMFLAGS(mp) & HW_LSO; 1519 if ((*flags != 0) && (mss != NULL)) 1520 *mss = (uint32_t)DB_LSOMSS(mp); 1521 } 1522 } 1523 1524 void 1525 mac_transceiver_info_set_present(mac_transceiver_info_t *infop, 1526 boolean_t present) 1527 { 1528 infop->mti_present = present; 1529 } 1530 1531 void 1532 mac_transceiver_info_set_usable(mac_transceiver_info_t *infop, 1533 boolean_t usable) 1534 { 1535 infop->mti_usable = usable; 1536 } 1537