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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2019 Joyent, Inc.
  25  * Copyright 2015 Garrett D'Amore <garrett@damore.org>
  26  */
  27 
  28 /*
  29  * MAC Services Module
  30  *
  31  * The GLDv3 framework locking -  The MAC layer
  32  * --------------------------------------------
  33  *
  34  * The MAC layer is central to the GLD framework and can provide the locking
  35  * framework needed for itself and for the use of MAC clients. MAC end points
  36  * are fairly disjoint and don't share a lot of state. So a coarse grained
  37  * multi-threading scheme is to single thread all create/modify/delete or set
  38  * type of control operations on a per mac end point while allowing data threads
  39  * concurrently.
  40  *
  41  * Control operations (set) that modify a mac end point are always serialized on
  42  * a per mac end point basis, We have at most 1 such thread per mac end point
  43  * at a time.
  44  *
  45  * All other operations that are not serialized are essentially multi-threaded.
  46  * For example a control operation (get) like getting statistics which may not
  47  * care about reading values atomically or data threads sending or receiving
  48  * data. Mostly these type of operations don't modify the control state. Any
  49  * state these operations care about are protected using traditional locks.
  50  *
  51  * The perimeter only serializes serial operations. It does not imply there
  52  * aren't any other concurrent operations. However a serialized operation may
  53  * sometimes need to make sure it is the only thread. In this case it needs
  54  * to use reference counting mechanisms to cv_wait until any current data
  55  * threads are done.
  56  *
  57  * The mac layer itself does not hold any locks across a call to another layer.
  58  * The perimeter is however held across a down call to the driver to make the
  59  * whole control operation atomic with respect to other control operations.
  60  * Also the data path and get type control operations may proceed concurrently.
  61  * These operations synchronize with the single serial operation on a given mac
  62  * end point using regular locks. The perimeter ensures that conflicting
  63  * operations like say a mac_multicast_add and a mac_multicast_remove on the
  64  * same mac end point don't interfere with each other and also ensures that the
  65  * changes in the mac layer and the call to the underlying driver to say add a
  66  * multicast address are done atomically without interference from a thread
  67  * trying to delete the same address.
  68  *
  69  * For example, consider
  70  * mac_multicst_add()
  71  * {
  72  *      mac_perimeter_enter();  serialize all control operations
  73  *
  74  *      grab list lock          protect against access by data threads
  75  *      add to list
  76  *      drop list lock
  77  *
  78  *      call driver's mi_multicst
  79  *
  80  *      mac_perimeter_exit();
  81  * }
  82  *
  83  * To lessen the number of serialization locks and simplify the lock hierarchy,
  84  * we serialize all the control operations on a per mac end point by using a
  85  * single serialization lock called the perimeter. We allow recursive entry into
  86  * the perimeter to facilitate use of this mechanism by both the mac client and
  87  * the MAC layer itself.
  88  *
  89  * MAC client means an entity that does an operation on a mac handle
  90  * obtained from a mac_open/mac_client_open. Similarly MAC driver means
  91  * an entity that does an operation on a mac handle obtained from a
  92  * mac_register. An entity could be both client and driver but on different
  93  * handles eg. aggr. and should only make the corresponding mac interface calls
  94  * i.e. mac driver interface or mac client interface as appropriate for that
  95  * mac handle.
  96  *
  97  * General rules.
  98  * -------------
  99  *
 100  * R1. The lock order of upcall threads is natually opposite to downcall
 101  * threads. Hence upcalls must not hold any locks across layers for fear of
 102  * recursive lock enter and lock order violation. This applies to all layers.
 103  *
 104  * R2. The perimeter is just another lock. Since it is held in the down
 105  * direction, acquiring the perimeter in an upcall is prohibited as it would
 106  * cause a deadlock. This applies to all layers.
 107  *
 108  * Note that upcalls that need to grab the mac perimeter (for example
 109  * mac_notify upcalls) can still achieve that by posting the request to a
 110  * thread, which can then grab all the required perimeters and locks in the
 111  * right global order. Note that in the above example the mac layer iself
 112  * won't grab the mac perimeter in the mac_notify upcall, instead the upcall
 113  * to the client must do that. Please see the aggr code for an example.
 114  *
 115  * MAC client rules
 116  * ----------------
 117  *
 118  * R3. A MAC client may use the MAC provided perimeter facility to serialize
 119  * control operations on a per mac end point. It does this by by acquring
 120  * and holding the perimeter across a sequence of calls to the mac layer.
 121  * This ensures atomicity across the entire block of mac calls. In this
 122  * model the MAC client must not hold any client locks across the calls to
 123  * the mac layer. This model is the preferred solution.
 124  *
 125  * R4. However if a MAC client has a lot of global state across all mac end
 126  * points the per mac end point serialization may not be sufficient. In this
 127  * case the client may choose to use global locks or use its own serialization.
 128  * To avoid deadlocks, these client layer locks held across the mac calls
 129  * in the control path must never be acquired by the data path for the reason
 130  * mentioned below.
 131  *
 132  * (Assume that a control operation that holds a client lock blocks in the
 133  * mac layer waiting for upcall reference counts to drop to zero. If an upcall
 134  * data thread that holds this reference count, tries to acquire the same
 135  * client lock subsequently it will deadlock).
 136  *
 137  * A MAC client may follow either the R3 model or the R4 model, but can't
 138  * mix both. In the former, the hierarchy is Perim -> client locks, but in
 139  * the latter it is client locks -> Perim.
 140  *
 141  * R5. MAC clients must make MAC calls (excluding data calls) in a cv_wait'able
 142  * context since they may block while trying to acquire the perimeter.
 143  * In addition some calls may block waiting for upcall refcnts to come down to
 144  * zero.
 145  *
 146  * R6. MAC clients must make sure that they are single threaded and all threads
 147  * from the top (in particular data threads) have finished before calling
 148  * mac_client_close. The MAC framework does not track the number of client
 149  * threads using the mac client handle. Also mac clients must make sure
 150  * they have undone all the control operations before calling mac_client_close.
 151  * For example mac_unicast_remove/mac_multicast_remove to undo the corresponding
 152  * mac_unicast_add/mac_multicast_add.
 153  *
 154  * MAC framework rules
 155  * -------------------
 156  *
 157  * R7. The mac layer itself must not hold any mac layer locks (except the mac
 158  * perimeter) across a call to any other layer from the mac layer. The call to
 159  * any other layer could be via mi_* entry points, classifier entry points into
 160  * the driver or via upcall pointers into layers above. The mac perimeter may
 161  * be acquired or held only in the down direction, for e.g. when calling into
 162  * a mi_* driver enty point to provide atomicity of the operation.
 163  *
 164  * R8. Since it is not guaranteed (see R14) that drivers won't hold locks across
 165  * mac driver interfaces, the MAC layer must provide a cut out for control
 166  * interfaces like upcall notifications and start them in a separate thread.
 167  *
 168  * R9. Note that locking order also implies a plumbing order. For example
 169  * VNICs are allowed to be created over aggrs, but not vice-versa. An attempt
 170  * to plumb in any other order must be failed at mac_open time, otherwise it
 171  * could lead to deadlocks due to inverse locking order.
 172  *
 173  * R10. MAC driver interfaces must not block since the driver could call them
 174  * in interrupt context.
 175  *
 176  * R11. Walkers must preferably not hold any locks while calling walker
 177  * callbacks. Instead these can operate on reference counts. In simple
 178  * callbacks it may be ok to hold a lock and call the callbacks, but this is
 179  * harder to maintain in the general case of arbitrary callbacks.
 180  *
 181  * R12. The MAC layer must protect upcall notification callbacks using reference
 182  * counts rather than holding locks across the callbacks.
 183  *
 184  * R13. Given the variety of drivers, it is preferable if the MAC layer can make
 185  * sure that any pointers (such as mac ring pointers) it passes to the driver
 186  * remain valid until mac unregister time. Currently the mac layer achieves
 187  * this by using generation numbers for rings and freeing the mac rings only
 188  * at unregister time.  The MAC layer must provide a layer of indirection and
 189  * must not expose underlying driver rings or driver data structures/pointers
 190  * directly to MAC clients.
 191  *
 192  * MAC driver rules
 193  * ----------------
 194  *
 195  * R14. It would be preferable if MAC drivers don't hold any locks across any
 196  * mac call. However at a minimum they must not hold any locks across data
 197  * upcalls. They must also make sure that all references to mac data structures
 198  * are cleaned up and that it is single threaded at mac_unregister time.
 199  *
 200  * R15. MAC driver interfaces don't block and so the action may be done
 201  * asynchronously in a separate thread as for example handling notifications.
 202  * The driver must not assume that the action is complete when the call
 203  * returns.
 204  *
 205  * R16. Drivers must maintain a generation number per Rx ring, and pass it
 206  * back to mac_rx_ring(); They are expected to increment the generation
 207  * number whenever the ring's stop routine is invoked.
 208  * See comments in mac_rx_ring();
 209  *
 210  * R17 Similarly mi_stop is another synchronization point and the driver must
 211  * ensure that all upcalls are done and there won't be any future upcall
 212  * before returning from mi_stop.
 213  *
 214  * R18. The driver may assume that all set/modify control operations via
 215  * the mi_* entry points are single threaded on a per mac end point.
 216  *
 217  * Lock and Perimeter hierarchy scenarios
 218  * ---------------------------------------
 219  *
 220  * i_mac_impl_lock -> mi_rw_lock -> srs_lock -> s_ring_lock[i_mac_tx_srs_notify]
 221  *
 222  * ft_lock -> fe_lock [mac_flow_lookup]
 223  *
 224  * mi_rw_lock -> fe_lock [mac_bcast_send]
 225  *
 226  * srs_lock -> mac_bw_lock [mac_rx_srs_drain_bw]
 227  *
 228  * cpu_lock -> mac_srs_g_lock -> srs_lock -> s_ring_lock [mac_walk_srs_and_bind]
 229  *
 230  * i_dls_devnet_lock -> mac layer locks [dls_devnet_rename]
 231  *
 232  * Perimeters are ordered P1 -> P2 -> P3 from top to bottom in order of mac
 233  * client to driver. In the case of clients that explictly use the mac provided
 234  * perimeter mechanism for its serialization, the hierarchy is
 235  * Perimeter -> mac layer locks, since the client never holds any locks across
 236  * the mac calls. In the case of clients that use its own locks the hierarchy
 237  * is Client locks -> Mac Perim -> Mac layer locks. The client never explicitly
 238  * calls mac_perim_enter/exit in this case.
 239  *
 240  * Subflow creation rules
 241  * ---------------------------
 242  * o In case of a user specified cpulist present on underlying link and flows,
 243  * the flows cpulist must be a subset of the underlying link.
 244  * o In case of a user specified fanout mode present on link and flow, the
 245  * subflow fanout count has to be less than or equal to that of the
 246  * underlying link. The cpu-bindings for the subflows will be a subset of
 247  * the underlying link.
 248  * o In case if no cpulist specified on both underlying link and flow, the
 249  * underlying link relies on a  MAC tunable to provide out of box fanout.
 250  * The subflow will have no cpulist (the subflow will be unbound)
 251  * o In case if no cpulist is specified on the underlying link, a subflow can
 252  * carry  either a user-specified cpulist or fanout count. The cpu-bindings
 253  * for the subflow will not adhere to restriction that they need to be subset
 254  * of the underlying link.
 255  * o In case where the underlying link is carrying either a user specified
 256  * cpulist or fanout mode and for a unspecified subflow, the subflow will be
 257  * created unbound.
 258  * o While creating unbound subflows, bandwidth mode changes attempt to
 259  * figure a right fanout count. In such cases the fanout count will override
 260  * the unbound cpu-binding behavior.
 261  * o In addition to this, while cycling between flow and link properties, we
 262  * impose a restriction that if a link property has a subflow with
 263  * user-specified attributes, we will not allow changing the link property.
 264  * The administrator needs to reset all the user specified properties for the
 265  * subflows before attempting a link property change.
 266  * Some of the above rules can be overridden by specifying additional command
 267  * line options while creating or modifying link or subflow properties.
 268  *
 269  * Datapath
 270  * --------
 271  *
 272  * For information on the datapath, the world of soft rings, hardware rings, how
 273  * it is structured, and the path of an mblk_t between a driver and a mac
 274  * client, see mac_sched.c.
 275  */
 276 
 277 #include <sys/types.h>
 278 #include <sys/conf.h>
 279 #include <sys/id_space.h>
 280 #include <sys/esunddi.h>
 281 #include <sys/stat.h>
 282 #include <sys/mkdev.h>
 283 #include <sys/stream.h>
 284 #include <sys/strsun.h>
 285 #include <sys/strsubr.h>
 286 #include <sys/dlpi.h>
 287 #include <sys/list.h>
 288 #include <sys/modhash.h>
 289 #include <sys/mac_provider.h>
 290 #include <sys/mac_client_impl.h>
 291 #include <sys/mac_soft_ring.h>
 292 #include <sys/mac_stat.h>
 293 #include <sys/mac_impl.h>
 294 #include <sys/mac.h>
 295 #include <sys/dls.h>
 296 #include <sys/dld.h>
 297 #include <sys/modctl.h>
 298 #include <sys/fs/dv_node.h>
 299 #include <sys/thread.h>
 300 #include <sys/proc.h>
 301 #include <sys/callb.h>
 302 #include <sys/cpuvar.h>
 303 #include <sys/atomic.h>
 304 #include <sys/bitmap.h>
 305 #include <sys/sdt.h>
 306 #include <sys/mac_flow.h>
 307 #include <sys/ddi_intr_impl.h>
 308 #include <sys/disp.h>
 309 #include <sys/sdt.h>
 310 #include <sys/vnic.h>
 311 #include <sys/vnic_impl.h>
 312 #include <sys/vlan.h>
 313 #include <inet/ip.h>
 314 #include <inet/ip6.h>
 315 #include <sys/exacct.h>
 316 #include <sys/exacct_impl.h>
 317 #include <inet/nd.h>
 318 #include <sys/ethernet.h>
 319 #include <sys/pool.h>
 320 #include <sys/pool_pset.h>
 321 #include <sys/cpupart.h>
 322 #include <inet/wifi_ioctl.h>
 323 #include <net/wpa.h>
 324 
 325 #define IMPL_HASHSZ     67      /* prime */
 326 
 327 kmem_cache_t            *i_mac_impl_cachep;
 328 mod_hash_t              *i_mac_impl_hash;
 329 krwlock_t               i_mac_impl_lock;
 330 uint_t                  i_mac_impl_count;
 331 static kmem_cache_t     *mac_ring_cache;
 332 static id_space_t       *minor_ids;
 333 static uint32_t         minor_count;
 334 static pool_event_cb_t  mac_pool_event_reg;
 335 
 336 /*
 337  * Logging stuff. Perhaps mac_logging_interval could be broken into
 338  * mac_flow_log_interval and mac_link_log_interval if we want to be
 339  * able to schedule them differently.
 340  */
 341 uint_t                  mac_logging_interval;
 342 boolean_t               mac_flow_log_enable;
 343 boolean_t               mac_link_log_enable;
 344 timeout_id_t            mac_logging_timer;
 345 
 346 #define MACTYPE_KMODDIR "mac"
 347 #define MACTYPE_HASHSZ  67
 348 static mod_hash_t       *i_mactype_hash;
 349 /*
 350  * i_mactype_lock synchronizes threads that obtain references to mactype_t
 351  * structures through i_mactype_getplugin().
 352  */
 353 static kmutex_t         i_mactype_lock;
 354 
 355 /*
 356  * mac_tx_percpu_cnt
 357  *
 358  * Number of per cpu locks per mac_client_impl_t. Used by the transmit side
 359  * in mac_tx to reduce lock contention. This is sized at boot time in mac_init.
 360  * mac_tx_percpu_cnt_max is settable in /etc/system and must be a power of 2.
 361  * Per cpu locks may be disabled by setting mac_tx_percpu_cnt_max to 1.
 362  */
 363 int mac_tx_percpu_cnt;
 364 int mac_tx_percpu_cnt_max = 128;
 365 
 366 /*
 367  * Call back functions for the bridge module.  These are guaranteed to be valid
 368  * when holding a reference on a link or when holding mip->mi_bridge_lock and
 369  * mi_bridge_link is non-NULL.
 370  */
 371 mac_bridge_tx_t mac_bridge_tx_cb;
 372 mac_bridge_rx_t mac_bridge_rx_cb;
 373 mac_bridge_ref_t mac_bridge_ref_cb;
 374 mac_bridge_ls_t mac_bridge_ls_cb;
 375 
 376 static int i_mac_constructor(void *, void *, int);
 377 static void i_mac_destructor(void *, void *);
 378 static int i_mac_ring_ctor(void *, void *, int);
 379 static void i_mac_ring_dtor(void *, void *);
 380 static mblk_t *mac_rx_classify(mac_impl_t *, mac_resource_handle_t, mblk_t *);
 381 void mac_tx_client_flush(mac_client_impl_t *);
 382 void mac_tx_client_block(mac_client_impl_t *);
 383 static void mac_rx_ring_quiesce(mac_ring_t *, uint_t);
 384 static int mac_start_group_and_rings(mac_group_t *);
 385 static void mac_stop_group_and_rings(mac_group_t *);
 386 static void mac_pool_event_cb(pool_event_t, int, void *);
 387 
 388 typedef struct netinfo_s {
 389         list_node_t     ni_link;
 390         void            *ni_record;
 391         int             ni_size;
 392         int             ni_type;
 393 } netinfo_t;
 394 
 395 /*
 396  * Module initialization functions.
 397  */
 398 
 399 void
 400 mac_init(void)
 401 {
 402         mac_tx_percpu_cnt = ((boot_max_ncpus == -1) ? max_ncpus :
 403             boot_max_ncpus);
 404 
 405         /* Upper bound is mac_tx_percpu_cnt_max */
 406         if (mac_tx_percpu_cnt > mac_tx_percpu_cnt_max)
 407                 mac_tx_percpu_cnt = mac_tx_percpu_cnt_max;
 408 
 409         if (mac_tx_percpu_cnt < 1) {
 410                 /* Someone set max_tx_percpu_cnt_max to 0 or less */
 411                 mac_tx_percpu_cnt = 1;
 412         }
 413 
 414         ASSERT(mac_tx_percpu_cnt >= 1);
 415         mac_tx_percpu_cnt = (1 << highbit(mac_tx_percpu_cnt - 1));
 416         /*
 417          * Make it of the form 2**N - 1 in the range
 418          * [0 .. mac_tx_percpu_cnt_max - 1]
 419          */
 420         mac_tx_percpu_cnt--;
 421 
 422         i_mac_impl_cachep = kmem_cache_create("mac_impl_cache",
 423             sizeof (mac_impl_t), 0, i_mac_constructor, i_mac_destructor,
 424             NULL, NULL, NULL, 0);
 425         ASSERT(i_mac_impl_cachep != NULL);
 426 
 427         mac_ring_cache = kmem_cache_create("mac_ring_cache",
 428             sizeof (mac_ring_t), 0, i_mac_ring_ctor, i_mac_ring_dtor, NULL,
 429             NULL, NULL, 0);
 430         ASSERT(mac_ring_cache != NULL);
 431 
 432         i_mac_impl_hash = mod_hash_create_extended("mac_impl_hash",
 433             IMPL_HASHSZ, mod_hash_null_keydtor, mod_hash_null_valdtor,
 434             mod_hash_bystr, NULL, mod_hash_strkey_cmp, KM_SLEEP);
 435         rw_init(&i_mac_impl_lock, NULL, RW_DEFAULT, NULL);
 436 
 437         mac_flow_init();
 438         mac_soft_ring_init();
 439         mac_bcast_init();
 440         mac_client_init();
 441 
 442         i_mac_impl_count = 0;
 443 
 444         i_mactype_hash = mod_hash_create_extended("mactype_hash",
 445             MACTYPE_HASHSZ,
 446             mod_hash_null_keydtor, mod_hash_null_valdtor,
 447             mod_hash_bystr, NULL, mod_hash_strkey_cmp, KM_SLEEP);
 448 
 449         /*
 450          * Allocate an id space to manage minor numbers. The range of the
 451          * space will be from MAC_MAX_MINOR+1 to MAC_PRIVATE_MINOR-1.  This
 452          * leaves half of the 32-bit minors available for driver private use.
 453          */
 454         minor_ids = id_space_create("mac_minor_ids", MAC_MAX_MINOR+1,
 455             MAC_PRIVATE_MINOR-1);
 456         ASSERT(minor_ids != NULL);
 457         minor_count = 0;
 458 
 459         /* Let's default to 20 seconds */
 460         mac_logging_interval = 20;
 461         mac_flow_log_enable = B_FALSE;
 462         mac_link_log_enable = B_FALSE;
 463         mac_logging_timer = 0;
 464 
 465         /* Register to be notified of noteworthy pools events */
 466         mac_pool_event_reg.pec_func =  mac_pool_event_cb;
 467         mac_pool_event_reg.pec_arg = NULL;
 468         pool_event_cb_register(&mac_pool_event_reg);
 469 }
 470 
 471 int
 472 mac_fini(void)
 473 {
 474 
 475         if (i_mac_impl_count > 0 || minor_count > 0)
 476                 return (EBUSY);
 477 
 478         pool_event_cb_unregister(&mac_pool_event_reg);
 479 
 480         id_space_destroy(minor_ids);
 481         mac_flow_fini();
 482 
 483         mod_hash_destroy_hash(i_mac_impl_hash);
 484         rw_destroy(&i_mac_impl_lock);
 485 
 486         mac_client_fini();
 487         kmem_cache_destroy(mac_ring_cache);
 488 
 489         mod_hash_destroy_hash(i_mactype_hash);
 490         mac_soft_ring_finish();
 491 
 492 
 493         return (0);
 494 }
 495 
 496 /*
 497  * Initialize a GLDv3 driver's device ops.  A driver that manages its own ops
 498  * (e.g. softmac) may pass in a NULL ops argument.
 499  */
 500 void
 501 mac_init_ops(struct dev_ops *ops, const char *name)
 502 {
 503         major_t major = ddi_name_to_major((char *)name);
 504 
 505         /*
 506          * By returning on error below, we are not letting the driver continue
 507          * in an undefined context.  The mac_register() function will faill if
 508          * DN_GLDV3_DRIVER isn't set.
 509          */
 510         if (major == DDI_MAJOR_T_NONE)
 511                 return;
 512         LOCK_DEV_OPS(&devnamesp[major].dn_lock);
 513         devnamesp[major].dn_flags |= (DN_GLDV3_DRIVER | DN_NETWORK_DRIVER);
 514         UNLOCK_DEV_OPS(&devnamesp[major].dn_lock);
 515         if (ops != NULL)
 516                 dld_init_ops(ops, name);
 517 }
 518 
 519 void
 520 mac_fini_ops(struct dev_ops *ops)
 521 {
 522         dld_fini_ops(ops);
 523 }
 524 
 525 /*ARGSUSED*/
 526 static int
 527 i_mac_constructor(void *buf, void *arg, int kmflag)
 528 {
 529         mac_impl_t      *mip = buf;
 530 
 531         bzero(buf, sizeof (mac_impl_t));
 532 
 533         mip->mi_linkstate = LINK_STATE_UNKNOWN;
 534 
 535         rw_init(&mip->mi_rw_lock, NULL, RW_DRIVER, NULL);
 536         mutex_init(&mip->mi_notify_lock, NULL, MUTEX_DRIVER, NULL);
 537         mutex_init(&mip->mi_promisc_lock, NULL, MUTEX_DRIVER, NULL);
 538         mutex_init(&mip->mi_ring_lock, NULL, MUTEX_DEFAULT, NULL);
 539 
 540         mip->mi_notify_cb_info.mcbi_lockp = &mip->mi_notify_lock;
 541         cv_init(&mip->mi_notify_cb_info.mcbi_cv, NULL, CV_DRIVER, NULL);
 542         mip->mi_promisc_cb_info.mcbi_lockp = &mip->mi_promisc_lock;
 543         cv_init(&mip->mi_promisc_cb_info.mcbi_cv, NULL, CV_DRIVER, NULL);
 544 
 545         mutex_init(&mip->mi_bridge_lock, NULL, MUTEX_DEFAULT, NULL);
 546 
 547         return (0);
 548 }
 549 
 550 /*ARGSUSED*/
 551 static void
 552 i_mac_destructor(void *buf, void *arg)
 553 {
 554         mac_impl_t      *mip = buf;
 555         mac_cb_info_t   *mcbi;
 556 
 557         ASSERT(mip->mi_ref == 0);
 558         ASSERT(mip->mi_active == 0);
 559         ASSERT(mip->mi_linkstate == LINK_STATE_UNKNOWN);
 560         ASSERT(mip->mi_devpromisc == 0);
 561         ASSERT(mip->mi_ksp == NULL);
 562         ASSERT(mip->mi_kstat_count == 0);
 563         ASSERT(mip->mi_nclients == 0);
 564         ASSERT(mip->mi_nactiveclients == 0);
 565         ASSERT(mip->mi_single_active_client == NULL);
 566         ASSERT(mip->mi_state_flags == 0);
 567         ASSERT(mip->mi_factory_addr == NULL);
 568         ASSERT(mip->mi_factory_addr_num == 0);
 569         ASSERT(mip->mi_default_tx_ring == NULL);
 570 
 571         mcbi = &mip->mi_notify_cb_info;
 572         ASSERT(mcbi->mcbi_del_cnt == 0 && mcbi->mcbi_walker_cnt == 0);
 573         ASSERT(mip->mi_notify_bits == 0);
 574         ASSERT(mip->mi_notify_thread == NULL);
 575         ASSERT(mcbi->mcbi_lockp == &mip->mi_notify_lock);
 576         mcbi->mcbi_lockp = NULL;
 577 
 578         mcbi = &mip->mi_promisc_cb_info;
 579         ASSERT(mcbi->mcbi_del_cnt == 0 && mip->mi_promisc_list == NULL);
 580         ASSERT(mip->mi_promisc_list == NULL);
 581         ASSERT(mcbi->mcbi_lockp == &mip->mi_promisc_lock);
 582         mcbi->mcbi_lockp = NULL;
 583 
 584         ASSERT(mip->mi_bcast_ngrps == 0 && mip->mi_bcast_grp == NULL);
 585         ASSERT(mip->mi_perim_owner == NULL && mip->mi_perim_ocnt == 0);
 586 
 587         rw_destroy(&mip->mi_rw_lock);
 588 
 589         mutex_destroy(&mip->mi_promisc_lock);
 590         cv_destroy(&mip->mi_promisc_cb_info.mcbi_cv);
 591         mutex_destroy(&mip->mi_notify_lock);
 592         cv_destroy(&mip->mi_notify_cb_info.mcbi_cv);
 593         mutex_destroy(&mip->mi_ring_lock);
 594 
 595         ASSERT(mip->mi_bridge_link == NULL);
 596 }
 597 
 598 /* ARGSUSED */
 599 static int
 600 i_mac_ring_ctor(void *buf, void *arg, int kmflag)
 601 {
 602         mac_ring_t *ring = (mac_ring_t *)buf;
 603 
 604         bzero(ring, sizeof (mac_ring_t));
 605         cv_init(&ring->mr_cv, NULL, CV_DEFAULT, NULL);
 606         mutex_init(&ring->mr_lock, NULL, MUTEX_DEFAULT, NULL);
 607         ring->mr_state = MR_FREE;
 608         return (0);
 609 }
 610 
 611 /* ARGSUSED */
 612 static void
 613 i_mac_ring_dtor(void *buf, void *arg)
 614 {
 615         mac_ring_t *ring = (mac_ring_t *)buf;
 616 
 617         cv_destroy(&ring->mr_cv);
 618         mutex_destroy(&ring->mr_lock);
 619 }
 620 
 621 /*
 622  * Common functions to do mac callback addition and deletion. Currently this is
 623  * used by promisc callbacks and notify callbacks. List addition and deletion
 624  * need to take care of list walkers. List walkers in general, can't hold list
 625  * locks and make upcall callbacks due to potential lock order and recursive
 626  * reentry issues. Instead list walkers increment the list walker count to mark
 627  * the presence of a walker thread. Addition can be carefully done to ensure
 628  * that the list walker always sees either the old list or the new list.
 629  * However the deletion can't be done while the walker is active, instead the
 630  * deleting thread simply marks the entry as logically deleted. The last walker
 631  * physically deletes and frees up the logically deleted entries when the walk
 632  * is complete.
 633  */
 634 void
 635 mac_callback_add(mac_cb_info_t *mcbi, mac_cb_t **mcb_head,
 636     mac_cb_t *mcb_elem)
 637 {
 638         mac_cb_t        *p;
 639         mac_cb_t        **pp;
 640 
 641         /* Verify it is not already in the list */
 642         for (pp = mcb_head; (p = *pp) != NULL; pp = &p->mcb_nextp) {
 643                 if (p == mcb_elem)
 644                         break;
 645         }
 646         VERIFY(p == NULL);
 647 
 648         /*
 649          * Add it to the head of the callback list. The membar ensures that
 650          * the following list pointer manipulations reach global visibility
 651          * in exactly the program order below.
 652          */
 653         ASSERT(MUTEX_HELD(mcbi->mcbi_lockp));
 654 
 655         mcb_elem->mcb_nextp = *mcb_head;
 656         membar_producer();
 657         *mcb_head = mcb_elem;
 658 }
 659 
 660 /*
 661  * Mark the entry as logically deleted. If there aren't any walkers unlink
 662  * from the list. In either case return the corresponding status.
 663  */
 664 boolean_t
 665 mac_callback_remove(mac_cb_info_t *mcbi, mac_cb_t **mcb_head,
 666     mac_cb_t *mcb_elem)
 667 {
 668         mac_cb_t        *p;
 669         mac_cb_t        **pp;
 670 
 671         ASSERT(MUTEX_HELD(mcbi->mcbi_lockp));
 672         /*
 673          * Search the callback list for the entry to be removed
 674          */
 675         for (pp = mcb_head; (p = *pp) != NULL; pp = &p->mcb_nextp) {
 676                 if (p == mcb_elem)
 677                         break;
 678         }
 679         VERIFY(p != NULL);
 680 
 681         /*
 682          * If there are walkers just mark it as deleted and the last walker
 683          * will remove from the list and free it.
 684          */
 685         if (mcbi->mcbi_walker_cnt != 0) {
 686                 p->mcb_flags |= MCB_CONDEMNED;
 687                 mcbi->mcbi_del_cnt++;
 688                 return (B_FALSE);
 689         }
 690 
 691         ASSERT(mcbi->mcbi_del_cnt == 0);
 692         *pp = p->mcb_nextp;
 693         p->mcb_nextp = NULL;
 694         return (B_TRUE);
 695 }
 696 
 697 /*
 698  * Wait for all pending callback removals to be completed
 699  */
 700 void
 701 mac_callback_remove_wait(mac_cb_info_t *mcbi)
 702 {
 703         ASSERT(MUTEX_HELD(mcbi->mcbi_lockp));
 704         while (mcbi->mcbi_del_cnt != 0) {
 705                 DTRACE_PROBE1(need_wait, mac_cb_info_t *, mcbi);
 706                 cv_wait(&mcbi->mcbi_cv, mcbi->mcbi_lockp);
 707         }
 708 }
 709 
 710 /*
 711  * The last mac callback walker does the cleanup. Walk the list and unlik
 712  * all the logically deleted entries and construct a temporary list of
 713  * removed entries. Return the list of removed entries to the caller.
 714  */
 715 mac_cb_t *
 716 mac_callback_walker_cleanup(mac_cb_info_t *mcbi, mac_cb_t **mcb_head)
 717 {
 718         mac_cb_t        *p;
 719         mac_cb_t        **pp;
 720         mac_cb_t        *rmlist = NULL;         /* List of removed elements */
 721         int     cnt = 0;
 722 
 723         ASSERT(MUTEX_HELD(mcbi->mcbi_lockp));
 724         ASSERT(mcbi->mcbi_del_cnt != 0 && mcbi->mcbi_walker_cnt == 0);
 725 
 726         pp = mcb_head;
 727         while (*pp != NULL) {
 728                 if ((*pp)->mcb_flags & MCB_CONDEMNED) {
 729                         p = *pp;
 730                         *pp = p->mcb_nextp;
 731                         p->mcb_nextp = rmlist;
 732                         rmlist = p;
 733                         cnt++;
 734                         continue;
 735                 }
 736                 pp = &(*pp)->mcb_nextp;
 737         }
 738 
 739         ASSERT(mcbi->mcbi_del_cnt == cnt);
 740         mcbi->mcbi_del_cnt = 0;
 741         return (rmlist);
 742 }
 743 
 744 boolean_t
 745 mac_callback_lookup(mac_cb_t **mcb_headp, mac_cb_t *mcb_elem)
 746 {
 747         mac_cb_t        *mcb;
 748 
 749         /* Verify it is not already in the list */
 750         for (mcb = *mcb_headp; mcb != NULL; mcb = mcb->mcb_nextp) {
 751                 if (mcb == mcb_elem)
 752                         return (B_TRUE);
 753         }
 754 
 755         return (B_FALSE);
 756 }
 757 
 758 boolean_t
 759 mac_callback_find(mac_cb_info_t *mcbi, mac_cb_t **mcb_headp, mac_cb_t *mcb_elem)
 760 {
 761         boolean_t       found;
 762 
 763         mutex_enter(mcbi->mcbi_lockp);
 764         found = mac_callback_lookup(mcb_headp, mcb_elem);
 765         mutex_exit(mcbi->mcbi_lockp);
 766 
 767         return (found);
 768 }
 769 
 770 /* Free the list of removed callbacks */
 771 void
 772 mac_callback_free(mac_cb_t *rmlist)
 773 {
 774         mac_cb_t        *mcb;
 775         mac_cb_t        *mcb_next;
 776 
 777         for (mcb = rmlist; mcb != NULL; mcb = mcb_next) {
 778                 mcb_next = mcb->mcb_nextp;
 779                 kmem_free(mcb->mcb_objp, mcb->mcb_objsize);
 780         }
 781 }
 782 
 783 /*
 784  * The promisc callbacks are in 2 lists, one off the 'mip' and another off the
 785  * 'mcip' threaded by mpi_mi_link and mpi_mci_link respectively. However there
 786  * is only a single shared total walker count, and an entry can't be physically
 787  * unlinked if a walker is active on either list. The last walker does this
 788  * cleanup of logically deleted entries.
 789  */
 790 void
 791 i_mac_promisc_walker_cleanup(mac_impl_t *mip)
 792 {
 793         mac_cb_t        *rmlist;
 794         mac_cb_t        *mcb;
 795         mac_cb_t        *mcb_next;
 796         mac_promisc_impl_t      *mpip;
 797 
 798         /*
 799          * Construct a temporary list of deleted callbacks by walking the
 800          * the mi_promisc_list. Then for each entry in the temporary list,
 801          * remove it from the mci_promisc_list and free the entry.
 802          */
 803         rmlist = mac_callback_walker_cleanup(&mip->mi_promisc_cb_info,
 804             &mip->mi_promisc_list);
 805 
 806         for (mcb = rmlist; mcb != NULL; mcb = mcb_next) {
 807                 mcb_next = mcb->mcb_nextp;
 808                 mpip = (mac_promisc_impl_t *)mcb->mcb_objp;
 809                 VERIFY(mac_callback_remove(&mip->mi_promisc_cb_info,
 810                     &mpip->mpi_mcip->mci_promisc_list, &mpip->mpi_mci_link));
 811                 mcb->mcb_flags = 0;
 812                 mcb->mcb_nextp = NULL;
 813                 kmem_cache_free(mac_promisc_impl_cache, mpip);
 814         }
 815 }
 816 
 817 void
 818 i_mac_notify(mac_impl_t *mip, mac_notify_type_t type)
 819 {
 820         mac_cb_info_t   *mcbi;
 821 
 822         /*
 823          * Signal the notify thread even after mi_ref has become zero and
 824          * mi_disabled is set. The synchronization with the notify thread
 825          * happens in mac_unregister and that implies the driver must make
 826          * sure it is single-threaded (with respect to mac calls) and that
 827          * all pending mac calls have returned before it calls mac_unregister
 828          */
 829         rw_enter(&i_mac_impl_lock, RW_READER);
 830         if (mip->mi_state_flags & MIS_DISABLED)
 831                 goto exit;
 832 
 833         /*
 834          * Guard against incorrect notifications.  (Running a newer
 835          * mac client against an older implementation?)
 836          */
 837         if (type >= MAC_NNOTE)
 838                 goto exit;
 839 
 840         mcbi = &mip->mi_notify_cb_info;
 841         mutex_enter(mcbi->mcbi_lockp);
 842         mip->mi_notify_bits |= (1 << type);
 843         cv_broadcast(&mcbi->mcbi_cv);
 844         mutex_exit(mcbi->mcbi_lockp);
 845 
 846 exit:
 847         rw_exit(&i_mac_impl_lock);
 848 }
 849 
 850 /*
 851  * Mac serialization primitives. Please see the block comment at the
 852  * top of the file.
 853  */
 854 void
 855 i_mac_perim_enter(mac_impl_t *mip)
 856 {
 857         mac_client_impl_t       *mcip;
 858 
 859         if (mip->mi_state_flags & MIS_IS_VNIC) {
 860                 /*
 861                  * This is a VNIC. Return the lower mac since that is what
 862                  * we want to serialize on.
 863                  */
 864                 mcip = mac_vnic_lower(mip);
 865                 mip = mcip->mci_mip;
 866         }
 867 
 868         mutex_enter(&mip->mi_perim_lock);
 869         if (mip->mi_perim_owner == curthread) {
 870                 mip->mi_perim_ocnt++;
 871                 mutex_exit(&mip->mi_perim_lock);
 872                 return;
 873         }
 874 
 875         while (mip->mi_perim_owner != NULL)
 876                 cv_wait(&mip->mi_perim_cv, &mip->mi_perim_lock);
 877 
 878         mip->mi_perim_owner = curthread;
 879         ASSERT(mip->mi_perim_ocnt == 0);
 880         mip->mi_perim_ocnt++;
 881 #ifdef DEBUG
 882         mip->mi_perim_stack_depth = getpcstack(mip->mi_perim_stack,
 883             MAC_PERIM_STACK_DEPTH);
 884 #endif
 885         mutex_exit(&mip->mi_perim_lock);
 886 }
 887 
 888 int
 889 i_mac_perim_enter_nowait(mac_impl_t *mip)
 890 {
 891         /*
 892          * The vnic is a special case, since the serialization is done based
 893          * on the lower mac. If the lower mac is busy, it does not imply the
 894          * vnic can't be unregistered. But in the case of other drivers,
 895          * a busy perimeter or open mac handles implies that the mac is busy
 896          * and can't be unregistered.
 897          */
 898         if (mip->mi_state_flags & MIS_IS_VNIC) {
 899                 i_mac_perim_enter(mip);
 900                 return (0);
 901         }
 902 
 903         mutex_enter(&mip->mi_perim_lock);
 904         if (mip->mi_perim_owner != NULL) {
 905                 mutex_exit(&mip->mi_perim_lock);
 906                 return (EBUSY);
 907         }
 908         ASSERT(mip->mi_perim_ocnt == 0);
 909         mip->mi_perim_owner = curthread;
 910         mip->mi_perim_ocnt++;
 911         mutex_exit(&mip->mi_perim_lock);
 912 
 913         return (0);
 914 }
 915 
 916 void
 917 i_mac_perim_exit(mac_impl_t *mip)
 918 {
 919         mac_client_impl_t *mcip;
 920 
 921         if (mip->mi_state_flags & MIS_IS_VNIC) {
 922                 /*
 923                  * This is a VNIC. Return the lower mac since that is what
 924                  * we want to serialize on.
 925                  */
 926                 mcip = mac_vnic_lower(mip);
 927                 mip = mcip->mci_mip;
 928         }
 929 
 930         ASSERT(mip->mi_perim_owner == curthread && mip->mi_perim_ocnt != 0);
 931 
 932         mutex_enter(&mip->mi_perim_lock);
 933         if (--mip->mi_perim_ocnt == 0) {
 934                 mip->mi_perim_owner = NULL;
 935                 cv_signal(&mip->mi_perim_cv);
 936         }
 937         mutex_exit(&mip->mi_perim_lock);
 938 }
 939 
 940 /*
 941  * Returns whether the current thread holds the mac perimeter. Used in making
 942  * assertions.
 943  */
 944 boolean_t
 945 mac_perim_held(mac_handle_t mh)
 946 {
 947         mac_impl_t      *mip = (mac_impl_t *)mh;
 948         mac_client_impl_t *mcip;
 949 
 950         if (mip->mi_state_flags & MIS_IS_VNIC) {
 951                 /*
 952                  * This is a VNIC. Return the lower mac since that is what
 953                  * we want to serialize on.
 954                  */
 955                 mcip = mac_vnic_lower(mip);
 956                 mip = mcip->mci_mip;
 957         }
 958         return (mip->mi_perim_owner == curthread);
 959 }
 960 
 961 /*
 962  * mac client interfaces to enter the mac perimeter of a mac end point, given
 963  * its mac handle, or macname or linkid.
 964  */
 965 void
 966 mac_perim_enter_by_mh(mac_handle_t mh, mac_perim_handle_t *mphp)
 967 {
 968         mac_impl_t      *mip = (mac_impl_t *)mh;
 969 
 970         i_mac_perim_enter(mip);
 971         /*
 972          * The mac_perim_handle_t returned encodes the 'mip' and whether a
 973          * mac_open has been done internally while entering the perimeter.
 974          * This information is used in mac_perim_exit
 975          */
 976         MAC_ENCODE_MPH(*mphp, mip, 0);
 977 }
 978 
 979 int
 980 mac_perim_enter_by_macname(const char *name, mac_perim_handle_t *mphp)
 981 {
 982         int     err;
 983         mac_handle_t    mh;
 984 
 985         if ((err = mac_open(name, &mh)) != 0)
 986                 return (err);
 987 
 988         mac_perim_enter_by_mh(mh, mphp);
 989         MAC_ENCODE_MPH(*mphp, mh, 1);
 990         return (0);
 991 }
 992 
 993 int
 994 mac_perim_enter_by_linkid(datalink_id_t linkid, mac_perim_handle_t *mphp)
 995 {
 996         int     err;
 997         mac_handle_t    mh;
 998 
 999         if ((err = mac_open_by_linkid(linkid, &mh)) != 0)
1000                 return (err);
1001 
1002         mac_perim_enter_by_mh(mh, mphp);
1003         MAC_ENCODE_MPH(*mphp, mh, 1);
1004         return (0);
1005 }
1006 
1007 void
1008 mac_perim_exit(mac_perim_handle_t mph)
1009 {
1010         mac_impl_t      *mip;
1011         boolean_t       need_close;
1012 
1013         MAC_DECODE_MPH(mph, mip, need_close);
1014         i_mac_perim_exit(mip);
1015         if (need_close)
1016                 mac_close((mac_handle_t)mip);
1017 }
1018 
1019 int
1020 mac_hold(const char *macname, mac_impl_t **pmip)
1021 {
1022         mac_impl_t      *mip;
1023         int             err;
1024 
1025         /*
1026          * Check the device name length to make sure it won't overflow our
1027          * buffer.
1028          */
1029         if (strlen(macname) >= MAXNAMELEN)
1030                 return (EINVAL);
1031 
1032         /*
1033          * Look up its entry in the global hash table.
1034          */
1035         rw_enter(&i_mac_impl_lock, RW_WRITER);
1036         err = mod_hash_find(i_mac_impl_hash, (mod_hash_key_t)macname,
1037             (mod_hash_val_t *)&mip);
1038 
1039         if (err != 0) {
1040                 rw_exit(&i_mac_impl_lock);
1041                 return (ENOENT);
1042         }
1043 
1044         if (mip->mi_state_flags & MIS_DISABLED) {
1045                 rw_exit(&i_mac_impl_lock);
1046                 return (ENOENT);
1047         }
1048 
1049         if (mip->mi_state_flags & MIS_EXCLUSIVE_HELD) {
1050                 rw_exit(&i_mac_impl_lock);
1051                 return (EBUSY);
1052         }
1053 
1054         mip->mi_ref++;
1055         rw_exit(&i_mac_impl_lock);
1056 
1057         *pmip = mip;
1058         return (0);
1059 }
1060 
1061 void
1062 mac_rele(mac_impl_t *mip)
1063 {
1064         rw_enter(&i_mac_impl_lock, RW_WRITER);
1065         ASSERT(mip->mi_ref != 0);
1066         if (--mip->mi_ref == 0) {
1067                 ASSERT(mip->mi_nactiveclients == 0 &&
1068                     !(mip->mi_state_flags & MIS_EXCLUSIVE));
1069         }
1070         rw_exit(&i_mac_impl_lock);
1071 }
1072 
1073 /*
1074  * Private GLDv3 function to start a MAC instance.
1075  */
1076 int
1077 mac_start(mac_handle_t mh)
1078 {
1079         mac_impl_t      *mip = (mac_impl_t *)mh;
1080         int             err = 0;
1081         mac_group_t     *defgrp;
1082 
1083         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
1084         ASSERT(mip->mi_start != NULL);
1085 
1086         /*
1087          * Check whether the device is already started.
1088          */
1089         if (mip->mi_active++ == 0) {
1090                 mac_ring_t *ring = NULL;
1091 
1092                 /*
1093                  * Start the device.
1094                  */
1095                 err = mip->mi_start(mip->mi_driver);
1096                 if (err != 0) {
1097                         mip->mi_active--;
1098                         return (err);
1099                 }
1100 
1101                 /*
1102                  * Start the default tx ring.
1103                  */
1104                 if (mip->mi_default_tx_ring != NULL) {
1105 
1106                         ring = (mac_ring_t *)mip->mi_default_tx_ring;
1107                         if (ring->mr_state != MR_INUSE) {
1108                                 err = mac_start_ring(ring);
1109                                 if (err != 0) {
1110                                         mip->mi_active--;
1111                                         return (err);
1112                                 }
1113                         }
1114                 }
1115 
1116                 if ((defgrp = MAC_DEFAULT_RX_GROUP(mip)) != NULL) {
1117                         /*
1118                          * Start the default ring, since it will be needed
1119                          * to receive broadcast and multicast traffic for
1120                          * both primary and non-primary MAC clients.
1121                          */
1122                         ASSERT(defgrp->mrg_state == MAC_GROUP_STATE_REGISTERED);
1123                         err = mac_start_group_and_rings(defgrp);
1124                         if (err != 0) {
1125                                 mip->mi_active--;
1126                                 if ((ring != NULL) &&
1127                                     (ring->mr_state == MR_INUSE))
1128                                         mac_stop_ring(ring);
1129                                 return (err);
1130                         }
1131                         mac_set_group_state(defgrp, MAC_GROUP_STATE_SHARED);
1132                 }
1133         }
1134 
1135         return (err);
1136 }
1137 
1138 /*
1139  * Private GLDv3 function to stop a MAC instance.
1140  */
1141 void
1142 mac_stop(mac_handle_t mh)
1143 {
1144         mac_impl_t      *mip = (mac_impl_t *)mh;
1145         mac_group_t     *grp;
1146 
1147         ASSERT(mip->mi_stop != NULL);
1148         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
1149 
1150         /*
1151          * Check whether the device is still needed.
1152          */
1153         ASSERT(mip->mi_active != 0);
1154         if (--mip->mi_active == 0) {
1155                 if ((grp = MAC_DEFAULT_RX_GROUP(mip)) != NULL) {
1156                         /*
1157                          * There should be no more active clients since the
1158                          * MAC is being stopped. Stop the default RX group
1159                          * and transition it back to registered state.
1160                          *
1161                          * When clients are torn down, the groups
1162                          * are release via mac_release_rx_group which
1163                          * knows the the default group is always in
1164                          * started mode since broadcast uses it. So
1165                          * we can assert that their are no clients
1166                          * (since mac_bcast_add doesn't register itself
1167                          * as a client) and group is in SHARED state.
1168                          */
1169                         ASSERT(grp->mrg_state == MAC_GROUP_STATE_SHARED);
1170                         ASSERT(MAC_GROUP_NO_CLIENT(grp) &&
1171                             mip->mi_nactiveclients == 0);
1172                         mac_stop_group_and_rings(grp);
1173                         mac_set_group_state(grp, MAC_GROUP_STATE_REGISTERED);
1174                 }
1175 
1176                 if (mip->mi_default_tx_ring != NULL) {
1177                         mac_ring_t *ring;
1178 
1179                         ring = (mac_ring_t *)mip->mi_default_tx_ring;
1180                         if (ring->mr_state == MR_INUSE) {
1181                                 mac_stop_ring(ring);
1182                                 ring->mr_flag = 0;
1183                         }
1184                 }
1185 
1186                 /*
1187                  * Stop the device.
1188                  */
1189                 mip->mi_stop(mip->mi_driver);
1190         }
1191 }
1192 
1193 int
1194 i_mac_promisc_set(mac_impl_t *mip, boolean_t on)
1195 {
1196         int             err = 0;
1197 
1198         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
1199         ASSERT(mip->mi_setpromisc != NULL);
1200 
1201         if (on) {
1202                 /*
1203                  * Enable promiscuous mode on the device if not yet enabled.
1204                  */
1205                 if (mip->mi_devpromisc++ == 0) {
1206                         err = mip->mi_setpromisc(mip->mi_driver, B_TRUE);
1207                         if (err != 0) {
1208                                 mip->mi_devpromisc--;
1209                                 return (err);
1210                         }
1211                         i_mac_notify(mip, MAC_NOTE_DEVPROMISC);
1212                 }
1213         } else {
1214                 if (mip->mi_devpromisc == 0)
1215                         return (EPROTO);
1216 
1217                 /*
1218                  * Disable promiscuous mode on the device if this is the last
1219                  * enabling.
1220                  */
1221                 if (--mip->mi_devpromisc == 0) {
1222                         err = mip->mi_setpromisc(mip->mi_driver, B_FALSE);
1223                         if (err != 0) {
1224                                 mip->mi_devpromisc++;
1225                                 return (err);
1226                         }
1227                         i_mac_notify(mip, MAC_NOTE_DEVPROMISC);
1228                 }
1229         }
1230 
1231         return (0);
1232 }
1233 
1234 /*
1235  * The promiscuity state can change any time. If the caller needs to take
1236  * actions that are atomic with the promiscuity state, then the caller needs
1237  * to bracket the entire sequence with mac_perim_enter/exit
1238  */
1239 boolean_t
1240 mac_promisc_get(mac_handle_t mh)
1241 {
1242         mac_impl_t              *mip = (mac_impl_t *)mh;
1243 
1244         /*
1245          * Return the current promiscuity.
1246          */
1247         return (mip->mi_devpromisc != 0);
1248 }
1249 
1250 /*
1251  * Invoked at MAC instance attach time to initialize the list
1252  * of factory MAC addresses supported by a MAC instance. This function
1253  * builds a local cache in the mac_impl_t for the MAC addresses
1254  * supported by the underlying hardware. The MAC clients themselves
1255  * use the mac_addr_factory*() functions to query and reserve
1256  * factory MAC addresses.
1257  */
1258 void
1259 mac_addr_factory_init(mac_impl_t *mip)
1260 {
1261         mac_capab_multifactaddr_t capab;
1262         uint8_t *addr;
1263         int i;
1264 
1265         /*
1266          * First round to see how many factory MAC addresses are available.
1267          */
1268         bzero(&capab, sizeof (capab));
1269         if (!i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_MULTIFACTADDR,
1270             &capab) || (capab.mcm_naddr == 0)) {
1271                 /*
1272                  * The MAC instance doesn't support multiple factory
1273                  * MAC addresses, we're done here.
1274                  */
1275                 return;
1276         }
1277 
1278         /*
1279          * Allocate the space and get all the factory addresses.
1280          */
1281         addr = kmem_alloc(capab.mcm_naddr * MAXMACADDRLEN, KM_SLEEP);
1282         capab.mcm_getaddr(mip->mi_driver, capab.mcm_naddr, addr);
1283 
1284         mip->mi_factory_addr_num = capab.mcm_naddr;
1285         mip->mi_factory_addr = kmem_zalloc(mip->mi_factory_addr_num *
1286             sizeof (mac_factory_addr_t), KM_SLEEP);
1287 
1288         for (i = 0; i < capab.mcm_naddr; i++) {
1289                 bcopy(addr + i * MAXMACADDRLEN,
1290                     mip->mi_factory_addr[i].mfa_addr,
1291                     mip->mi_type->mt_addr_length);
1292                 mip->mi_factory_addr[i].mfa_in_use = B_FALSE;
1293         }
1294 
1295         kmem_free(addr, capab.mcm_naddr * MAXMACADDRLEN);
1296 }
1297 
1298 void
1299 mac_addr_factory_fini(mac_impl_t *mip)
1300 {
1301         if (mip->mi_factory_addr == NULL) {
1302                 ASSERT(mip->mi_factory_addr_num == 0);
1303                 return;
1304         }
1305 
1306         kmem_free(mip->mi_factory_addr, mip->mi_factory_addr_num *
1307             sizeof (mac_factory_addr_t));
1308 
1309         mip->mi_factory_addr = NULL;
1310         mip->mi_factory_addr_num = 0;
1311 }
1312 
1313 /*
1314  * Reserve a factory MAC address. If *slot is set to -1, the function
1315  * attempts to reserve any of the available factory MAC addresses and
1316  * returns the reserved slot id. If no slots are available, the function
1317  * returns ENOSPC. If *slot is not set to -1, the function reserves
1318  * the specified slot if it is available, or returns EBUSY is the slot
1319  * is already used. Returns ENOTSUP if the underlying MAC does not
1320  * support multiple factory addresses. If the slot number is not -1 but
1321  * is invalid, returns EINVAL.
1322  */
1323 int
1324 mac_addr_factory_reserve(mac_client_handle_t mch, int *slot)
1325 {
1326         mac_client_impl_t *mcip = (mac_client_impl_t *)mch;
1327         mac_impl_t *mip = mcip->mci_mip;
1328         int i, ret = 0;
1329 
1330         i_mac_perim_enter(mip);
1331         /*
1332          * Protect against concurrent readers that may need a self-consistent
1333          * view of the factory addresses
1334          */
1335         rw_enter(&mip->mi_rw_lock, RW_WRITER);
1336 
1337         if (mip->mi_factory_addr_num == 0) {
1338                 ret = ENOTSUP;
1339                 goto bail;
1340         }
1341 
1342         if (*slot != -1) {
1343                 /* check the specified slot */
1344                 if (*slot < 1 || *slot > mip->mi_factory_addr_num) {
1345                         ret = EINVAL;
1346                         goto bail;
1347                 }
1348                 if (mip->mi_factory_addr[*slot-1].mfa_in_use) {
1349                         ret = EBUSY;
1350                         goto bail;
1351                 }
1352         } else {
1353                 /* pick the next available slot */
1354                 for (i = 0; i < mip->mi_factory_addr_num; i++) {
1355                         if (!mip->mi_factory_addr[i].mfa_in_use)
1356                                 break;
1357                 }
1358 
1359                 if (i == mip->mi_factory_addr_num) {
1360                         ret = ENOSPC;
1361                         goto bail;
1362                 }
1363                 *slot = i+1;
1364         }
1365 
1366         mip->mi_factory_addr[*slot-1].mfa_in_use = B_TRUE;
1367         mip->mi_factory_addr[*slot-1].mfa_client = mcip;
1368 
1369 bail:
1370         rw_exit(&mip->mi_rw_lock);
1371         i_mac_perim_exit(mip);
1372         return (ret);
1373 }
1374 
1375 /*
1376  * Release the specified factory MAC address slot.
1377  */
1378 void
1379 mac_addr_factory_release(mac_client_handle_t mch, uint_t slot)
1380 {
1381         mac_client_impl_t *mcip = (mac_client_impl_t *)mch;
1382         mac_impl_t *mip = mcip->mci_mip;
1383 
1384         i_mac_perim_enter(mip);
1385         /*
1386          * Protect against concurrent readers that may need a self-consistent
1387          * view of the factory addresses
1388          */
1389         rw_enter(&mip->mi_rw_lock, RW_WRITER);
1390 
1391         ASSERT(slot > 0 && slot <= mip->mi_factory_addr_num);
1392         ASSERT(mip->mi_factory_addr[slot-1].mfa_in_use);
1393 
1394         mip->mi_factory_addr[slot-1].mfa_in_use = B_FALSE;
1395 
1396         rw_exit(&mip->mi_rw_lock);
1397         i_mac_perim_exit(mip);
1398 }
1399 
1400 /*
1401  * Stores in mac_addr the value of the specified MAC address. Returns
1402  * 0 on success, or EINVAL if the slot number is not valid for the MAC.
1403  * The caller must provide a string of at least MAXNAMELEN bytes.
1404  */
1405 void
1406 mac_addr_factory_value(mac_handle_t mh, int slot, uchar_t *mac_addr,
1407     uint_t *addr_len, char *client_name, boolean_t *in_use_arg)
1408 {
1409         mac_impl_t *mip = (mac_impl_t *)mh;
1410         boolean_t in_use;
1411 
1412         ASSERT(slot > 0 && slot <= mip->mi_factory_addr_num);
1413 
1414         /*
1415          * Readers need to hold mi_rw_lock. Writers need to hold mac perimeter
1416          * and mi_rw_lock
1417          */
1418         rw_enter(&mip->mi_rw_lock, RW_READER);
1419         bcopy(mip->mi_factory_addr[slot-1].mfa_addr, mac_addr, MAXMACADDRLEN);
1420         *addr_len = mip->mi_type->mt_addr_length;
1421         in_use = mip->mi_factory_addr[slot-1].mfa_in_use;
1422         if (in_use && client_name != NULL) {
1423                 bcopy(mip->mi_factory_addr[slot-1].mfa_client->mci_name,
1424                     client_name, MAXNAMELEN);
1425         }
1426         if (in_use_arg != NULL)
1427                 *in_use_arg = in_use;
1428         rw_exit(&mip->mi_rw_lock);
1429 }
1430 
1431 /*
1432  * Returns the number of factory MAC addresses (in addition to the
1433  * primary MAC address), 0 if the underlying MAC doesn't support
1434  * that feature.
1435  */
1436 uint_t
1437 mac_addr_factory_num(mac_handle_t mh)
1438 {
1439         mac_impl_t *mip = (mac_impl_t *)mh;
1440 
1441         return (mip->mi_factory_addr_num);
1442 }
1443 
1444 
1445 void
1446 mac_rx_group_unmark(mac_group_t *grp, uint_t flag)
1447 {
1448         mac_ring_t      *ring;
1449 
1450         for (ring = grp->mrg_rings; ring != NULL; ring = ring->mr_next)
1451                 ring->mr_flag &= ~flag;
1452 }
1453 
1454 /*
1455  * The following mac_hwrings_xxx() functions are private mac client functions
1456  * used by the aggr driver to access and control the underlying HW Rx group
1457  * and rings. In this case, the aggr driver has exclusive control of the
1458  * underlying HW Rx group/rings, it calls the following functions to
1459  * start/stop the HW Rx rings, disable/enable polling, add/remove mac'
1460  * addresses, or set up the Rx callback.
1461  */
1462 /* ARGSUSED */
1463 static void
1464 mac_hwrings_rx_process(void *arg, mac_resource_handle_t srs,
1465     mblk_t *mp_chain, boolean_t loopback)
1466 {
1467         mac_soft_ring_set_t     *mac_srs = (mac_soft_ring_set_t *)srs;
1468         mac_srs_rx_t            *srs_rx = &mac_srs->srs_rx;
1469         mac_direct_rx_t         proc;
1470         void                    *arg1;
1471         mac_resource_handle_t   arg2;
1472 
1473         proc = srs_rx->sr_func;
1474         arg1 = srs_rx->sr_arg1;
1475         arg2 = mac_srs->srs_mrh;
1476 
1477         proc(arg1, arg2, mp_chain, NULL);
1478 }
1479 
1480 /*
1481  * This function is called to get the list of HW rings that are reserved by
1482  * an exclusive mac client.
1483  *
1484  * Return value: the number of HW rings.
1485  */
1486 int
1487 mac_hwrings_get(mac_client_handle_t mch, mac_group_handle_t *hwgh,
1488     mac_ring_handle_t *hwrh, mac_ring_type_t rtype)
1489 {
1490         mac_client_impl_t       *mcip = (mac_client_impl_t *)mch;
1491         flow_entry_t            *flent = mcip->mci_flent;
1492         mac_group_t             *grp;
1493         mac_ring_t              *ring;
1494         int                     cnt = 0;
1495 
1496         if (rtype == MAC_RING_TYPE_RX) {
1497                 grp = flent->fe_rx_ring_group;
1498         } else if (rtype == MAC_RING_TYPE_TX) {
1499                 grp = flent->fe_tx_ring_group;
1500         } else {
1501                 ASSERT(B_FALSE);
1502                 return (-1);
1503         }
1504         /*
1505          * The mac client did not reserve any RX group, return directly.
1506          * This is probably because the underlying MAC does not support
1507          * any groups.
1508          */
1509         if (hwgh != NULL)
1510                 *hwgh = NULL;
1511         if (grp == NULL)
1512                 return (0);
1513         /*
1514          * This group must be reserved by this mac client.
1515          */
1516         ASSERT((grp->mrg_state == MAC_GROUP_STATE_RESERVED) &&
1517             (mcip == MAC_GROUP_ONLY_CLIENT(grp)));
1518 
1519         for (ring = grp->mrg_rings; ring != NULL; ring = ring->mr_next, cnt++) {
1520                 ASSERT(cnt < MAX_RINGS_PER_GROUP);
1521                 hwrh[cnt] = (mac_ring_handle_t)ring;
1522         }
1523         if (hwgh != NULL)
1524                 *hwgh = (mac_group_handle_t)grp;
1525 
1526         return (cnt);
1527 }
1528 
1529 /*
1530  * This function is called to get info about Tx/Rx rings.
1531  *
1532  * Return value: returns uint_t which will have various bits set
1533  * that indicates different properties of the ring.
1534  */
1535 uint_t
1536 mac_hwring_getinfo(mac_ring_handle_t rh)
1537 {
1538         mac_ring_t *ring = (mac_ring_t *)rh;
1539         mac_ring_info_t *info = &ring->mr_info;
1540 
1541         return (info->mri_flags);
1542 }
1543 
1544 /*
1545  * Export ddi interrupt handles from the HW ring to the pseudo ring and
1546  * setup the RX callback of the mac client which exclusively controls
1547  * HW ring.
1548  */
1549 void
1550 mac_hwring_setup(mac_ring_handle_t hwrh, mac_resource_handle_t prh,
1551     mac_ring_handle_t pseudo_rh)
1552 {
1553         mac_ring_t              *hw_ring = (mac_ring_t *)hwrh;
1554         mac_ring_t              *pseudo_ring;
1555         mac_soft_ring_set_t     *mac_srs = hw_ring->mr_srs;
1556 
1557         if (pseudo_rh != NULL) {
1558                 pseudo_ring = (mac_ring_t *)pseudo_rh;
1559                 /* Export the ddi handles to pseudo ring */
1560                 pseudo_ring->mr_info.mri_intr.mi_ddi_handle =
1561                     hw_ring->mr_info.mri_intr.mi_ddi_handle;
1562                 pseudo_ring->mr_info.mri_intr.mi_ddi_shared =
1563                     hw_ring->mr_info.mri_intr.mi_ddi_shared;
1564                 /*
1565                  * Save a pointer to pseudo ring in the hw ring. If
1566                  * interrupt handle changes, the hw ring will be
1567                  * notified of the change (see mac_ring_intr_set())
1568                  * and the appropriate change has to be made to
1569                  * the pseudo ring that has exported the ddi handle.
1570                  */
1571                 hw_ring->mr_prh = pseudo_rh;
1572         }
1573 
1574         if (hw_ring->mr_type == MAC_RING_TYPE_RX) {
1575                 ASSERT(!(mac_srs->srs_type & SRST_TX));
1576                 mac_srs->srs_mrh = prh;
1577                 mac_srs->srs_rx.sr_lower_proc = mac_hwrings_rx_process;
1578         }
1579 }
1580 
1581 void
1582 mac_hwring_teardown(mac_ring_handle_t hwrh)
1583 {
1584         mac_ring_t              *hw_ring = (mac_ring_t *)hwrh;
1585         mac_soft_ring_set_t     *mac_srs;
1586 
1587         if (hw_ring == NULL)
1588                 return;
1589         hw_ring->mr_prh = NULL;
1590         if (hw_ring->mr_type == MAC_RING_TYPE_RX) {
1591                 mac_srs = hw_ring->mr_srs;
1592                 ASSERT(!(mac_srs->srs_type & SRST_TX));
1593                 mac_srs->srs_rx.sr_lower_proc = mac_rx_srs_process;
1594                 mac_srs->srs_mrh = NULL;
1595         }
1596 }
1597 
1598 int
1599 mac_hwring_disable_intr(mac_ring_handle_t rh)
1600 {
1601         mac_ring_t *rr_ring = (mac_ring_t *)rh;
1602         mac_intr_t *intr = &rr_ring->mr_info.mri_intr;
1603 
1604         return (intr->mi_disable(intr->mi_handle));
1605 }
1606 
1607 int
1608 mac_hwring_enable_intr(mac_ring_handle_t rh)
1609 {
1610         mac_ring_t *rr_ring = (mac_ring_t *)rh;
1611         mac_intr_t *intr = &rr_ring->mr_info.mri_intr;
1612 
1613         return (intr->mi_enable(intr->mi_handle));
1614 }
1615 
1616 int
1617 mac_hwring_start(mac_ring_handle_t rh)
1618 {
1619         mac_ring_t *rr_ring = (mac_ring_t *)rh;
1620 
1621         MAC_RING_UNMARK(rr_ring, MR_QUIESCE);
1622         return (0);
1623 }
1624 
1625 void
1626 mac_hwring_stop(mac_ring_handle_t rh)
1627 {
1628         mac_ring_t *rr_ring = (mac_ring_t *)rh;
1629 
1630         mac_rx_ring_quiesce(rr_ring, MR_QUIESCE);
1631 }
1632 
1633 mblk_t *
1634 mac_hwring_poll(mac_ring_handle_t rh, int bytes_to_pickup)
1635 {
1636         mac_ring_t *rr_ring = (mac_ring_t *)rh;
1637         mac_ring_info_t *info = &rr_ring->mr_info;
1638 
1639         return (info->mri_poll(info->mri_driver, bytes_to_pickup));
1640 }
1641 
1642 /*
1643  * Send packets through a selected tx ring.
1644  */
1645 mblk_t *
1646 mac_hwring_tx(mac_ring_handle_t rh, mblk_t *mp)
1647 {
1648         mac_ring_t *ring = (mac_ring_t *)rh;
1649         mac_ring_info_t *info = &ring->mr_info;
1650 
1651         ASSERT(ring->mr_type == MAC_RING_TYPE_TX &&
1652             ring->mr_state >= MR_INUSE);
1653         return (info->mri_tx(info->mri_driver, mp));
1654 }
1655 
1656 /*
1657  * Query stats for a particular rx/tx ring
1658  */
1659 int
1660 mac_hwring_getstat(mac_ring_handle_t rh, uint_t stat, uint64_t *val)
1661 {
1662         mac_ring_t      *ring = (mac_ring_t *)rh;
1663         mac_ring_info_t *info = &ring->mr_info;
1664 
1665         return (info->mri_stat(info->mri_driver, stat, val));
1666 }
1667 
1668 /*
1669  * Private function that is only used by aggr to send packets through
1670  * a port/Tx ring. Since aggr exposes a pseudo Tx ring even for ports
1671  * that does not expose Tx rings, aggr_ring_tx() entry point needs
1672  * access to mac_impl_t to send packets through m_tx() entry point.
1673  * It accomplishes this by calling mac_hwring_send_priv() function.
1674  */
1675 mblk_t *
1676 mac_hwring_send_priv(mac_client_handle_t mch, mac_ring_handle_t rh, mblk_t *mp)
1677 {
1678         mac_client_impl_t *mcip = (mac_client_impl_t *)mch;
1679         mac_impl_t *mip = mcip->mci_mip;
1680 
1681         MAC_TX(mip, rh, mp, mcip);
1682         return (mp);
1683 }
1684 
1685 /*
1686  * Private function that is only used by aggr to update the default transmission
1687  * ring. Because aggr exposes a pseudo Tx ring even for ports that may
1688  * temporarily be down, it may need to update the default ring that is used by
1689  * MAC such that it refers to a link that can actively be used to send traffic.
1690  * Note that this is different from the case where the port has been removed
1691  * from the group. In those cases, all of the rings will be torn down because
1692  * the ring will no longer exist. It's important to give aggr a case where the
1693  * rings can still exist such that it may be able to continue to send LACP PDUs
1694  * to potentially restore the link.
1695  *
1696  * Finally, we explicitly don't do anything if the ring hasn't been enabled yet.
1697  * This is to help out aggr which doesn't really know the internal state that
1698  * MAC does about the rings and can't know that it's not quite ready for use
1699  * yet.
1700  */
1701 void
1702 mac_hwring_set_default(mac_handle_t mh, mac_ring_handle_t rh)
1703 {
1704         mac_impl_t *mip = (mac_impl_t *)mh;
1705         mac_ring_t *ring = (mac_ring_t *)rh;
1706 
1707         ASSERT(MAC_PERIM_HELD(mh));
1708         VERIFY(mip->mi_state_flags & MIS_IS_AGGR);
1709 
1710         if (ring->mr_state != MR_INUSE)
1711                 return;
1712 
1713         mip->mi_default_tx_ring = rh;
1714 }
1715 
1716 int
1717 mac_hwgroup_addmac(mac_group_handle_t gh, const uint8_t *addr)
1718 {
1719         mac_group_t *group = (mac_group_t *)gh;
1720 
1721         return (mac_group_addmac(group, addr));
1722 }
1723 
1724 int
1725 mac_hwgroup_remmac(mac_group_handle_t gh, const uint8_t *addr)
1726 {
1727         mac_group_t *group = (mac_group_t *)gh;
1728 
1729         return (mac_group_remmac(group, addr));
1730 }
1731 
1732 /*
1733  * Set the RX group to be shared/reserved. Note that the group must be
1734  * started/stopped outside of this function.
1735  */
1736 void
1737 mac_set_group_state(mac_group_t *grp, mac_group_state_t state)
1738 {
1739         /*
1740          * If there is no change in the group state, just return.
1741          */
1742         if (grp->mrg_state == state)
1743                 return;
1744 
1745         switch (state) {
1746         case MAC_GROUP_STATE_RESERVED:
1747                 /*
1748                  * Successfully reserved the group.
1749                  *
1750                  * Given that there is an exclusive client controlling this
1751                  * group, we enable the group level polling when available,
1752                  * so that SRSs get to turn on/off individual rings they's
1753                  * assigned to.
1754                  */
1755                 ASSERT(MAC_PERIM_HELD(grp->mrg_mh));
1756 
1757                 if (grp->mrg_type == MAC_RING_TYPE_RX &&
1758                     GROUP_INTR_DISABLE_FUNC(grp) != NULL) {
1759                         GROUP_INTR_DISABLE_FUNC(grp)(GROUP_INTR_HANDLE(grp));
1760                 }
1761                 break;
1762 
1763         case MAC_GROUP_STATE_SHARED:
1764                 /*
1765                  * Set all rings of this group to software classified.
1766                  * If the group has an overriding interrupt, then re-enable it.
1767                  */
1768                 ASSERT(MAC_PERIM_HELD(grp->mrg_mh));
1769 
1770                 if (grp->mrg_type == MAC_RING_TYPE_RX &&
1771                     GROUP_INTR_ENABLE_FUNC(grp) != NULL) {
1772                         GROUP_INTR_ENABLE_FUNC(grp)(GROUP_INTR_HANDLE(grp));
1773                 }
1774                 /* The ring is not available for reservations any more */
1775                 break;
1776 
1777         case MAC_GROUP_STATE_REGISTERED:
1778                 /* Also callable from mac_register, perim is not held */
1779                 break;
1780 
1781         default:
1782                 ASSERT(B_FALSE);
1783                 break;
1784         }
1785 
1786         grp->mrg_state = state;
1787 }
1788 
1789 /*
1790  * Quiesce future hardware classified packets for the specified Rx ring
1791  */
1792 static void
1793 mac_rx_ring_quiesce(mac_ring_t *rx_ring, uint_t ring_flag)
1794 {
1795         ASSERT(rx_ring->mr_classify_type == MAC_HW_CLASSIFIER);
1796         ASSERT(ring_flag == MR_CONDEMNED || ring_flag  == MR_QUIESCE);
1797 
1798         mutex_enter(&rx_ring->mr_lock);
1799         rx_ring->mr_flag |= ring_flag;
1800         while (rx_ring->mr_refcnt != 0)
1801                 cv_wait(&rx_ring->mr_cv, &rx_ring->mr_lock);
1802         mutex_exit(&rx_ring->mr_lock);
1803 }
1804 
1805 /*
1806  * Please see mac_tx for details about the per cpu locking scheme
1807  */
1808 static void
1809 mac_tx_lock_all(mac_client_impl_t *mcip)
1810 {
1811         int     i;
1812 
1813         for (i = 0; i <= mac_tx_percpu_cnt; i++)
1814                 mutex_enter(&mcip->mci_tx_pcpu[i].pcpu_tx_lock);
1815 }
1816 
1817 static void
1818 mac_tx_unlock_all(mac_client_impl_t *mcip)
1819 {
1820         int     i;
1821 
1822         for (i = mac_tx_percpu_cnt; i >= 0; i--)
1823                 mutex_exit(&mcip->mci_tx_pcpu[i].pcpu_tx_lock);
1824 }
1825 
1826 static void
1827 mac_tx_unlock_allbutzero(mac_client_impl_t *mcip)
1828 {
1829         int     i;
1830 
1831         for (i = mac_tx_percpu_cnt; i > 0; i--)
1832                 mutex_exit(&mcip->mci_tx_pcpu[i].pcpu_tx_lock);
1833 }
1834 
1835 static int
1836 mac_tx_sum_refcnt(mac_client_impl_t *mcip)
1837 {
1838         int     i;
1839         int     refcnt = 0;
1840 
1841         for (i = 0; i <= mac_tx_percpu_cnt; i++)
1842                 refcnt += mcip->mci_tx_pcpu[i].pcpu_tx_refcnt;
1843 
1844         return (refcnt);
1845 }
1846 
1847 /*
1848  * Stop future Tx packets coming down from the client in preparation for
1849  * quiescing the Tx side. This is needed for dynamic reclaim and reassignment
1850  * of rings between clients
1851  */
1852 void
1853 mac_tx_client_block(mac_client_impl_t *mcip)
1854 {
1855         mac_tx_lock_all(mcip);
1856         mcip->mci_tx_flag |= MCI_TX_QUIESCE;
1857         while (mac_tx_sum_refcnt(mcip) != 0) {
1858                 mac_tx_unlock_allbutzero(mcip);
1859                 cv_wait(&mcip->mci_tx_cv, &mcip->mci_tx_pcpu[0].pcpu_tx_lock);
1860                 mutex_exit(&mcip->mci_tx_pcpu[0].pcpu_tx_lock);
1861                 mac_tx_lock_all(mcip);
1862         }
1863         mac_tx_unlock_all(mcip);
1864 }
1865 
1866 void
1867 mac_tx_client_unblock(mac_client_impl_t *mcip)
1868 {
1869         mac_tx_lock_all(mcip);
1870         mcip->mci_tx_flag &= ~MCI_TX_QUIESCE;
1871         mac_tx_unlock_all(mcip);
1872         /*
1873          * We may fail to disable flow control for the last MAC_NOTE_TX
1874          * notification because the MAC client is quiesced. Send the
1875          * notification again.
1876          */
1877         i_mac_notify(mcip->mci_mip, MAC_NOTE_TX);
1878 }
1879 
1880 /*
1881  * Wait for an SRS to quiesce. The SRS worker will signal us when the
1882  * quiesce is done.
1883  */
1884 static void
1885 mac_srs_quiesce_wait(mac_soft_ring_set_t *srs, uint_t srs_flag)
1886 {
1887         mutex_enter(&srs->srs_lock);
1888         while (!(srs->srs_state & srs_flag))
1889                 cv_wait(&srs->srs_quiesce_done_cv, &srs->srs_lock);
1890         mutex_exit(&srs->srs_lock);
1891 }
1892 
1893 /*
1894  * Quiescing an Rx SRS is achieved by the following sequence. The protocol
1895  * works bottom up by cutting off packet flow from the bottommost point in the
1896  * mac, then the SRS, and then the soft rings. There are 2 use cases of this
1897  * mechanism. One is a temporary quiesce of the SRS, such as say while changing
1898  * the Rx callbacks. Another use case is Rx SRS teardown. In the former case
1899  * the QUIESCE prefix/suffix is used and in the latter the CONDEMNED is used
1900  * for the SRS and MR flags. In the former case the threads pause waiting for
1901  * a restart, while in the latter case the threads exit. The Tx SRS teardown
1902  * is also mostly similar to the above.
1903  *
1904  * 1. Stop future hardware classified packets at the lowest level in the mac.
1905  *    Remove any hardware classification rule (CONDEMNED case) and mark the
1906  *    rings as CONDEMNED or QUIESCE as appropriate. This prevents the mr_refcnt
1907  *    from increasing. Upcalls from the driver that come through hardware
1908  *    classification will be dropped in mac_rx from now on. Then we wait for
1909  *    the mr_refcnt to drop to zero. When the mr_refcnt reaches zero we are
1910  *    sure there aren't any upcall threads from the driver through hardware
1911  *    classification. In the case of SRS teardown we also remove the
1912  *    classification rule in the driver.
1913  *
1914  * 2. Stop future software classified packets by marking the flow entry with
1915  *    FE_QUIESCE or FE_CONDEMNED as appropriate which prevents the refcnt from
1916  *    increasing. We also remove the flow entry from the table in the latter
1917  *    case. Then wait for the fe_refcnt to reach an appropriate quiescent value
1918  *    that indicates there aren't any active threads using that flow entry.
1919  *
1920  * 3. Quiesce the SRS and softrings by signaling the SRS. The SRS poll thread,
1921  *    SRS worker thread, and the soft ring threads are quiesced in sequence
1922  *    with the SRS worker thread serving as a master controller. This
1923  *    mechansim is explained in mac_srs_worker_quiesce().
1924  *
1925  * The restart mechanism to reactivate the SRS and softrings is explained
1926  * in mac_srs_worker_restart(). Here we just signal the SRS worker to start the
1927  * restart sequence.
1928  */
1929 void
1930 mac_rx_srs_quiesce(mac_soft_ring_set_t *srs, uint_t srs_quiesce_flag)
1931 {
1932         flow_entry_t    *flent = srs->srs_flent;
1933         uint_t  mr_flag, srs_done_flag;
1934 
1935         ASSERT(MAC_PERIM_HELD((mac_handle_t)FLENT_TO_MIP(flent)));
1936         ASSERT(!(srs->srs_type & SRST_TX));
1937 
1938         if (srs_quiesce_flag == SRS_CONDEMNED) {
1939                 mr_flag = MR_CONDEMNED;
1940                 srs_done_flag = SRS_CONDEMNED_DONE;
1941                 if (srs->srs_type & SRST_CLIENT_POLL_ENABLED)
1942                         mac_srs_client_poll_disable(srs->srs_mcip, srs);
1943         } else {
1944                 ASSERT(srs_quiesce_flag == SRS_QUIESCE);
1945                 mr_flag = MR_QUIESCE;
1946                 srs_done_flag = SRS_QUIESCE_DONE;
1947                 if (srs->srs_type & SRST_CLIENT_POLL_ENABLED)
1948                         mac_srs_client_poll_quiesce(srs->srs_mcip, srs);
1949         }
1950 
1951         if (srs->srs_ring != NULL) {
1952                 mac_rx_ring_quiesce(srs->srs_ring, mr_flag);
1953         } else {
1954                 /*
1955                  * SRS is driven by software classification. In case
1956                  * of CONDEMNED, the top level teardown functions will
1957                  * deal with flow removal.
1958                  */
1959                 if (srs_quiesce_flag != SRS_CONDEMNED) {
1960                         FLOW_MARK(flent, FE_QUIESCE);
1961                         mac_flow_wait(flent, FLOW_DRIVER_UPCALL);
1962                 }
1963         }
1964 
1965         /*
1966          * Signal the SRS to quiesce itself, and then cv_wait for the
1967          * SRS quiesce to complete. The SRS worker thread will wake us
1968          * up when the quiesce is complete
1969          */
1970         mac_srs_signal(srs, srs_quiesce_flag);
1971         mac_srs_quiesce_wait(srs, srs_done_flag);
1972 }
1973 
1974 /*
1975  * Remove an SRS.
1976  */
1977 void
1978 mac_rx_srs_remove(mac_soft_ring_set_t *srs)
1979 {
1980         flow_entry_t *flent = srs->srs_flent;
1981         int i;
1982 
1983         mac_rx_srs_quiesce(srs, SRS_CONDEMNED);
1984         /*
1985          * Locate and remove our entry in the fe_rx_srs[] array, and
1986          * adjust the fe_rx_srs array entries and array count by
1987          * moving the last entry into the vacated spot.
1988          */
1989         mutex_enter(&flent->fe_lock);
1990         for (i = 0; i < flent->fe_rx_srs_cnt; i++) {
1991                 if (flent->fe_rx_srs[i] == srs)
1992                         break;
1993         }
1994 
1995         ASSERT(i != 0 && i < flent->fe_rx_srs_cnt);
1996         if (i != flent->fe_rx_srs_cnt - 1) {
1997                 flent->fe_rx_srs[i] =
1998                     flent->fe_rx_srs[flent->fe_rx_srs_cnt - 1];
1999                 i = flent->fe_rx_srs_cnt - 1;
2000         }
2001 
2002         flent->fe_rx_srs[i] = NULL;
2003         flent->fe_rx_srs_cnt--;
2004         mutex_exit(&flent->fe_lock);
2005 
2006         mac_srs_free(srs);
2007 }
2008 
2009 static void
2010 mac_srs_clear_flag(mac_soft_ring_set_t *srs, uint_t flag)
2011 {
2012         mutex_enter(&srs->srs_lock);
2013         srs->srs_state &= ~flag;
2014         mutex_exit(&srs->srs_lock);
2015 }
2016 
2017 void
2018 mac_rx_srs_restart(mac_soft_ring_set_t *srs)
2019 {
2020         flow_entry_t    *flent = srs->srs_flent;
2021         mac_ring_t      *mr;
2022 
2023         ASSERT(MAC_PERIM_HELD((mac_handle_t)FLENT_TO_MIP(flent)));
2024         ASSERT((srs->srs_type & SRST_TX) == 0);
2025 
2026         /*
2027          * This handles a change in the number of SRSs between the quiesce and
2028          * and restart operation of a flow.
2029          */
2030         if (!SRS_QUIESCED(srs))
2031                 return;
2032 
2033         /*
2034          * Signal the SRS to restart itself. Wait for the restart to complete
2035          * Note that we only restart the SRS if it is not marked as
2036          * permanently quiesced.
2037          */
2038         if (!SRS_QUIESCED_PERMANENT(srs)) {
2039                 mac_srs_signal(srs, SRS_RESTART);
2040                 mac_srs_quiesce_wait(srs, SRS_RESTART_DONE);
2041                 mac_srs_clear_flag(srs, SRS_RESTART_DONE);
2042 
2043                 mac_srs_client_poll_restart(srs->srs_mcip, srs);
2044         }
2045 
2046         /* Finally clear the flags to let the packets in */
2047         mr = srs->srs_ring;
2048         if (mr != NULL) {
2049                 MAC_RING_UNMARK(mr, MR_QUIESCE);
2050                 /* In case the ring was stopped, safely restart it */
2051                 if (mr->mr_state != MR_INUSE)
2052                         (void) mac_start_ring(mr);
2053         } else {
2054                 FLOW_UNMARK(flent, FE_QUIESCE);
2055         }
2056 }
2057 
2058 /*
2059  * Temporary quiesce of a flow and associated Rx SRS.
2060  * Please see block comment above mac_rx_classify_flow_rem.
2061  */
2062 /* ARGSUSED */
2063 int
2064 mac_rx_classify_flow_quiesce(flow_entry_t *flent, void *arg)
2065 {
2066         int             i;
2067 
2068         for (i = 0; i < flent->fe_rx_srs_cnt; i++) {
2069                 mac_rx_srs_quiesce((mac_soft_ring_set_t *)flent->fe_rx_srs[i],
2070                     SRS_QUIESCE);
2071         }
2072         return (0);
2073 }
2074 
2075 /*
2076  * Restart a flow and associated Rx SRS that has been quiesced temporarily
2077  * Please see block comment above mac_rx_classify_flow_rem
2078  */
2079 /* ARGSUSED */
2080 int
2081 mac_rx_classify_flow_restart(flow_entry_t *flent, void *arg)
2082 {
2083         int             i;
2084 
2085         for (i = 0; i < flent->fe_rx_srs_cnt; i++)
2086                 mac_rx_srs_restart((mac_soft_ring_set_t *)flent->fe_rx_srs[i]);
2087 
2088         return (0);
2089 }
2090 
2091 void
2092 mac_srs_perm_quiesce(mac_client_handle_t mch, boolean_t on)
2093 {
2094         mac_client_impl_t       *mcip = (mac_client_impl_t *)mch;
2095         flow_entry_t            *flent = mcip->mci_flent;
2096         mac_impl_t              *mip = mcip->mci_mip;
2097         mac_soft_ring_set_t     *mac_srs;
2098         int                     i;
2099 
2100         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
2101 
2102         if (flent == NULL)
2103                 return;
2104 
2105         for (i = 0; i < flent->fe_rx_srs_cnt; i++) {
2106                 mac_srs = flent->fe_rx_srs[i];
2107                 mutex_enter(&mac_srs->srs_lock);
2108                 if (on)
2109                         mac_srs->srs_state |= SRS_QUIESCE_PERM;
2110                 else
2111                         mac_srs->srs_state &= ~SRS_QUIESCE_PERM;
2112                 mutex_exit(&mac_srs->srs_lock);
2113         }
2114 }
2115 
2116 void
2117 mac_rx_client_quiesce(mac_client_handle_t mch)
2118 {
2119         mac_client_impl_t       *mcip = (mac_client_impl_t *)mch;
2120         mac_impl_t              *mip = mcip->mci_mip;
2121 
2122         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
2123 
2124         if (MCIP_DATAPATH_SETUP(mcip)) {
2125                 (void) mac_rx_classify_flow_quiesce(mcip->mci_flent,
2126                     NULL);
2127                 (void) mac_flow_walk_nolock(mcip->mci_subflow_tab,
2128                     mac_rx_classify_flow_quiesce, NULL);
2129         }
2130 }
2131 
2132 void
2133 mac_rx_client_restart(mac_client_handle_t mch)
2134 {
2135         mac_client_impl_t       *mcip = (mac_client_impl_t *)mch;
2136         mac_impl_t              *mip = mcip->mci_mip;
2137 
2138         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
2139 
2140         if (MCIP_DATAPATH_SETUP(mcip)) {
2141                 (void) mac_rx_classify_flow_restart(mcip->mci_flent, NULL);
2142                 (void) mac_flow_walk_nolock(mcip->mci_subflow_tab,
2143                     mac_rx_classify_flow_restart, NULL);
2144         }
2145 }
2146 
2147 /*
2148  * This function only quiesces the Tx SRS and softring worker threads. Callers
2149  * need to make sure that there aren't any mac client threads doing current or
2150  * future transmits in the mac before calling this function.
2151  */
2152 void
2153 mac_tx_srs_quiesce(mac_soft_ring_set_t *srs, uint_t srs_quiesce_flag)
2154 {
2155         mac_client_impl_t       *mcip = srs->srs_mcip;
2156 
2157         ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip));
2158 
2159         ASSERT(srs->srs_type & SRST_TX);
2160         ASSERT(srs_quiesce_flag == SRS_CONDEMNED ||
2161             srs_quiesce_flag == SRS_QUIESCE);
2162 
2163         /*
2164          * Signal the SRS to quiesce itself, and then cv_wait for the
2165          * SRS quiesce to complete. The SRS worker thread will wake us
2166          * up when the quiesce is complete
2167          */
2168         mac_srs_signal(srs, srs_quiesce_flag);
2169         mac_srs_quiesce_wait(srs, srs_quiesce_flag == SRS_QUIESCE ?
2170             SRS_QUIESCE_DONE : SRS_CONDEMNED_DONE);
2171 }
2172 
2173 void
2174 mac_tx_srs_restart(mac_soft_ring_set_t *srs)
2175 {
2176         /*
2177          * Resizing the fanout could result in creation of new SRSs.
2178          * They may not necessarily be in the quiesced state in which
2179          * case it need be restarted
2180          */
2181         if (!SRS_QUIESCED(srs))
2182                 return;
2183 
2184         mac_srs_signal(srs, SRS_RESTART);
2185         mac_srs_quiesce_wait(srs, SRS_RESTART_DONE);
2186         mac_srs_clear_flag(srs, SRS_RESTART_DONE);
2187 }
2188 
2189 /*
2190  * Temporary quiesce of a flow and associated Rx SRS.
2191  * Please see block comment above mac_rx_srs_quiesce
2192  */
2193 /* ARGSUSED */
2194 int
2195 mac_tx_flow_quiesce(flow_entry_t *flent, void *arg)
2196 {
2197         /*
2198          * The fe_tx_srs is null for a subflow on an interface that is
2199          * not plumbed
2200          */
2201         if (flent->fe_tx_srs != NULL)
2202                 mac_tx_srs_quiesce(flent->fe_tx_srs, SRS_QUIESCE);
2203         return (0);
2204 }
2205 
2206 /* ARGSUSED */
2207 int
2208 mac_tx_flow_restart(flow_entry_t *flent, void *arg)
2209 {
2210         /*
2211          * The fe_tx_srs is null for a subflow on an interface that is
2212          * not plumbed
2213          */
2214         if (flent->fe_tx_srs != NULL)
2215                 mac_tx_srs_restart(flent->fe_tx_srs);
2216         return (0);
2217 }
2218 
2219 static void
2220 i_mac_tx_client_quiesce(mac_client_handle_t mch, uint_t srs_quiesce_flag)
2221 {
2222         mac_client_impl_t       *mcip = (mac_client_impl_t *)mch;
2223 
2224         ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip));
2225 
2226         mac_tx_client_block(mcip);
2227         if (MCIP_TX_SRS(mcip) != NULL) {
2228                 mac_tx_srs_quiesce(MCIP_TX_SRS(mcip), srs_quiesce_flag);
2229                 (void) mac_flow_walk_nolock(mcip->mci_subflow_tab,
2230                     mac_tx_flow_quiesce, NULL);
2231         }
2232 }
2233 
2234 void
2235 mac_tx_client_quiesce(mac_client_handle_t mch)
2236 {
2237         i_mac_tx_client_quiesce(mch, SRS_QUIESCE);
2238 }
2239 
2240 void
2241 mac_tx_client_condemn(mac_client_handle_t mch)
2242 {
2243         i_mac_tx_client_quiesce(mch, SRS_CONDEMNED);
2244 }
2245 
2246 void
2247 mac_tx_client_restart(mac_client_handle_t mch)
2248 {
2249         mac_client_impl_t *mcip = (mac_client_impl_t *)mch;
2250 
2251         ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip));
2252 
2253         mac_tx_client_unblock(mcip);
2254         if (MCIP_TX_SRS(mcip) != NULL) {
2255                 mac_tx_srs_restart(MCIP_TX_SRS(mcip));
2256                 (void) mac_flow_walk_nolock(mcip->mci_subflow_tab,
2257                     mac_tx_flow_restart, NULL);
2258         }
2259 }
2260 
2261 void
2262 mac_tx_client_flush(mac_client_impl_t *mcip)
2263 {
2264         ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip));
2265 
2266         mac_tx_client_quiesce((mac_client_handle_t)mcip);
2267         mac_tx_client_restart((mac_client_handle_t)mcip);
2268 }
2269 
2270 void
2271 mac_client_quiesce(mac_client_impl_t *mcip)
2272 {
2273         mac_rx_client_quiesce((mac_client_handle_t)mcip);
2274         mac_tx_client_quiesce((mac_client_handle_t)mcip);
2275 }
2276 
2277 void
2278 mac_client_restart(mac_client_impl_t *mcip)
2279 {
2280         mac_rx_client_restart((mac_client_handle_t)mcip);
2281         mac_tx_client_restart((mac_client_handle_t)mcip);
2282 }
2283 
2284 /*
2285  * Allocate a minor number.
2286  */
2287 minor_t
2288 mac_minor_hold(boolean_t sleep)
2289 {
2290         id_t id;
2291 
2292         /*
2293          * Grab a value from the arena.
2294          */
2295         atomic_inc_32(&minor_count);
2296 
2297         if (sleep)
2298                 return ((uint_t)id_alloc(minor_ids));
2299 
2300         if ((id = id_alloc_nosleep(minor_ids)) == -1) {
2301                 atomic_dec_32(&minor_count);
2302                 return (0);
2303         }
2304 
2305         return ((uint_t)id);
2306 }
2307 
2308 /*
2309  * Release a previously allocated minor number.
2310  */
2311 void
2312 mac_minor_rele(minor_t minor)
2313 {
2314         /*
2315          * Return the value to the arena.
2316          */
2317         id_free(minor_ids, minor);
2318         atomic_dec_32(&minor_count);
2319 }
2320 
2321 uint32_t
2322 mac_no_notification(mac_handle_t mh)
2323 {
2324         mac_impl_t *mip = (mac_impl_t *)mh;
2325 
2326         return (((mip->mi_state_flags & MIS_LEGACY) != 0) ?
2327             mip->mi_capab_legacy.ml_unsup_note : 0);
2328 }
2329 
2330 /*
2331  * Prevent any new opens of this mac in preparation for unregister
2332  */
2333 int
2334 i_mac_disable(mac_impl_t *mip)
2335 {
2336         mac_client_impl_t       *mcip;
2337 
2338         rw_enter(&i_mac_impl_lock, RW_WRITER);
2339         if (mip->mi_state_flags & MIS_DISABLED) {
2340                 /* Already disabled, return success */
2341                 rw_exit(&i_mac_impl_lock);
2342                 return (0);
2343         }
2344         /*
2345          * See if there are any other references to this mac_t (e.g., VLAN's).
2346          * If so return failure. If all the other checks below pass, then
2347          * set mi_disabled atomically under the i_mac_impl_lock to prevent
2348          * any new VLAN's from being created or new mac client opens of this
2349          * mac end point.
2350          */
2351         if (mip->mi_ref > 0) {
2352                 rw_exit(&i_mac_impl_lock);
2353                 return (EBUSY);
2354         }
2355 
2356         /*
2357          * mac clients must delete all multicast groups they join before
2358          * closing. bcast groups are reference counted, the last client
2359          * to delete the group will wait till the group is physically
2360          * deleted. Since all clients have closed this mac end point
2361          * mi_bcast_ngrps must be zero at this point
2362          */
2363         ASSERT(mip->mi_bcast_ngrps == 0);
2364 
2365         /*
2366          * Don't let go of this if it has some flows.
2367          * All other code guarantees no flows are added to a disabled
2368          * mac, therefore it is sufficient to check for the flow table
2369          * only here.
2370          */
2371         mcip = mac_primary_client_handle(mip);
2372         if ((mcip != NULL) && mac_link_has_flows((mac_client_handle_t)mcip)) {
2373                 rw_exit(&i_mac_impl_lock);
2374                 return (ENOTEMPTY);
2375         }
2376 
2377         mip->mi_state_flags |= MIS_DISABLED;
2378         rw_exit(&i_mac_impl_lock);
2379         return (0);
2380 }
2381 
2382 int
2383 mac_disable_nowait(mac_handle_t mh)
2384 {
2385         mac_impl_t      *mip = (mac_impl_t *)mh;
2386         int err;
2387 
2388         if ((err = i_mac_perim_enter_nowait(mip)) != 0)
2389                 return (err);
2390         err = i_mac_disable(mip);
2391         i_mac_perim_exit(mip);
2392         return (err);
2393 }
2394 
2395 int
2396 mac_disable(mac_handle_t mh)
2397 {
2398         mac_impl_t      *mip = (mac_impl_t *)mh;
2399         int err;
2400 
2401         i_mac_perim_enter(mip);
2402         err = i_mac_disable(mip);
2403         i_mac_perim_exit(mip);
2404 
2405         /*
2406          * Clean up notification thread and wait for it to exit.
2407          */
2408         if (err == 0)
2409                 i_mac_notify_exit(mip);
2410 
2411         return (err);
2412 }
2413 
2414 /*
2415  * Called when the MAC instance has a non empty flow table, to de-multiplex
2416  * incoming packets to the right flow.
2417  * The MAC's rw lock is assumed held as a READER.
2418  */
2419 /* ARGSUSED */
2420 static mblk_t *
2421 mac_rx_classify(mac_impl_t *mip, mac_resource_handle_t mrh, mblk_t *mp)
2422 {
2423         flow_entry_t    *flent = NULL;
2424         uint_t          flags = FLOW_INBOUND;
2425         int             err;
2426 
2427         /*
2428          * If the mac is a port of an aggregation, pass FLOW_IGNORE_VLAN
2429          * to mac_flow_lookup() so that the VLAN packets can be successfully
2430          * passed to the non-VLAN aggregation flows.
2431          *
2432          * Note that there is possibly a race between this and
2433          * mac_unicast_remove/add() and VLAN packets could be incorrectly
2434          * classified to non-VLAN flows of non-aggregation mac clients. These
2435          * VLAN packets will be then filtered out by the mac module.
2436          */
2437         if ((mip->mi_state_flags & MIS_EXCLUSIVE) != 0)
2438                 flags |= FLOW_IGNORE_VLAN;
2439 
2440         err = mac_flow_lookup(mip->mi_flow_tab, mp, flags, &flent);
2441         if (err != 0) {
2442                 /* no registered receive function */
2443                 return (mp);
2444         } else {
2445                 mac_client_impl_t       *mcip;
2446 
2447                 /*
2448                  * This flent might just be an additional one on the MAC client,
2449                  * i.e. for classification purposes (different fdesc), however
2450                  * the resources, SRS et. al., are in the mci_flent, so if
2451                  * this isn't the mci_flent, we need to get it.
2452                  */
2453                 if ((mcip = flent->fe_mcip) != NULL &&
2454                     mcip->mci_flent != flent) {
2455                         FLOW_REFRELE(flent);
2456                         flent = mcip->mci_flent;
2457                         FLOW_TRY_REFHOLD(flent, err);
2458                         if (err != 0)
2459                                 return (mp);
2460                 }
2461                 (flent->fe_cb_fn)(flent->fe_cb_arg1, flent->fe_cb_arg2, mp,
2462                     B_FALSE);
2463                 FLOW_REFRELE(flent);
2464         }
2465         return (NULL);
2466 }
2467 
2468 mblk_t *
2469 mac_rx_flow(mac_handle_t mh, mac_resource_handle_t mrh, mblk_t *mp_chain)
2470 {
2471         mac_impl_t      *mip = (mac_impl_t *)mh;
2472         mblk_t          *bp, *bp1, **bpp, *list = NULL;
2473 
2474         /*
2475          * We walk the chain and attempt to classify each packet.
2476          * The packets that couldn't be classified will be returned
2477          * back to the caller.
2478          */
2479         bp = mp_chain;
2480         bpp = &list;
2481         while (bp != NULL) {
2482                 bp1 = bp;
2483                 bp = bp->b_next;
2484                 bp1->b_next = NULL;
2485 
2486                 if (mac_rx_classify(mip, mrh, bp1) != NULL) {
2487                         *bpp = bp1;
2488                         bpp = &bp1->b_next;
2489                 }
2490         }
2491         return (list);
2492 }
2493 
2494 static int
2495 mac_tx_flow_srs_wakeup(flow_entry_t *flent, void *arg)
2496 {
2497         mac_ring_handle_t ring = arg;
2498 
2499         if (flent->fe_tx_srs)
2500                 mac_tx_srs_wakeup(flent->fe_tx_srs, ring);
2501         return (0);
2502 }
2503 
2504 void
2505 i_mac_tx_srs_notify(mac_impl_t *mip, mac_ring_handle_t ring)
2506 {
2507         mac_client_impl_t       *cclient;
2508         mac_soft_ring_set_t     *mac_srs;
2509 
2510         /*
2511          * After grabbing the mi_rw_lock, the list of clients can't change.
2512          * If there are any clients mi_disabled must be B_FALSE and can't
2513          * get set since there are clients. If there aren't any clients we
2514          * don't do anything. In any case the mip has to be valid. The driver
2515          * must make sure that it goes single threaded (with respect to mac
2516          * calls) and wait for all pending mac calls to finish before calling
2517          * mac_unregister.
2518          */
2519         rw_enter(&i_mac_impl_lock, RW_READER);
2520         if (mip->mi_state_flags & MIS_DISABLED) {
2521                 rw_exit(&i_mac_impl_lock);
2522                 return;
2523         }
2524 
2525         /*
2526          * Get MAC tx srs from walking mac_client_handle list.
2527          */
2528         rw_enter(&mip->mi_rw_lock, RW_READER);
2529         for (cclient = mip->mi_clients_list; cclient != NULL;
2530             cclient = cclient->mci_client_next) {
2531                 if ((mac_srs = MCIP_TX_SRS(cclient)) != NULL) {
2532                         mac_tx_srs_wakeup(mac_srs, ring);
2533                 } else {
2534                         /*
2535                          * Aggr opens underlying ports in exclusive mode
2536                          * and registers flow control callbacks using
2537                          * mac_tx_client_notify(). When opened in
2538                          * exclusive mode, Tx SRS won't be created
2539                          * during mac_unicast_add().
2540                          */
2541                         if (cclient->mci_state_flags & MCIS_EXCLUSIVE) {
2542                                 mac_tx_invoke_callbacks(cclient,
2543                                     (mac_tx_cookie_t)ring);
2544                         }
2545                 }
2546                 (void) mac_flow_walk(cclient->mci_subflow_tab,
2547                     mac_tx_flow_srs_wakeup, ring);
2548         }
2549         rw_exit(&mip->mi_rw_lock);
2550         rw_exit(&i_mac_impl_lock);
2551 }
2552 
2553 /* ARGSUSED */
2554 void
2555 mac_multicast_refresh(mac_handle_t mh, mac_multicst_t refresh, void *arg,
2556     boolean_t add)
2557 {
2558         mac_impl_t *mip = (mac_impl_t *)mh;
2559 
2560         i_mac_perim_enter((mac_impl_t *)mh);
2561         /*
2562          * If no specific refresh function was given then default to the
2563          * driver's m_multicst entry point.
2564          */
2565         if (refresh == NULL) {
2566                 refresh = mip->mi_multicst;
2567                 arg = mip->mi_driver;
2568         }
2569 
2570         mac_bcast_refresh(mip, refresh, arg, add);
2571         i_mac_perim_exit((mac_impl_t *)mh);
2572 }
2573 
2574 void
2575 mac_promisc_refresh(mac_handle_t mh, mac_setpromisc_t refresh, void *arg)
2576 {
2577         mac_impl_t      *mip = (mac_impl_t *)mh;
2578 
2579         /*
2580          * If no specific refresh function was given then default to the
2581          * driver's m_promisc entry point.
2582          */
2583         if (refresh == NULL) {
2584                 refresh = mip->mi_setpromisc;
2585                 arg = mip->mi_driver;
2586         }
2587         ASSERT(refresh != NULL);
2588 
2589         /*
2590          * Call the refresh function with the current promiscuity.
2591          */
2592         refresh(arg, (mip->mi_devpromisc != 0));
2593 }
2594 
2595 /*
2596  * The mac client requests that the mac not to change its margin size to
2597  * be less than the specified value.  If "current" is B_TRUE, then the client
2598  * requests the mac not to change its margin size to be smaller than the
2599  * current size. Further, return the current margin size value in this case.
2600  *
2601  * We keep every requested size in an ordered list from largest to smallest.
2602  */
2603 int
2604 mac_margin_add(mac_handle_t mh, uint32_t *marginp, boolean_t current)
2605 {
2606         mac_impl_t              *mip = (mac_impl_t *)mh;
2607         mac_margin_req_t        **pp, *p;
2608         int                     err = 0;
2609 
2610         rw_enter(&(mip->mi_rw_lock), RW_WRITER);
2611         if (current)
2612                 *marginp = mip->mi_margin;
2613 
2614         /*
2615          * If the current margin value cannot satisfy the margin requested,
2616          * return ENOTSUP directly.
2617          */
2618         if (*marginp > mip->mi_margin) {
2619                 err = ENOTSUP;
2620                 goto done;
2621         }
2622 
2623         /*
2624          * Check whether the given margin is already in the list. If so,
2625          * bump the reference count.
2626          */
2627         for (pp = &mip->mi_mmrp; (p = *pp) != NULL; pp = &p->mmr_nextp) {
2628                 if (p->mmr_margin == *marginp) {
2629                         /*
2630                          * The margin requested is already in the list,
2631                          * so just bump the reference count.
2632                          */
2633                         p->mmr_ref++;
2634                         goto done;
2635                 }
2636                 if (p->mmr_margin < *marginp)
2637                         break;
2638         }
2639 
2640 
2641         p = kmem_zalloc(sizeof (mac_margin_req_t), KM_SLEEP);
2642         p->mmr_margin = *marginp;
2643         p->mmr_ref++;
2644         p->mmr_nextp = *pp;
2645         *pp = p;
2646 
2647 done:
2648         rw_exit(&(mip->mi_rw_lock));
2649         return (err);
2650 }
2651 
2652 /*
2653  * The mac client requests to cancel its previous mac_margin_add() request.
2654  * We remove the requested margin size from the list.
2655  */
2656 int
2657 mac_margin_remove(mac_handle_t mh, uint32_t margin)
2658 {
2659         mac_impl_t              *mip = (mac_impl_t *)mh;
2660         mac_margin_req_t        **pp, *p;
2661         int                     err = 0;
2662 
2663         rw_enter(&(mip->mi_rw_lock), RW_WRITER);
2664         /*
2665          * Find the entry in the list for the given margin.
2666          */
2667         for (pp = &(mip->mi_mmrp); (p = *pp) != NULL; pp = &(p->mmr_nextp)) {
2668                 if (p->mmr_margin == margin) {
2669                         if (--p->mmr_ref == 0)
2670                                 break;
2671 
2672                         /*
2673                          * There is still a reference to this address so
2674                          * there's nothing more to do.
2675                          */
2676                         goto done;
2677                 }
2678         }
2679 
2680         /*
2681          * We did not find an entry for the given margin.
2682          */
2683         if (p == NULL) {
2684                 err = ENOENT;
2685                 goto done;
2686         }
2687 
2688         ASSERT(p->mmr_ref == 0);
2689 
2690         /*
2691          * Remove it from the list.
2692          */
2693         *pp = p->mmr_nextp;
2694         kmem_free(p, sizeof (mac_margin_req_t));
2695 done:
2696         rw_exit(&(mip->mi_rw_lock));
2697         return (err);
2698 }
2699 
2700 boolean_t
2701 mac_margin_update(mac_handle_t mh, uint32_t margin)
2702 {
2703         mac_impl_t      *mip = (mac_impl_t *)mh;
2704         uint32_t        margin_needed = 0;
2705 
2706         rw_enter(&(mip->mi_rw_lock), RW_WRITER);
2707 
2708         if (mip->mi_mmrp != NULL)
2709                 margin_needed = mip->mi_mmrp->mmr_margin;
2710 
2711         if (margin_needed <= margin)
2712                 mip->mi_margin = margin;
2713 
2714         rw_exit(&(mip->mi_rw_lock));
2715 
2716         if (margin_needed <= margin)
2717                 i_mac_notify(mip, MAC_NOTE_MARGIN);
2718 
2719         return (margin_needed <= margin);
2720 }
2721 
2722 /*
2723  * MAC clients use this interface to request that a MAC device not change its
2724  * MTU below the specified amount. At this time, that amount must be within the
2725  * range of the device's current minimum and the device's current maximum. eg. a
2726  * client cannot request a 3000 byte MTU when the device's MTU is currently
2727  * 2000.
2728  *
2729  * If "current" is set to B_TRUE, then the request is to simply to reserve the
2730  * current underlying mac's maximum for this mac client and return it in mtup.
2731  */
2732 int
2733 mac_mtu_add(mac_handle_t mh, uint32_t *mtup, boolean_t current)
2734 {
2735         mac_impl_t              *mip = (mac_impl_t *)mh;
2736         mac_mtu_req_t           *prev, *cur;
2737         mac_propval_range_t     mpr;
2738         int                     err;
2739 
2740         i_mac_perim_enter(mip);
2741         rw_enter(&mip->mi_rw_lock, RW_WRITER);
2742 
2743         if (current == B_TRUE)
2744                 *mtup = mip->mi_sdu_max;
2745         mpr.mpr_count = 1;
2746         err = mac_prop_info(mh, MAC_PROP_MTU, "mtu", NULL, 0, &mpr, NULL);
2747         if (err != 0) {
2748                 rw_exit(&mip->mi_rw_lock);
2749                 i_mac_perim_exit(mip);
2750                 return (err);
2751         }
2752 
2753         if (*mtup > mip->mi_sdu_max ||
2754             *mtup < mpr.mpr_range_uint32[0].mpur_min) {
2755                 rw_exit(&mip->mi_rw_lock);
2756                 i_mac_perim_exit(mip);
2757                 return (ENOTSUP);
2758         }
2759 
2760         prev = NULL;
2761         for (cur = mip->mi_mtrp; cur != NULL; cur = cur->mtr_nextp) {
2762                 if (*mtup == cur->mtr_mtu) {
2763                         cur->mtr_ref++;
2764                         rw_exit(&mip->mi_rw_lock);
2765                         i_mac_perim_exit(mip);
2766                         return (0);
2767                 }
2768 
2769                 if (*mtup > cur->mtr_mtu)
2770                         break;
2771 
2772                 prev = cur;
2773         }
2774 
2775         cur = kmem_alloc(sizeof (mac_mtu_req_t), KM_SLEEP);
2776         cur->mtr_mtu = *mtup;
2777         cur->mtr_ref = 1;
2778         if (prev != NULL) {
2779                 cur->mtr_nextp = prev->mtr_nextp;
2780                 prev->mtr_nextp = cur;
2781         } else {
2782                 cur->mtr_nextp = mip->mi_mtrp;
2783                 mip->mi_mtrp = cur;
2784         }
2785 
2786         rw_exit(&mip->mi_rw_lock);
2787         i_mac_perim_exit(mip);
2788         return (0);
2789 }
2790 
2791 int
2792 mac_mtu_remove(mac_handle_t mh, uint32_t mtu)
2793 {
2794         mac_impl_t *mip = (mac_impl_t *)mh;
2795         mac_mtu_req_t *cur, *prev;
2796 
2797         i_mac_perim_enter(mip);
2798         rw_enter(&mip->mi_rw_lock, RW_WRITER);
2799 
2800         prev = NULL;
2801         for (cur = mip->mi_mtrp; cur != NULL; cur = cur->mtr_nextp) {
2802                 if (cur->mtr_mtu == mtu) {
2803                         ASSERT(cur->mtr_ref > 0);
2804                         cur->mtr_ref--;
2805                         if (cur->mtr_ref == 0) {
2806                                 if (prev == NULL) {
2807                                         mip->mi_mtrp = cur->mtr_nextp;
2808                                 } else {
2809                                         prev->mtr_nextp = cur->mtr_nextp;
2810                                 }
2811                                 kmem_free(cur, sizeof (mac_mtu_req_t));
2812                         }
2813                         rw_exit(&mip->mi_rw_lock);
2814                         i_mac_perim_exit(mip);
2815                         return (0);
2816                 }
2817 
2818                 prev = cur;
2819         }
2820 
2821         rw_exit(&mip->mi_rw_lock);
2822         i_mac_perim_exit(mip);
2823         return (ENOENT);
2824 }
2825 
2826 /*
2827  * MAC Type Plugin functions.
2828  */
2829 
2830 mactype_t *
2831 mactype_getplugin(const char *pname)
2832 {
2833         mactype_t       *mtype = NULL;
2834         boolean_t       tried_modload = B_FALSE;
2835 
2836         mutex_enter(&i_mactype_lock);
2837 
2838 find_registered_mactype:
2839         if (mod_hash_find(i_mactype_hash, (mod_hash_key_t)pname,
2840             (mod_hash_val_t *)&mtype) != 0) {
2841                 if (!tried_modload) {
2842                         /*
2843                          * If the plugin has not yet been loaded, then
2844                          * attempt to load it now.  If modload() succeeds,
2845                          * the plugin should have registered using
2846                          * mactype_register(), in which case we can go back
2847                          * and attempt to find it again.
2848                          */
2849                         if (modload(MACTYPE_KMODDIR, (char *)pname) != -1) {
2850                                 tried_modload = B_TRUE;
2851                                 goto find_registered_mactype;
2852                         }
2853                 }
2854         } else {
2855                 /*
2856                  * Note that there's no danger that the plugin we've loaded
2857                  * could be unloaded between the modload() step and the
2858                  * reference count bump here, as we're holding
2859                  * i_mactype_lock, which mactype_unregister() also holds.
2860                  */
2861                 atomic_inc_32(&mtype->mt_ref);
2862         }
2863 
2864         mutex_exit(&i_mactype_lock);
2865         return (mtype);
2866 }
2867 
2868 mactype_register_t *
2869 mactype_alloc(uint_t mactype_version)
2870 {
2871         mactype_register_t *mtrp;
2872 
2873         /*
2874          * Make sure there isn't a version mismatch between the plugin and
2875          * the framework.  In the future, if multiple versions are
2876          * supported, this check could become more sophisticated.
2877          */
2878         if (mactype_version != MACTYPE_VERSION)
2879                 return (NULL);
2880 
2881         mtrp = kmem_zalloc(sizeof (mactype_register_t), KM_SLEEP);
2882         mtrp->mtr_version = mactype_version;
2883         return (mtrp);
2884 }
2885 
2886 void
2887 mactype_free(mactype_register_t *mtrp)
2888 {
2889         kmem_free(mtrp, sizeof (mactype_register_t));
2890 }
2891 
2892 int
2893 mactype_register(mactype_register_t *mtrp)
2894 {
2895         mactype_t       *mtp;
2896         mactype_ops_t   *ops = mtrp->mtr_ops;
2897 
2898         /* Do some sanity checking before we register this MAC type. */
2899         if (mtrp->mtr_ident == NULL || ops == NULL)
2900                 return (EINVAL);
2901 
2902         /*
2903          * Verify that all mandatory callbacks are set in the ops
2904          * vector.
2905          */
2906         if (ops->mtops_unicst_verify == NULL ||
2907             ops->mtops_multicst_verify == NULL ||
2908             ops->mtops_sap_verify == NULL ||
2909             ops->mtops_header == NULL ||
2910             ops->mtops_header_info == NULL) {
2911                 return (EINVAL);
2912         }
2913 
2914         mtp = kmem_zalloc(sizeof (*mtp), KM_SLEEP);
2915         mtp->mt_ident = mtrp->mtr_ident;
2916         mtp->mt_ops = *ops;
2917         mtp->mt_type = mtrp->mtr_mactype;
2918         mtp->mt_nativetype = mtrp->mtr_nativetype;
2919         mtp->mt_addr_length = mtrp->mtr_addrlen;
2920         if (mtrp->mtr_brdcst_addr != NULL) {
2921                 mtp->mt_brdcst_addr = kmem_alloc(mtrp->mtr_addrlen, KM_SLEEP);
2922                 bcopy(mtrp->mtr_brdcst_addr, mtp->mt_brdcst_addr,
2923                     mtrp->mtr_addrlen);
2924         }
2925 
2926         mtp->mt_stats = mtrp->mtr_stats;
2927         mtp->mt_statcount = mtrp->mtr_statcount;
2928 
2929         mtp->mt_mapping = mtrp->mtr_mapping;
2930         mtp->mt_mappingcount = mtrp->mtr_mappingcount;
2931 
2932         if (mod_hash_insert(i_mactype_hash,
2933             (mod_hash_key_t)mtp->mt_ident, (mod_hash_val_t)mtp) != 0) {
2934                 kmem_free(mtp->mt_brdcst_addr, mtp->mt_addr_length);
2935                 kmem_free(mtp, sizeof (*mtp));
2936                 return (EEXIST);
2937         }
2938         return (0);
2939 }
2940 
2941 int
2942 mactype_unregister(const char *ident)
2943 {
2944         mactype_t       *mtp;
2945         mod_hash_val_t  val;
2946         int             err;
2947 
2948         /*
2949          * Let's not allow MAC drivers to use this plugin while we're
2950          * trying to unregister it.  Holding i_mactype_lock also prevents a
2951          * plugin from unregistering while a MAC driver is attempting to
2952          * hold a reference to it in i_mactype_getplugin().
2953          */
2954         mutex_enter(&i_mactype_lock);
2955 
2956         if ((err = mod_hash_find(i_mactype_hash, (mod_hash_key_t)ident,
2957             (mod_hash_val_t *)&mtp)) != 0) {
2958                 /* A plugin is trying to unregister, but it never registered. */
2959                 err = ENXIO;
2960                 goto done;
2961         }
2962 
2963         if (mtp->mt_ref != 0) {
2964                 err = EBUSY;
2965                 goto done;
2966         }
2967 
2968         err = mod_hash_remove(i_mactype_hash, (mod_hash_key_t)ident, &val);
2969         ASSERT(err == 0);
2970         if (err != 0) {
2971                 /* This should never happen, thus the ASSERT() above. */
2972                 err = EINVAL;
2973                 goto done;
2974         }
2975         ASSERT(mtp == (mactype_t *)val);
2976 
2977         if (mtp->mt_brdcst_addr != NULL)
2978                 kmem_free(mtp->mt_brdcst_addr, mtp->mt_addr_length);
2979         kmem_free(mtp, sizeof (mactype_t));
2980 done:
2981         mutex_exit(&i_mactype_lock);
2982         return (err);
2983 }
2984 
2985 /*
2986  * Checks the size of the value size specified for a property as
2987  * part of a property operation. Returns B_TRUE if the size is
2988  * correct, B_FALSE otherwise.
2989  */
2990 boolean_t
2991 mac_prop_check_size(mac_prop_id_t id, uint_t valsize, boolean_t is_range)
2992 {
2993         uint_t minsize = 0;
2994 
2995         if (is_range)
2996                 return (valsize >= sizeof (mac_propval_range_t));
2997 
2998         switch (id) {
2999         case MAC_PROP_ZONE:
3000                 minsize = sizeof (dld_ioc_zid_t);
3001                 break;
3002         case MAC_PROP_AUTOPUSH:
3003                 if (valsize != 0)
3004                         minsize = sizeof (struct dlautopush);
3005                 break;
3006         case MAC_PROP_TAGMODE:
3007                 minsize = sizeof (link_tagmode_t);
3008                 break;
3009         case MAC_PROP_RESOURCE:
3010         case MAC_PROP_RESOURCE_EFF:
3011                 minsize = sizeof (mac_resource_props_t);
3012                 break;
3013         case MAC_PROP_DUPLEX:
3014                 minsize = sizeof (link_duplex_t);
3015                 break;
3016         case MAC_PROP_SPEED:
3017                 minsize = sizeof (uint64_t);
3018                 break;
3019         case MAC_PROP_STATUS:
3020                 minsize = sizeof (link_state_t);
3021                 break;
3022         case MAC_PROP_AUTONEG:
3023         case MAC_PROP_EN_AUTONEG:
3024                 minsize = sizeof (uint8_t);
3025                 break;
3026         case MAC_PROP_MTU:
3027         case MAC_PROP_LLIMIT:
3028         case MAC_PROP_LDECAY:
3029                 minsize = sizeof (uint32_t);
3030                 break;
3031         case MAC_PROP_FLOWCTRL:
3032                 minsize = sizeof (link_flowctrl_t);
3033                 break;
3034         case MAC_PROP_ADV_5000FDX_CAP:
3035         case MAC_PROP_EN_5000FDX_CAP:
3036         case MAC_PROP_ADV_2500FDX_CAP:
3037         case MAC_PROP_EN_2500FDX_CAP:
3038         case MAC_PROP_ADV_100GFDX_CAP:
3039         case MAC_PROP_EN_100GFDX_CAP:
3040         case MAC_PROP_ADV_50GFDX_CAP:
3041         case MAC_PROP_EN_50GFDX_CAP:
3042         case MAC_PROP_ADV_40GFDX_CAP:
3043         case MAC_PROP_EN_40GFDX_CAP:
3044         case MAC_PROP_ADV_25GFDX_CAP:
3045         case MAC_PROP_EN_25GFDX_CAP:
3046         case MAC_PROP_ADV_10GFDX_CAP:
3047         case MAC_PROP_EN_10GFDX_CAP:
3048         case MAC_PROP_ADV_1000HDX_CAP:
3049         case MAC_PROP_EN_1000HDX_CAP:
3050         case MAC_PROP_ADV_100FDX_CAP:
3051         case MAC_PROP_EN_100FDX_CAP:
3052         case MAC_PROP_ADV_100HDX_CAP:
3053         case MAC_PROP_EN_100HDX_CAP:
3054         case MAC_PROP_ADV_10FDX_CAP:
3055         case MAC_PROP_EN_10FDX_CAP:
3056         case MAC_PROP_ADV_10HDX_CAP:
3057         case MAC_PROP_EN_10HDX_CAP:
3058         case MAC_PROP_ADV_100T4_CAP:
3059         case MAC_PROP_EN_100T4_CAP:
3060                 minsize = sizeof (uint8_t);
3061                 break;
3062         case MAC_PROP_PVID:
3063                 minsize = sizeof (uint16_t);
3064                 break;
3065         case MAC_PROP_IPTUN_HOPLIMIT:
3066                 minsize = sizeof (uint32_t);
3067                 break;
3068         case MAC_PROP_IPTUN_ENCAPLIMIT:
3069                 minsize = sizeof (uint32_t);
3070                 break;
3071         case MAC_PROP_MAX_TX_RINGS_AVAIL:
3072         case MAC_PROP_MAX_RX_RINGS_AVAIL:
3073         case MAC_PROP_MAX_RXHWCLNT_AVAIL:
3074         case MAC_PROP_MAX_TXHWCLNT_AVAIL:
3075                 minsize = sizeof (uint_t);
3076                 break;
3077         case MAC_PROP_WL_ESSID:
3078                 minsize = sizeof (wl_linkstatus_t);
3079                 break;
3080         case MAC_PROP_WL_BSSID:
3081                 minsize = sizeof (wl_bssid_t);
3082                 break;
3083         case MAC_PROP_WL_BSSTYPE:
3084                 minsize = sizeof (wl_bss_type_t);
3085                 break;
3086         case MAC_PROP_WL_LINKSTATUS:
3087                 minsize = sizeof (wl_linkstatus_t);
3088                 break;
3089         case MAC_PROP_WL_DESIRED_RATES:
3090                 minsize = sizeof (wl_rates_t);
3091                 break;
3092         case MAC_PROP_WL_SUPPORTED_RATES:
3093                 minsize = sizeof (wl_rates_t);
3094                 break;
3095         case MAC_PROP_WL_AUTH_MODE:
3096                 minsize = sizeof (wl_authmode_t);
3097                 break;
3098         case MAC_PROP_WL_ENCRYPTION:
3099                 minsize = sizeof (wl_encryption_t);
3100                 break;
3101         case MAC_PROP_WL_RSSI:
3102                 minsize = sizeof (wl_rssi_t);
3103                 break;
3104         case MAC_PROP_WL_PHY_CONFIG:
3105                 minsize = sizeof (wl_phy_conf_t);
3106                 break;
3107         case MAC_PROP_WL_CAPABILITY:
3108                 minsize = sizeof (wl_capability_t);
3109                 break;
3110         case MAC_PROP_WL_WPA:
3111                 minsize = sizeof (wl_wpa_t);
3112                 break;
3113         case MAC_PROP_WL_SCANRESULTS:
3114                 minsize = sizeof (wl_wpa_ess_t);
3115                 break;
3116         case MAC_PROP_WL_POWER_MODE:
3117                 minsize = sizeof (wl_ps_mode_t);
3118                 break;
3119         case MAC_PROP_WL_RADIO:
3120                 minsize = sizeof (wl_radio_t);
3121                 break;
3122         case MAC_PROP_WL_ESS_LIST:
3123                 minsize = sizeof (wl_ess_list_t);
3124                 break;
3125         case MAC_PROP_WL_KEY_TAB:
3126                 minsize = sizeof (wl_wep_key_tab_t);
3127                 break;
3128         case MAC_PROP_WL_CREATE_IBSS:
3129                 minsize = sizeof (wl_create_ibss_t);
3130                 break;
3131         case MAC_PROP_WL_SETOPTIE:
3132                 minsize = sizeof (wl_wpa_ie_t);
3133                 break;
3134         case MAC_PROP_WL_DELKEY:
3135                 minsize = sizeof (wl_del_key_t);
3136                 break;
3137         case MAC_PROP_WL_KEY:
3138                 minsize = sizeof (wl_key_t);
3139                 break;
3140         case MAC_PROP_WL_MLME:
3141                 minsize = sizeof (wl_mlme_t);
3142                 break;
3143         case MAC_PROP_VN_PROMISC_FILTERED:
3144                 minsize = sizeof (boolean_t);
3145                 break;
3146         }
3147 
3148         return (valsize >= minsize);
3149 }
3150 
3151 /*
3152  * mac_set_prop() sets MAC or hardware driver properties:
3153  *
3154  * - MAC-managed properties such as resource properties include maxbw,
3155  *   priority, and cpu binding list, as well as the default port VID
3156  *   used by bridging. These properties are consumed by the MAC layer
3157  *   itself and not passed down to the driver. For resource control
3158  *   properties, this function invokes mac_set_resources() which will
3159  *   cache the property value in mac_impl_t and may call
3160  *   mac_client_set_resource() to update property value of the primary
3161  *   mac client, if it exists.
3162  *
3163  * - Properties which act on the hardware and must be passed to the
3164  *   driver, such as MTU, through the driver's mc_setprop() entry point.
3165  */
3166 int
3167 mac_set_prop(mac_handle_t mh, mac_prop_id_t id, char *name, void *val,
3168     uint_t valsize)
3169 {
3170         int err = ENOTSUP;
3171         mac_impl_t *mip = (mac_impl_t *)mh;
3172 
3173         ASSERT(MAC_PERIM_HELD(mh));
3174 
3175         switch (id) {
3176         case MAC_PROP_RESOURCE: {
3177                 mac_resource_props_t *mrp;
3178 
3179                 /* call mac_set_resources() for MAC properties */
3180                 ASSERT(valsize >= sizeof (mac_resource_props_t));
3181                 mrp = kmem_zalloc(sizeof (*mrp), KM_SLEEP);
3182                 bcopy(val, mrp, sizeof (*mrp));
3183                 err = mac_set_resources(mh, mrp);
3184                 kmem_free(mrp, sizeof (*mrp));
3185                 break;
3186         }
3187 
3188         case MAC_PROP_PVID:
3189                 ASSERT(valsize >= sizeof (uint16_t));
3190                 if (mip->mi_state_flags & MIS_IS_VNIC)
3191                         return (EINVAL);
3192                 err = mac_set_pvid(mh, *(uint16_t *)val);
3193                 break;
3194 
3195         case MAC_PROP_MTU: {
3196                 uint32_t mtu;
3197 
3198                 ASSERT(valsize >= sizeof (uint32_t));
3199                 bcopy(val, &mtu, sizeof (mtu));
3200                 err = mac_set_mtu(mh, mtu, NULL);
3201                 break;
3202         }
3203 
3204         case MAC_PROP_LLIMIT:
3205         case MAC_PROP_LDECAY: {
3206                 uint32_t learnval;
3207 
3208                 if (valsize < sizeof (learnval) ||
3209                     (mip->mi_state_flags & MIS_IS_VNIC))
3210                         return (EINVAL);
3211                 bcopy(val, &learnval, sizeof (learnval));
3212                 if (learnval == 0 && id == MAC_PROP_LDECAY)
3213                         return (EINVAL);
3214                 if (id == MAC_PROP_LLIMIT)
3215                         mip->mi_llimit = learnval;
3216                 else
3217                         mip->mi_ldecay = learnval;
3218                 err = 0;
3219                 break;
3220         }
3221 
3222         default:
3223                 /* For other driver properties, call driver's callback */
3224                 if (mip->mi_callbacks->mc_callbacks & MC_SETPROP) {
3225                         err = mip->mi_callbacks->mc_setprop(mip->mi_driver,
3226                             name, id, valsize, val);
3227                 }
3228         }
3229         return (err);
3230 }
3231 
3232 /*
3233  * mac_get_prop() gets MAC or device driver properties.
3234  *
3235  * If the property is a driver property, mac_get_prop() calls driver's callback
3236  * entry point to get it.
3237  * If the property is a MAC property, mac_get_prop() invokes mac_get_resources()
3238  * which returns the cached value in mac_impl_t.
3239  */
3240 int
3241 mac_get_prop(mac_handle_t mh, mac_prop_id_t id, char *name, void *val,
3242     uint_t valsize)
3243 {
3244         int err = ENOTSUP;
3245         mac_impl_t *mip = (mac_impl_t *)mh;
3246         uint_t  rings;
3247         uint_t  vlinks;
3248 
3249         bzero(val, valsize);
3250 
3251         switch (id) {
3252         case MAC_PROP_RESOURCE: {
3253                 mac_resource_props_t *mrp;
3254 
3255                 /* If mac property, read from cache */
3256                 ASSERT(valsize >= sizeof (mac_resource_props_t));
3257                 mrp = kmem_zalloc(sizeof (*mrp), KM_SLEEP);
3258                 mac_get_resources(mh, mrp);
3259                 bcopy(mrp, val, sizeof (*mrp));
3260                 kmem_free(mrp, sizeof (*mrp));
3261                 return (0);
3262         }
3263         case MAC_PROP_RESOURCE_EFF: {
3264                 mac_resource_props_t *mrp;
3265 
3266                 /* If mac effective property, read from client */
3267                 ASSERT(valsize >= sizeof (mac_resource_props_t));
3268                 mrp = kmem_zalloc(sizeof (*mrp), KM_SLEEP);
3269                 mac_get_effective_resources(mh, mrp);
3270                 bcopy(mrp, val, sizeof (*mrp));
3271                 kmem_free(mrp, sizeof (*mrp));
3272                 return (0);
3273         }
3274 
3275         case MAC_PROP_PVID:
3276                 ASSERT(valsize >= sizeof (uint16_t));
3277                 if (mip->mi_state_flags & MIS_IS_VNIC)
3278                         return (EINVAL);
3279                 *(uint16_t *)val = mac_get_pvid(mh);
3280                 return (0);
3281 
3282         case MAC_PROP_LLIMIT:
3283         case MAC_PROP_LDECAY:
3284                 ASSERT(valsize >= sizeof (uint32_t));
3285                 if (mip->mi_state_flags & MIS_IS_VNIC)
3286                         return (EINVAL);
3287                 if (id == MAC_PROP_LLIMIT)
3288                         bcopy(&mip->mi_llimit, val, sizeof (mip->mi_llimit));
3289                 else
3290                         bcopy(&mip->mi_ldecay, val, sizeof (mip->mi_ldecay));
3291                 return (0);
3292 
3293         case MAC_PROP_MTU: {
3294                 uint32_t sdu;
3295 
3296                 ASSERT(valsize >= sizeof (uint32_t));
3297                 mac_sdu_get2(mh, NULL, &sdu, NULL);
3298                 bcopy(&sdu, val, sizeof (sdu));
3299 
3300                 return (0);
3301         }
3302         case MAC_PROP_STATUS: {
3303                 link_state_t link_state;
3304 
3305                 if (valsize < sizeof (link_state))
3306                         return (EINVAL);
3307                 link_state = mac_link_get(mh);
3308                 bcopy(&link_state, val, sizeof (link_state));
3309 
3310                 return (0);
3311         }
3312 
3313         case MAC_PROP_MAX_RX_RINGS_AVAIL:
3314         case MAC_PROP_MAX_TX_RINGS_AVAIL:
3315                 ASSERT(valsize >= sizeof (uint_t));
3316                 rings = id == MAC_PROP_MAX_RX_RINGS_AVAIL ?
3317                     mac_rxavail_get(mh) : mac_txavail_get(mh);
3318                 bcopy(&rings, val, sizeof (uint_t));
3319                 return (0);
3320 
3321         case MAC_PROP_MAX_RXHWCLNT_AVAIL:
3322         case MAC_PROP_MAX_TXHWCLNT_AVAIL:
3323                 ASSERT(valsize >= sizeof (uint_t));
3324                 vlinks = id == MAC_PROP_MAX_RXHWCLNT_AVAIL ?
3325                     mac_rxhwlnksavail_get(mh) : mac_txhwlnksavail_get(mh);
3326                 bcopy(&vlinks, val, sizeof (uint_t));
3327                 return (0);
3328 
3329         case MAC_PROP_RXRINGSRANGE:
3330         case MAC_PROP_TXRINGSRANGE:
3331                 /*
3332                  * The value for these properties are returned through
3333                  * the MAC_PROP_RESOURCE property.
3334                  */
3335                 return (0);
3336 
3337         default:
3338                 break;
3339 
3340         }
3341 
3342         /* If driver property, request from driver */
3343         if (mip->mi_callbacks->mc_callbacks & MC_GETPROP) {
3344                 err = mip->mi_callbacks->mc_getprop(mip->mi_driver, name, id,
3345                     valsize, val);
3346         }
3347 
3348         return (err);
3349 }
3350 
3351 /*
3352  * Helper function to initialize the range structure for use in
3353  * mac_get_prop. If the type can be other than uint32, we can
3354  * pass that as an arg.
3355  */
3356 static void
3357 _mac_set_range(mac_propval_range_t *range, uint32_t min, uint32_t max)
3358 {
3359         range->mpr_count = 1;
3360         range->mpr_type = MAC_PROPVAL_UINT32;
3361         range->mpr_range_uint32[0].mpur_min = min;
3362         range->mpr_range_uint32[0].mpur_max = max;
3363 }
3364 
3365 /*
3366  * Returns information about the specified property, such as default
3367  * values or permissions.
3368  */
3369 int
3370 mac_prop_info(mac_handle_t mh, mac_prop_id_t id, char *name,
3371     void *default_val, uint_t default_size, mac_propval_range_t *range,
3372     uint_t *perm)
3373 {
3374         mac_prop_info_state_t state;
3375         mac_impl_t *mip = (mac_impl_t *)mh;
3376         uint_t  max;
3377 
3378         /*
3379          * A property is read/write by default unless the driver says
3380          * otherwise.
3381          */
3382         if (perm != NULL)
3383                 *perm = MAC_PROP_PERM_RW;
3384 
3385         if (default_val != NULL)
3386                 bzero(default_val, default_size);
3387 
3388         /*
3389          * First, handle framework properties for which we don't need to
3390          * involve the driver.
3391          */
3392         switch (id) {
3393         case MAC_PROP_RESOURCE:
3394         case MAC_PROP_PVID:
3395         case MAC_PROP_LLIMIT:
3396         case MAC_PROP_LDECAY:
3397                 return (0);
3398 
3399         case MAC_PROP_MAX_RX_RINGS_AVAIL:
3400         case MAC_PROP_MAX_TX_RINGS_AVAIL:
3401         case MAC_PROP_MAX_RXHWCLNT_AVAIL:
3402         case MAC_PROP_MAX_TXHWCLNT_AVAIL:
3403                 if (perm != NULL)
3404                         *perm = MAC_PROP_PERM_READ;
3405                 return (0);
3406 
3407         case MAC_PROP_RXRINGSRANGE:
3408         case MAC_PROP_TXRINGSRANGE:
3409                 /*
3410                  * Currently, we support range for RX and TX rings properties.
3411                  * When we extend this support to maxbw, cpus and priority,
3412                  * we should move this to mac_get_resources.
3413                  * There is no default value for RX or TX rings.
3414                  */
3415                 if ((mip->mi_state_flags & MIS_IS_VNIC) &&
3416                     mac_is_vnic_primary(mh)) {
3417                         /*
3418                          * We don't support setting rings for a VLAN
3419                          * data link because it shares its ring with the
3420                          * primary MAC client.
3421                          */
3422                         if (perm != NULL)
3423                                 *perm = MAC_PROP_PERM_READ;
3424                         if (range != NULL)
3425                                 range->mpr_count = 0;
3426                 } else if (range != NULL) {
3427                         if (mip->mi_state_flags & MIS_IS_VNIC)
3428                                 mh = mac_get_lower_mac_handle(mh);
3429                         mip = (mac_impl_t *)mh;
3430                         if ((id == MAC_PROP_RXRINGSRANGE &&
3431                             mip->mi_rx_group_type == MAC_GROUP_TYPE_STATIC) ||
3432                             (id == MAC_PROP_TXRINGSRANGE &&
3433                             mip->mi_tx_group_type == MAC_GROUP_TYPE_STATIC)) {
3434                                 if (id == MAC_PROP_RXRINGSRANGE) {
3435                                         if ((mac_rxhwlnksavail_get(mh) +
3436                                             mac_rxhwlnksrsvd_get(mh)) <= 1) {
3437                                                 /*
3438                                                  * doesn't support groups or
3439                                                  * rings
3440                                                  */
3441                                                 range->mpr_count = 0;
3442                                         } else {
3443                                                 /*
3444                                                  * supports specifying groups,
3445                                                  * but not rings
3446                                                  */
3447                                                 _mac_set_range(range, 0, 0);
3448                                         }
3449                                 } else {
3450                                         if ((mac_txhwlnksavail_get(mh) +
3451                                             mac_txhwlnksrsvd_get(mh)) <= 1) {
3452                                                 /*
3453                                                  * doesn't support groups or
3454                                                  * rings
3455                                                  */
3456                                                 range->mpr_count = 0;
3457                                         } else {
3458                                                 /*
3459                                                  * supports specifying groups,
3460                                                  * but not rings
3461                                                  */
3462                                                 _mac_set_range(range, 0, 0);
3463                                         }
3464                                 }
3465                         } else {
3466                                 max = id == MAC_PROP_RXRINGSRANGE ?
3467                                     mac_rxavail_get(mh) + mac_rxrsvd_get(mh) :
3468                                     mac_txavail_get(mh) + mac_txrsvd_get(mh);
3469                                 if (max <= 1) {
3470                                         /*
3471                                          * doesn't support groups or
3472                                          * rings
3473                                          */
3474                                         range->mpr_count = 0;
3475                                 } else  {
3476                                         /*
3477                                          * -1 because we have to leave out the
3478                                          * default ring.
3479                                          */
3480                                         _mac_set_range(range, 1, max - 1);
3481                                 }
3482                         }
3483                 }
3484                 return (0);
3485 
3486         case MAC_PROP_STATUS:
3487                 if (perm != NULL)
3488                         *perm = MAC_PROP_PERM_READ;
3489                 return (0);
3490         }
3491 
3492         /*
3493          * Get the property info from the driver if it implements the
3494          * property info entry point.
3495          */
3496         bzero(&state, sizeof (state));
3497 
3498         if (mip->mi_callbacks->mc_callbacks & MC_PROPINFO) {
3499                 state.pr_default = default_val;
3500                 state.pr_default_size = default_size;
3501 
3502                 /*
3503                  * The caller specifies the maximum number of ranges
3504                  * it can accomodate using mpr_count. We don't touch
3505                  * this value until the driver returns from its
3506                  * mc_propinfo() callback, and ensure we don't exceed
3507                  * this number of range as the driver defines
3508                  * supported range from its mc_propinfo().
3509                  *
3510                  * pr_range_cur_count keeps track of how many ranges
3511                  * were defined by the driver from its mc_propinfo()
3512                  * entry point.
3513                  *
3514                  * On exit, the user-specified range mpr_count returns
3515                  * the number of ranges specified by the driver on
3516                  * success, or the number of ranges it wanted to
3517                  * define if that number of ranges could not be
3518                  * accomodated by the specified range structure.  In
3519                  * the latter case, the caller will be able to
3520                  * allocate a larger range structure, and query the
3521                  * property again.
3522                  */
3523                 state.pr_range_cur_count = 0;
3524                 state.pr_range = range;
3525 
3526                 mip->mi_callbacks->mc_propinfo(mip->mi_driver, name, id,
3527                     (mac_prop_info_handle_t)&state);
3528 
3529                 if (state.pr_flags & MAC_PROP_INFO_RANGE)
3530                         range->mpr_count = state.pr_range_cur_count;
3531 
3532                 /*
3533                  * The operation could fail if the buffer supplied by
3534                  * the user was too small for the range or default
3535                  * value of the property.
3536                  */
3537                 if (state.pr_errno != 0)
3538                         return (state.pr_errno);
3539 
3540                 if (perm != NULL && state.pr_flags & MAC_PROP_INFO_PERM)
3541                         *perm = state.pr_perm;
3542         }
3543 
3544         /*
3545          * The MAC layer may want to provide default values or allowed
3546          * ranges for properties if the driver does not provide a
3547          * property info entry point, or that entry point exists, but
3548          * it did not provide a default value or allowed ranges for
3549          * that property.
3550          */
3551         switch (id) {
3552         case MAC_PROP_MTU: {
3553                 uint32_t sdu;
3554 
3555                 mac_sdu_get2(mh, NULL, &sdu, NULL);
3556 
3557                 if (range != NULL && !(state.pr_flags &
3558                     MAC_PROP_INFO_RANGE)) {
3559                         /* MTU range */
3560                         _mac_set_range(range, sdu, sdu);
3561                 }
3562 
3563                 if (default_val != NULL && !(state.pr_flags &
3564                     MAC_PROP_INFO_DEFAULT)) {
3565                         if (mip->mi_info.mi_media == DL_ETHER)
3566                                 sdu = ETHERMTU;
3567                         /* default MTU value */
3568                         bcopy(&sdu, default_val, sizeof (sdu));
3569                 }
3570         }
3571         }
3572 
3573         return (0);
3574 }
3575 
3576 int
3577 mac_fastpath_disable(mac_handle_t mh)
3578 {
3579         mac_impl_t      *mip = (mac_impl_t *)mh;
3580 
3581         if ((mip->mi_state_flags & MIS_LEGACY) == 0)
3582                 return (0);
3583 
3584         return (mip->mi_capab_legacy.ml_fastpath_disable(mip->mi_driver));
3585 }
3586 
3587 void
3588 mac_fastpath_enable(mac_handle_t mh)
3589 {
3590         mac_impl_t      *mip = (mac_impl_t *)mh;
3591 
3592         if ((mip->mi_state_flags & MIS_LEGACY) == 0)
3593                 return;
3594 
3595         mip->mi_capab_legacy.ml_fastpath_enable(mip->mi_driver);
3596 }
3597 
3598 void
3599 mac_register_priv_prop(mac_impl_t *mip, char **priv_props)
3600 {
3601         uint_t nprops, i;
3602 
3603         if (priv_props == NULL)
3604                 return;
3605 
3606         nprops = 0;
3607         while (priv_props[nprops] != NULL)
3608                 nprops++;
3609         if (nprops == 0)
3610                 return;
3611 
3612 
3613         mip->mi_priv_prop = kmem_zalloc(nprops * sizeof (char *), KM_SLEEP);
3614 
3615         for (i = 0; i < nprops; i++) {
3616                 mip->mi_priv_prop[i] = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
3617                 (void) strlcpy(mip->mi_priv_prop[i], priv_props[i],
3618                     MAXLINKPROPNAME);
3619         }
3620 
3621         mip->mi_priv_prop_count = nprops;
3622 }
3623 
3624 void
3625 mac_unregister_priv_prop(mac_impl_t *mip)
3626 {
3627         uint_t i;
3628 
3629         if (mip->mi_priv_prop_count == 0) {
3630                 ASSERT(mip->mi_priv_prop == NULL);
3631                 return;
3632         }
3633 
3634         for (i = 0; i < mip->mi_priv_prop_count; i++)
3635                 kmem_free(mip->mi_priv_prop[i], MAXLINKPROPNAME);
3636         kmem_free(mip->mi_priv_prop, mip->mi_priv_prop_count *
3637             sizeof (char *));
3638 
3639         mip->mi_priv_prop = NULL;
3640         mip->mi_priv_prop_count = 0;
3641 }
3642 
3643 /*
3644  * mac_ring_t 'mr' macros. Some rogue drivers may access ring structure
3645  * (by invoking mac_rx()) even after processing mac_stop_ring(). In such
3646  * cases if MAC free's the ring structure after mac_stop_ring(), any
3647  * illegal access to the ring structure coming from the driver will panic
3648  * the system. In order to protect the system from such inadverent access,
3649  * we maintain a cache of rings in the mac_impl_t after they get free'd up.
3650  * When packets are received on free'd up rings, MAC (through the generation
3651  * count mechanism) will drop such packets.
3652  */
3653 static mac_ring_t *
3654 mac_ring_alloc(mac_impl_t *mip)
3655 {
3656         mac_ring_t *ring;
3657 
3658         mutex_enter(&mip->mi_ring_lock);
3659         if (mip->mi_ring_freelist != NULL) {
3660                 ring = mip->mi_ring_freelist;
3661                 mip->mi_ring_freelist = ring->mr_next;
3662                 bzero(ring, sizeof (mac_ring_t));
3663                 mutex_exit(&mip->mi_ring_lock);
3664         } else {
3665                 mutex_exit(&mip->mi_ring_lock);
3666                 ring = kmem_cache_alloc(mac_ring_cache, KM_SLEEP);
3667         }
3668         ASSERT((ring != NULL) && (ring->mr_state == MR_FREE));
3669         return (ring);
3670 }
3671 
3672 static void
3673 mac_ring_free(mac_impl_t *mip, mac_ring_t *ring)
3674 {
3675         ASSERT(ring->mr_state == MR_FREE);
3676 
3677         mutex_enter(&mip->mi_ring_lock);
3678         ring->mr_state = MR_FREE;
3679         ring->mr_flag = 0;
3680         ring->mr_next = mip->mi_ring_freelist;
3681         ring->mr_mip = NULL;
3682         mip->mi_ring_freelist = ring;
3683         mac_ring_stat_delete(ring);
3684         mutex_exit(&mip->mi_ring_lock);
3685 }
3686 
3687 static void
3688 mac_ring_freeall(mac_impl_t *mip)
3689 {
3690         mac_ring_t *ring_next;
3691         mutex_enter(&mip->mi_ring_lock);
3692         mac_ring_t *ring = mip->mi_ring_freelist;
3693         while (ring != NULL) {
3694                 ring_next = ring->mr_next;
3695                 kmem_cache_free(mac_ring_cache, ring);
3696                 ring = ring_next;
3697         }
3698         mip->mi_ring_freelist = NULL;
3699         mutex_exit(&mip->mi_ring_lock);
3700 }
3701 
3702 int
3703 mac_start_ring(mac_ring_t *ring)
3704 {
3705         int rv = 0;
3706 
3707         ASSERT(ring->mr_state == MR_FREE);
3708 
3709         if (ring->mr_start != NULL) {
3710                 rv = ring->mr_start(ring->mr_driver, ring->mr_gen_num);
3711                 if (rv != 0)
3712                         return (rv);
3713         }
3714 
3715         ring->mr_state = MR_INUSE;
3716         return (rv);
3717 }
3718 
3719 void
3720 mac_stop_ring(mac_ring_t *ring)
3721 {
3722         ASSERT(ring->mr_state == MR_INUSE);
3723 
3724         if (ring->mr_stop != NULL)
3725                 ring->mr_stop(ring->mr_driver);
3726 
3727         ring->mr_state = MR_FREE;
3728 
3729         /*
3730          * Increment the ring generation number for this ring.
3731          */
3732         ring->mr_gen_num++;
3733 }
3734 
3735 int
3736 mac_start_group(mac_group_t *group)
3737 {
3738         int rv = 0;
3739 
3740         if (group->mrg_start != NULL)
3741                 rv = group->mrg_start(group->mrg_driver);
3742 
3743         return (rv);
3744 }
3745 
3746 void
3747 mac_stop_group(mac_group_t *group)
3748 {
3749         if (group->mrg_stop != NULL)
3750                 group->mrg_stop(group->mrg_driver);
3751 }
3752 
3753 /*
3754  * Called from mac_start() on the default Rx group. Broadcast and multicast
3755  * packets are received only on the default group. Hence the default group
3756  * needs to be up even if the primary client is not up, for the other groups
3757  * to be functional. We do this by calling this function at mac_start time
3758  * itself. However the broadcast packets that are received can't make their
3759  * way beyond mac_rx until a mac client creates a broadcast flow.
3760  */
3761 static int
3762 mac_start_group_and_rings(mac_group_t *group)
3763 {
3764         mac_ring_t      *ring;
3765         int             rv = 0;
3766 
3767         ASSERT(group->mrg_state == MAC_GROUP_STATE_REGISTERED);
3768         if ((rv = mac_start_group(group)) != 0)
3769                 return (rv);
3770 
3771         for (ring = group->mrg_rings; ring != NULL; ring = ring->mr_next) {
3772                 ASSERT(ring->mr_state == MR_FREE);
3773                 if ((rv = mac_start_ring(ring)) != 0)
3774                         goto error;
3775                 ring->mr_classify_type = MAC_SW_CLASSIFIER;
3776         }
3777         return (0);
3778 
3779 error:
3780         mac_stop_group_and_rings(group);
3781         return (rv);
3782 }
3783 
3784 /* Called from mac_stop on the default Rx group */
3785 static void
3786 mac_stop_group_and_rings(mac_group_t *group)
3787 {
3788         mac_ring_t      *ring;
3789 
3790         for (ring = group->mrg_rings; ring != NULL; ring = ring->mr_next) {
3791                 if (ring->mr_state != MR_FREE) {
3792                         mac_stop_ring(ring);
3793                         ring->mr_flag = 0;
3794                         ring->mr_classify_type = MAC_NO_CLASSIFIER;
3795                 }
3796         }
3797         mac_stop_group(group);
3798 }
3799 
3800 
3801 static mac_ring_t *
3802 mac_init_ring(mac_impl_t *mip, mac_group_t *group, int index,
3803     mac_capab_rings_t *cap_rings)
3804 {
3805         mac_ring_t *ring, *rnext;
3806         mac_ring_info_t ring_info;
3807         ddi_intr_handle_t ddi_handle;
3808 
3809         ring = mac_ring_alloc(mip);
3810 
3811         /* Prepare basic information of ring */
3812 
3813         /*
3814          * Ring index is numbered to be unique across a particular device.
3815          * Ring index computation makes following assumptions:
3816          *      - For drivers with static grouping (e.g. ixgbe, bge),
3817          *      ring index exchanged with the driver (e.g. during mr_rget)
3818          *      is unique only across the group the ring belongs to.
3819          *      - Drivers with dynamic grouping (e.g. nxge), start
3820          *      with single group (mrg_index = 0).
3821          */
3822         ring->mr_index = group->mrg_index * group->mrg_info.mgi_count + index;
3823         ring->mr_type = group->mrg_type;
3824         ring->mr_gh = (mac_group_handle_t)group;
3825 
3826         /* Insert the new ring to the list. */
3827         ring->mr_next = group->mrg_rings;
3828         group->mrg_rings = ring;
3829 
3830         /* Zero to reuse the info data structure */
3831         bzero(&ring_info, sizeof (ring_info));
3832 
3833         /* Query ring information from driver */
3834         cap_rings->mr_rget(mip->mi_driver, group->mrg_type, group->mrg_index,
3835             index, &ring_info, (mac_ring_handle_t)ring);
3836 
3837         ring->mr_info = ring_info;
3838 
3839         /*
3840          * The interrupt handle could be shared among multiple rings.
3841          * Thus if there is a bunch of rings that are sharing an
3842          * interrupt, then only one ring among the bunch will be made
3843          * available for interrupt re-targeting; the rest will have
3844          * ddi_shared flag set to TRUE and would not be available for
3845          * be interrupt re-targeting.
3846          */
3847         if ((ddi_handle = ring_info.mri_intr.mi_ddi_handle) != NULL) {
3848                 rnext = ring->mr_next;
3849                 while (rnext != NULL) {
3850                         if (rnext->mr_info.mri_intr.mi_ddi_handle ==
3851                             ddi_handle) {
3852                                 /*
3853                                  * If default ring (mr_index == 0) is part
3854                                  * of a group of rings sharing an
3855                                  * interrupt, then set ddi_shared flag for
3856                                  * the default ring and give another ring
3857                                  * the chance to be re-targeted.
3858                                  */
3859                                 if (rnext->mr_index == 0 &&
3860                                     !rnext->mr_info.mri_intr.mi_ddi_shared) {
3861                                         rnext->mr_info.mri_intr.mi_ddi_shared =
3862                                             B_TRUE;
3863                                 } else {
3864                                         ring->mr_info.mri_intr.mi_ddi_shared =
3865                                             B_TRUE;
3866                                 }
3867                                 break;
3868                         }
3869                         rnext = rnext->mr_next;
3870                 }
3871                 /*
3872                  * If rnext is NULL, then no matching ddi_handle was found.
3873                  * Rx rings get registered first. So if this is a Tx ring,
3874                  * then go through all the Rx rings and see if there is a
3875                  * matching ddi handle.
3876                  */
3877                 if (rnext == NULL && ring->mr_type == MAC_RING_TYPE_TX) {
3878                         mac_compare_ddi_handle(mip->mi_rx_groups,
3879                             mip->mi_rx_group_count, ring);
3880                 }
3881         }
3882 
3883         /* Update ring's status */
3884         ring->mr_state = MR_FREE;
3885         ring->mr_flag = 0;
3886 
3887         /* Update the ring count of the group */
3888         group->mrg_cur_count++;
3889 
3890         /* Create per ring kstats */
3891         if (ring->mr_stat != NULL) {
3892                 ring->mr_mip = mip;
3893                 mac_ring_stat_create(ring);
3894         }
3895 
3896         return (ring);
3897 }
3898 
3899 /*
3900  * Rings are chained together for easy regrouping.
3901  */
3902 static void
3903 mac_init_group(mac_impl_t *mip, mac_group_t *group, int size,
3904     mac_capab_rings_t *cap_rings)
3905 {
3906         int index;
3907 
3908         /*
3909          * Initialize all ring members of this group. Size of zero will not
3910          * enter the loop, so it's safe for initializing an empty group.
3911          */
3912         for (index = size - 1; index >= 0; index--)
3913                 (void) mac_init_ring(mip, group, index, cap_rings);
3914 }
3915 
3916 int
3917 mac_init_rings(mac_impl_t *mip, mac_ring_type_t rtype)
3918 {
3919         mac_capab_rings_t       *cap_rings;
3920         mac_group_t             *group;
3921         mac_group_t             *groups;
3922         mac_group_info_t        group_info;
3923         uint_t                  group_free = 0;
3924         uint_t                  ring_left;
3925         mac_ring_t              *ring;
3926         int                     g;
3927         int                     err = 0;
3928         uint_t                  grpcnt;
3929         boolean_t               pseudo_txgrp = B_FALSE;
3930 
3931         switch (rtype) {
3932         case MAC_RING_TYPE_RX:
3933                 ASSERT(mip->mi_rx_groups == NULL);
3934 
3935                 cap_rings = &mip->mi_rx_rings_cap;
3936                 cap_rings->mr_type = MAC_RING_TYPE_RX;
3937                 break;
3938         case MAC_RING_TYPE_TX:
3939                 ASSERT(mip->mi_tx_groups == NULL);
3940 
3941                 cap_rings = &mip->mi_tx_rings_cap;
3942                 cap_rings->mr_type = MAC_RING_TYPE_TX;
3943                 break;
3944         default:
3945                 ASSERT(B_FALSE);
3946         }
3947 
3948         if (!i_mac_capab_get((mac_handle_t)mip, MAC_CAPAB_RINGS, cap_rings))
3949                 return (0);
3950         grpcnt = cap_rings->mr_gnum;
3951 
3952         /*
3953          * If we have multiple TX rings, but only one TX group, we can
3954          * create pseudo TX groups (one per TX ring) in the MAC layer,
3955          * except for an aggr. For an aggr currently we maintain only
3956          * one group with all the rings (for all its ports), going
3957          * forwards we might change this.
3958          */
3959         if (rtype == MAC_RING_TYPE_TX &&
3960             cap_rings->mr_gnum == 0 && cap_rings->mr_rnum >  0 &&
3961             (mip->mi_state_flags & MIS_IS_AGGR) == 0) {
3962                 /*
3963                  * The -1 here is because we create a default TX group
3964                  * with all the rings in it.
3965                  */
3966                 grpcnt = cap_rings->mr_rnum - 1;
3967                 pseudo_txgrp = B_TRUE;
3968         }
3969 
3970         /*
3971          * Allocate a contiguous buffer for all groups.
3972          */
3973         groups = kmem_zalloc(sizeof (mac_group_t) * (grpcnt+ 1), KM_SLEEP);
3974 
3975         ring_left = cap_rings->mr_rnum;
3976 
3977         /*
3978          * Get all ring groups if any, and get their ring members
3979          * if any.
3980          */
3981         for (g = 0; g < grpcnt; g++) {
3982                 group = groups + g;
3983 
3984                 /* Prepare basic information of the group */
3985                 group->mrg_index = g;
3986                 group->mrg_type = rtype;
3987                 group->mrg_state = MAC_GROUP_STATE_UNINIT;
3988                 group->mrg_mh = (mac_handle_t)mip;
3989                 group->mrg_next = group + 1;
3990 
3991                 /* Zero to reuse the info data structure */
3992                 bzero(&group_info, sizeof (group_info));
3993 
3994                 if (pseudo_txgrp) {
3995                         /*
3996                          * This is a pseudo group that we created, apart
3997                          * from setting the state there is nothing to be
3998                          * done.
3999                          */
4000                         group->mrg_state = MAC_GROUP_STATE_REGISTERED;
4001                         group_free++;
4002                         continue;
4003                 }
4004                 /* Query group information from driver */
4005                 cap_rings->mr_gget(mip->mi_driver, rtype, g, &group_info,
4006                     (mac_group_handle_t)group);
4007 
4008                 switch (cap_rings->mr_group_type) {
4009                 case MAC_GROUP_TYPE_DYNAMIC:
4010                         if (cap_rings->mr_gaddring == NULL ||
4011                             cap_rings->mr_gremring == NULL) {
4012                                 DTRACE_PROBE3(
4013                                     mac__init__rings_no_addremring,
4014                                     char *, mip->mi_name,
4015                                     mac_group_add_ring_t,
4016                                     cap_rings->mr_gaddring,
4017                                     mac_group_add_ring_t,
4018                                     cap_rings->mr_gremring);
4019                                 err = EINVAL;
4020                                 goto bail;
4021                         }
4022 
4023                         switch (rtype) {
4024                         case MAC_RING_TYPE_RX:
4025                                 /*
4026                                  * The first RX group must have non-zero
4027                                  * rings, and the following groups must
4028                                  * have zero rings.
4029                                  */
4030                                 if (g == 0 && group_info.mgi_count == 0) {
4031                                         DTRACE_PROBE1(
4032                                             mac__init__rings__rx__def__zero,
4033                                             char *, mip->mi_name);
4034                                         err = EINVAL;
4035                                         goto bail;
4036                                 }
4037                                 if (g > 0 && group_info.mgi_count != 0) {
4038                                         DTRACE_PROBE3(
4039                                             mac__init__rings__rx__nonzero,
4040                                             char *, mip->mi_name,
4041                                             int, g, int, group_info.mgi_count);
4042                                         err = EINVAL;
4043                                         goto bail;
4044                                 }
4045                                 break;
4046                         case MAC_RING_TYPE_TX:
4047                                 /*
4048                                  * All TX ring groups must have zero rings.
4049                                  */
4050                                 if (group_info.mgi_count != 0) {
4051                                         DTRACE_PROBE3(
4052                                             mac__init__rings__tx__nonzero,
4053                                             char *, mip->mi_name,
4054                                             int, g, int, group_info.mgi_count);
4055                                         err = EINVAL;
4056                                         goto bail;
4057                                 }
4058                                 break;
4059                         }
4060                         break;
4061                 case MAC_GROUP_TYPE_STATIC:
4062                         /*
4063                          * Note that an empty group is allowed, e.g., an aggr
4064                          * would start with an empty group.
4065                          */
4066                         break;
4067                 default:
4068                         /* unknown group type */
4069                         DTRACE_PROBE2(mac__init__rings__unknown__type,
4070                             char *, mip->mi_name,
4071                             int, cap_rings->mr_group_type);
4072                         err = EINVAL;
4073                         goto bail;
4074                 }
4075 
4076 
4077                 /*
4078                  * Driver must register group->mgi_addmac/remmac() for rx groups
4079                  * to support multiple MAC addresses.
4080                  */
4081                 if (rtype == MAC_RING_TYPE_RX &&
4082                     ((group_info.mgi_addmac == NULL) ||
4083                     (group_info.mgi_remmac == NULL))) {
4084                         err = EINVAL;
4085                         goto bail;
4086                 }
4087 
4088                 /* Cache driver-supplied information */
4089                 group->mrg_info = group_info;
4090 
4091                 /* Update the group's status and group count. */
4092                 mac_set_group_state(group, MAC_GROUP_STATE_REGISTERED);
4093                 group_free++;
4094 
4095                 group->mrg_rings = NULL;
4096                 group->mrg_cur_count = 0;
4097                 mac_init_group(mip, group, group_info.mgi_count, cap_rings);
4098                 ring_left -= group_info.mgi_count;
4099 
4100                 /* The current group size should be equal to default value */
4101                 ASSERT(group->mrg_cur_count == group_info.mgi_count);
4102         }
4103 
4104         /* Build up a dummy group for free resources as a pool */
4105         group = groups + grpcnt;
4106 
4107         /* Prepare basic information of the group */
4108         group->mrg_index = -1;
4109         group->mrg_type = rtype;
4110         group->mrg_state = MAC_GROUP_STATE_UNINIT;
4111         group->mrg_mh = (mac_handle_t)mip;
4112         group->mrg_next = NULL;
4113 
4114         /*
4115          * If there are ungrouped rings, allocate a continuous buffer for
4116          * remaining resources.
4117          */
4118         if (ring_left != 0) {
4119                 group->mrg_rings = NULL;
4120                 group->mrg_cur_count = 0;
4121                 mac_init_group(mip, group, ring_left, cap_rings);
4122 
4123                 /* The current group size should be equal to ring_left */
4124                 ASSERT(group->mrg_cur_count == ring_left);
4125 
4126                 ring_left = 0;
4127 
4128                 /* Update this group's status */
4129                 mac_set_group_state(group, MAC_GROUP_STATE_REGISTERED);
4130         } else
4131                 group->mrg_rings = NULL;
4132 
4133         ASSERT(ring_left == 0);
4134 
4135 bail:
4136 
4137         /* Cache other important information to finalize the initialization */
4138         switch (rtype) {
4139         case MAC_RING_TYPE_RX:
4140                 mip->mi_rx_group_type = cap_rings->mr_group_type;
4141                 mip->mi_rx_group_count = cap_rings->mr_gnum;
4142                 mip->mi_rx_groups = groups;
4143                 mip->mi_rx_donor_grp = groups;
4144                 if (mip->mi_rx_group_type == MAC_GROUP_TYPE_DYNAMIC) {
4145                         /*
4146                          * The default ring is reserved since it is
4147                          * used for sending the broadcast etc. packets.
4148                          */
4149                         mip->mi_rxrings_avail =
4150                             mip->mi_rx_groups->mrg_cur_count - 1;
4151                         mip->mi_rxrings_rsvd = 1;
4152                 }
4153                 /*
4154                  * The default group cannot be reserved. It is used by
4155                  * all the clients that do not have an exclusive group.
4156                  */
4157                 mip->mi_rxhwclnt_avail = mip->mi_rx_group_count - 1;
4158                 mip->mi_rxhwclnt_used = 1;
4159                 break;
4160         case MAC_RING_TYPE_TX:
4161                 mip->mi_tx_group_type = pseudo_txgrp ? MAC_GROUP_TYPE_DYNAMIC :
4162                     cap_rings->mr_group_type;
4163                 mip->mi_tx_group_count = grpcnt;
4164                 mip->mi_tx_group_free = group_free;
4165                 mip->mi_tx_groups = groups;
4166 
4167                 group = groups + grpcnt;
4168                 ring = group->mrg_rings;
4169                 /*
4170                  * The ring can be NULL in the case of aggr. Aggr will
4171                  * have an empty Tx group which will get populated
4172                  * later when pseudo Tx rings are added after
4173                  * mac_register() is done.
4174                  */
4175                 if (ring == NULL) {
4176                         ASSERT(mip->mi_state_flags & MIS_IS_AGGR);
4177                         /*
4178                          * pass the group to aggr so it can add Tx
4179                          * rings to the group later.
4180                          */
4181                         cap_rings->mr_gget(mip->mi_driver, rtype, 0, NULL,
4182                             (mac_group_handle_t)group);
4183                         /*
4184                          * Even though there are no rings at this time
4185                          * (rings will come later), set the group
4186                          * state to registered.
4187                          */
4188                         group->mrg_state = MAC_GROUP_STATE_REGISTERED;
4189                 } else {
4190                         /*
4191                          * Ring 0 is used as the default one and it could be
4192                          * assigned to a client as well.
4193                          */
4194                         while ((ring->mr_index != 0) && (ring->mr_next != NULL))
4195                                 ring = ring->mr_next;
4196                         ASSERT(ring->mr_index == 0);
4197                         mip->mi_default_tx_ring = (mac_ring_handle_t)ring;
4198                 }
4199                 if (mip->mi_tx_group_type == MAC_GROUP_TYPE_DYNAMIC) {
4200                         mip->mi_txrings_avail = group->mrg_cur_count - 1;
4201                         /*
4202                          * The default ring cannot be reserved.
4203                          */
4204                         mip->mi_txrings_rsvd = 1;
4205                 }
4206                 /*
4207                  * The default group cannot be reserved. It will be shared
4208                  * by clients that do not have an exclusive group.
4209                  */
4210                 mip->mi_txhwclnt_avail = mip->mi_tx_group_count;
4211                 mip->mi_txhwclnt_used = 1;
4212                 break;
4213         default:
4214                 ASSERT(B_FALSE);
4215         }
4216 
4217         if (err != 0)
4218                 mac_free_rings(mip, rtype);
4219 
4220         return (err);
4221 }
4222 
4223 /*
4224  * The ddi interrupt handle could be shared amoung rings. If so, compare
4225  * the new ring's ddi handle with the existing ones and set ddi_shared
4226  * flag.
4227  */
4228 void
4229 mac_compare_ddi_handle(mac_group_t *groups, uint_t grpcnt, mac_ring_t *cring)
4230 {
4231         mac_group_t *group;
4232         mac_ring_t *ring;
4233         ddi_intr_handle_t ddi_handle;
4234         int g;
4235 
4236         ddi_handle = cring->mr_info.mri_intr.mi_ddi_handle;
4237         for (g = 0; g < grpcnt; g++) {
4238                 group = groups + g;
4239                 for (ring = group->mrg_rings; ring != NULL;
4240                     ring = ring->mr_next) {
4241                         if (ring == cring)
4242                                 continue;
4243                         if (ring->mr_info.mri_intr.mi_ddi_handle ==
4244                             ddi_handle) {
4245                                 if (cring->mr_type == MAC_RING_TYPE_RX &&
4246                                     ring->mr_index == 0 &&
4247                                     !ring->mr_info.mri_intr.mi_ddi_shared) {
4248                                         ring->mr_info.mri_intr.mi_ddi_shared =
4249                                             B_TRUE;
4250                                 } else {
4251                                         cring->mr_info.mri_intr.mi_ddi_shared =
4252                                             B_TRUE;
4253                                 }
4254                                 return;
4255                         }
4256                 }
4257         }
4258 }
4259 
4260 /*
4261  * Called to free all groups of particular type (RX or TX). It's assumed that
4262  * no clients are using these groups.
4263  */
4264 void
4265 mac_free_rings(mac_impl_t *mip, mac_ring_type_t rtype)
4266 {
4267         mac_group_t *group, *groups;
4268         uint_t group_count;
4269 
4270         switch (rtype) {
4271         case MAC_RING_TYPE_RX:
4272                 if (mip->mi_rx_groups == NULL)
4273                         return;
4274 
4275                 groups = mip->mi_rx_groups;
4276                 group_count = mip->mi_rx_group_count;
4277 
4278                 mip->mi_rx_groups = NULL;
4279                 mip->mi_rx_donor_grp = NULL;
4280                 mip->mi_rx_group_count = 0;
4281                 break;
4282         case MAC_RING_TYPE_TX:
4283                 ASSERT(mip->mi_tx_group_count == mip->mi_tx_group_free);
4284 
4285                 if (mip->mi_tx_groups == NULL)
4286                         return;
4287 
4288                 groups = mip->mi_tx_groups;
4289                 group_count = mip->mi_tx_group_count;
4290 
4291                 mip->mi_tx_groups = NULL;
4292                 mip->mi_tx_group_count = 0;
4293                 mip->mi_tx_group_free = 0;
4294                 mip->mi_default_tx_ring = NULL;
4295                 break;
4296         default:
4297                 ASSERT(B_FALSE);
4298         }
4299 
4300         for (group = groups; group != NULL; group = group->mrg_next) {
4301                 mac_ring_t *ring;
4302 
4303                 if (group->mrg_cur_count == 0)
4304                         continue;
4305 
4306                 ASSERT(group->mrg_rings != NULL);
4307 
4308                 while ((ring = group->mrg_rings) != NULL) {
4309                         group->mrg_rings = ring->mr_next;
4310                         mac_ring_free(mip, ring);
4311                 }
4312         }
4313 
4314         /* Free all the cached rings */
4315         mac_ring_freeall(mip);
4316         /* Free the block of group data strutures */
4317         kmem_free(groups, sizeof (mac_group_t) * (group_count + 1));
4318 }
4319 
4320 /*
4321  * Associate a MAC address with a receive group.
4322  *
4323  * The return value of this function should always be checked properly, because
4324  * any type of failure could cause unexpected results. A group can be added
4325  * or removed with a MAC address only after it has been reserved. Ideally,
4326  * a successful reservation always leads to calling mac_group_addmac() to
4327  * steer desired traffic. Failure of adding an unicast MAC address doesn't
4328  * always imply that the group is functioning abnormally.
4329  *
4330  * Currently this function is called everywhere, and it reflects assumptions
4331  * about MAC addresses in the implementation. CR 6735196.
4332  */
4333 int
4334 mac_group_addmac(mac_group_t *group, const uint8_t *addr)
4335 {
4336         ASSERT(group->mrg_type == MAC_RING_TYPE_RX);
4337         ASSERT(group->mrg_info.mgi_addmac != NULL);
4338 
4339         return (group->mrg_info.mgi_addmac(group->mrg_info.mgi_driver, addr));
4340 }
4341 
4342 /*
4343  * Remove the association between MAC address and receive group.
4344  */
4345 int
4346 mac_group_remmac(mac_group_t *group, const uint8_t *addr)
4347 {
4348         ASSERT(group->mrg_type == MAC_RING_TYPE_RX);
4349         ASSERT(group->mrg_info.mgi_remmac != NULL);
4350 
4351         return (group->mrg_info.mgi_remmac(group->mrg_info.mgi_driver, addr));
4352 }
4353 
4354 /*
4355  * This is the entry point for packets transmitted through the bridging code.
4356  * If no bridge is in place, MAC_RING_TX transmits using tx ring. The 'rh'
4357  * pointer may be NULL to select the default ring.
4358  */
4359 mblk_t *
4360 mac_bridge_tx(mac_impl_t *mip, mac_ring_handle_t rh, mblk_t *mp)
4361 {
4362         mac_handle_t mh;
4363 
4364         /*
4365          * Once we take a reference on the bridge link, the bridge
4366          * module itself can't unload, so the callback pointers are
4367          * stable.
4368          */
4369         mutex_enter(&mip->mi_bridge_lock);
4370         if ((mh = mip->mi_bridge_link) != NULL)
4371                 mac_bridge_ref_cb(mh, B_TRUE);
4372         mutex_exit(&mip->mi_bridge_lock);
4373         if (mh == NULL) {
4374                 MAC_RING_TX(mip, rh, mp, mp);
4375         } else {
4376                 mp = mac_bridge_tx_cb(mh, rh, mp);
4377                 mac_bridge_ref_cb(mh, B_FALSE);
4378         }
4379 
4380         return (mp);
4381 }
4382 
4383 /*
4384  * Find a ring from its index.
4385  */
4386 mac_ring_handle_t
4387 mac_find_ring(mac_group_handle_t gh, int index)
4388 {
4389         mac_group_t *group = (mac_group_t *)gh;
4390         mac_ring_t *ring = group->mrg_rings;
4391 
4392         for (ring = group->mrg_rings; ring != NULL; ring = ring->mr_next)
4393                 if (ring->mr_index == index)
4394                         break;
4395 
4396         return ((mac_ring_handle_t)ring);
4397 }
4398 /*
4399  * Add a ring to an existing group.
4400  *
4401  * The ring must be either passed directly (for example if the ring
4402  * movement is initiated by the framework), or specified through a driver
4403  * index (for example when the ring is added by the driver.
4404  *
4405  * The caller needs to call mac_perim_enter() before calling this function.
4406  */
4407 int
4408 i_mac_group_add_ring(mac_group_t *group, mac_ring_t *ring, int index)
4409 {
4410         mac_impl_t *mip = (mac_impl_t *)group->mrg_mh;
4411         mac_capab_rings_t *cap_rings;
4412         boolean_t driver_call = (ring == NULL);
4413         mac_group_type_t group_type;
4414         int ret = 0;
4415         flow_entry_t *flent;
4416 
4417         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
4418 
4419         switch (group->mrg_type) {
4420         case MAC_RING_TYPE_RX:
4421                 cap_rings = &mip->mi_rx_rings_cap;
4422                 group_type = mip->mi_rx_group_type;
4423                 break;
4424         case MAC_RING_TYPE_TX:
4425                 cap_rings = &mip->mi_tx_rings_cap;
4426                 group_type = mip->mi_tx_group_type;
4427                 break;
4428         default:
4429                 ASSERT(B_FALSE);
4430         }
4431 
4432         /*
4433          * There should be no ring with the same ring index in the target
4434          * group.
4435          */
4436         ASSERT(mac_find_ring((mac_group_handle_t)group,
4437             driver_call ? index : ring->mr_index) == NULL);
4438 
4439         if (driver_call) {
4440                 /*
4441                  * The function is called as a result of a request from
4442                  * a driver to add a ring to an existing group, for example
4443                  * from the aggregation driver. Allocate a new mac_ring_t
4444                  * for that ring.
4445                  */
4446                 ring = mac_init_ring(mip, group, index, cap_rings);
4447                 ASSERT(group->mrg_state > MAC_GROUP_STATE_UNINIT);
4448         } else {
4449                 /*
4450                  * The function is called as a result of a MAC layer request
4451                  * to add a ring to an existing group. In this case the
4452                  * ring is being moved between groups, which requires
4453                  * the underlying driver to support dynamic grouping,
4454                  * and the mac_ring_t already exists.
4455                  */
4456                 ASSERT(group_type == MAC_GROUP_TYPE_DYNAMIC);
4457                 ASSERT(group->mrg_driver == NULL ||
4458                     cap_rings->mr_gaddring != NULL);
4459                 ASSERT(ring->mr_gh == NULL);
4460         }
4461 
4462         /*
4463          * At this point the ring should not be in use, and it should be
4464          * of the right for the target group.
4465          */
4466         ASSERT(ring->mr_state < MR_INUSE);
4467         ASSERT(ring->mr_srs == NULL);
4468         ASSERT(ring->mr_type == group->mrg_type);
4469 
4470         if (!driver_call) {
4471                 /*
4472                  * Add the driver level hardware ring if the process was not
4473                  * initiated by the driver, and the target group is not the
4474                  * group.
4475                  */
4476                 if (group->mrg_driver != NULL) {
4477                         cap_rings->mr_gaddring(group->mrg_driver,
4478                             ring->mr_driver, ring->mr_type);
4479                 }
4480 
4481                 /*
4482                  * Insert the ring ahead existing rings.
4483                  */
4484                 ring->mr_next = group->mrg_rings;
4485                 group->mrg_rings = ring;
4486                 ring->mr_gh = (mac_group_handle_t)group;
4487                 group->mrg_cur_count++;
4488         }
4489 
4490         /*
4491          * If the group has not been actively used, we're done.
4492          */
4493         if (group->mrg_index != -1 &&
4494             group->mrg_state < MAC_GROUP_STATE_RESERVED)
4495                 return (0);
4496 
4497         /*
4498          * Start the ring if needed. Failure causes to undo the grouping action.
4499          */
4500         if (ring->mr_state != MR_INUSE) {
4501                 if ((ret = mac_start_ring(ring)) != 0) {
4502                         if (!driver_call) {
4503                                 cap_rings->mr_gremring(group->mrg_driver,
4504                                     ring->mr_driver, ring->mr_type);
4505                         }
4506                         group->mrg_cur_count--;
4507                         group->mrg_rings = ring->mr_next;
4508 
4509                         ring->mr_gh = NULL;
4510 
4511                         if (driver_call)
4512                                 mac_ring_free(mip, ring);
4513 
4514                         return (ret);
4515                 }
4516         }
4517 
4518         /*
4519          * Set up SRS/SR according to the ring type.
4520          */
4521         switch (ring->mr_type) {
4522         case MAC_RING_TYPE_RX:
4523                 /*
4524                  * Setup SRS on top of the new ring if the group is
4525                  * reserved for someones exclusive use.
4526                  */
4527                 if (group->mrg_state == MAC_GROUP_STATE_RESERVED) {
4528                         mac_client_impl_t *mcip;
4529 
4530                         mcip = MAC_GROUP_ONLY_CLIENT(group);
4531                         /*
4532                          * Even though this group is reserved we migth still
4533                          * have multiple clients, i.e a VLAN shares the
4534                          * group with the primary mac client.
4535                          */
4536                         if (mcip != NULL) {
4537                                 flent = mcip->mci_flent;
4538                                 ASSERT(flent->fe_rx_srs_cnt > 0);
4539                                 mac_rx_srs_group_setup(mcip, flent, SRST_LINK);
4540                                 mac_fanout_setup(mcip, flent,
4541                                     MCIP_RESOURCE_PROPS(mcip), mac_rx_deliver,
4542                                     mcip, NULL, NULL);
4543                         } else {
4544                                 ring->mr_classify_type = MAC_SW_CLASSIFIER;
4545                         }
4546                 }
4547                 break;
4548         case MAC_RING_TYPE_TX:
4549         {
4550                 mac_grp_client_t        *mgcp = group->mrg_clients;
4551                 mac_client_impl_t       *mcip;
4552                 mac_soft_ring_set_t     *mac_srs;
4553                 mac_srs_tx_t            *tx;
4554 
4555                 if (MAC_GROUP_NO_CLIENT(group)) {
4556                         if (ring->mr_state == MR_INUSE)
4557                                 mac_stop_ring(ring);
4558                         ring->mr_flag = 0;
4559                         break;
4560                 }
4561                 /*
4562                  * If the rings are being moved to a group that has
4563                  * clients using it, then add the new rings to the
4564                  * clients SRS.
4565                  */
4566                 while (mgcp != NULL) {
4567                         boolean_t       is_aggr;
4568 
4569                         mcip = mgcp->mgc_client;
4570                         flent = mcip->mci_flent;
4571                         is_aggr = (mcip->mci_state_flags & MCIS_IS_AGGR);
4572                         mac_srs = MCIP_TX_SRS(mcip);
4573                         tx = &mac_srs->srs_tx;
4574                         mac_tx_client_quiesce((mac_client_handle_t)mcip);
4575                         /*
4576                          * If we are  growing from 1 to multiple rings.
4577                          */
4578                         if (tx->st_mode == SRS_TX_BW ||
4579                             tx->st_mode == SRS_TX_SERIALIZE ||
4580                             tx->st_mode == SRS_TX_DEFAULT) {
4581                                 mac_ring_t      *tx_ring = tx->st_arg2;
4582 
4583                                 tx->st_arg2 = NULL;
4584                                 mac_tx_srs_stat_recreate(mac_srs, B_TRUE);
4585                                 mac_tx_srs_add_ring(mac_srs, tx_ring);
4586                                 if (mac_srs->srs_type & SRST_BW_CONTROL) {
4587                                         tx->st_mode = is_aggr ? SRS_TX_BW_AGGR :
4588                                             SRS_TX_BW_FANOUT;
4589                                 } else {
4590                                         tx->st_mode = is_aggr ? SRS_TX_AGGR :
4591                                             SRS_TX_FANOUT;
4592                                 }
4593                                 tx->st_func = mac_tx_get_func(tx->st_mode);
4594                         }
4595                         mac_tx_srs_add_ring(mac_srs, ring);
4596                         mac_fanout_setup(mcip, flent, MCIP_RESOURCE_PROPS(mcip),
4597                             mac_rx_deliver, mcip, NULL, NULL);
4598                         mac_tx_client_restart((mac_client_handle_t)mcip);
4599                         mgcp = mgcp->mgc_next;
4600                 }
4601                 break;
4602         }
4603         default:
4604                 ASSERT(B_FALSE);
4605         }
4606         /*
4607          * For aggr, the default ring will be NULL to begin with. If it
4608          * is NULL, then pick the first ring that gets added as the
4609          * default ring. Any ring in an aggregation can be removed at
4610          * any time (by the user action of removing a link) and if the
4611          * current default ring gets removed, then a new one gets
4612          * picked (see i_mac_group_rem_ring()).
4613          */
4614         if (mip->mi_state_flags & MIS_IS_AGGR &&
4615             mip->mi_default_tx_ring == NULL &&
4616             ring->mr_type == MAC_RING_TYPE_TX) {
4617                 mip->mi_default_tx_ring = (mac_ring_handle_t)ring;
4618         }
4619 
4620         MAC_RING_UNMARK(ring, MR_INCIPIENT);
4621         return (0);
4622 }
4623 
4624 /*
4625  * Remove a ring from it's current group. MAC internal function for dynamic
4626  * grouping.
4627  *
4628  * The caller needs to call mac_perim_enter() before calling this function.
4629  */
4630 void
4631 i_mac_group_rem_ring(mac_group_t *group, mac_ring_t *ring,
4632     boolean_t driver_call)
4633 {
4634         mac_impl_t *mip = (mac_impl_t *)group->mrg_mh;
4635         mac_capab_rings_t *cap_rings = NULL;
4636         mac_group_type_t group_type;
4637 
4638         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
4639 
4640         ASSERT(mac_find_ring((mac_group_handle_t)group,
4641             ring->mr_index) == (mac_ring_handle_t)ring);
4642         ASSERT((mac_group_t *)ring->mr_gh == group);
4643         ASSERT(ring->mr_type == group->mrg_type);
4644 
4645         if (ring->mr_state == MR_INUSE)
4646                 mac_stop_ring(ring);
4647         switch (ring->mr_type) {
4648         case MAC_RING_TYPE_RX:
4649                 group_type = mip->mi_rx_group_type;
4650                 cap_rings = &mip->mi_rx_rings_cap;
4651 
4652                 /*
4653                  * Only hardware classified packets hold a reference to the
4654                  * ring all the way up the Rx path. mac_rx_srs_remove()
4655                  * will take care of quiescing the Rx path and removing the
4656                  * SRS. The software classified path neither holds a reference
4657                  * nor any association with the ring in mac_rx.
4658                  */
4659                 if (ring->mr_srs != NULL) {
4660                         mac_rx_srs_remove(ring->mr_srs);
4661                         ring->mr_srs = NULL;
4662                 }
4663 
4664                 break;
4665         case MAC_RING_TYPE_TX:
4666         {
4667                 mac_grp_client_t        *mgcp;
4668                 mac_client_impl_t       *mcip;
4669                 mac_soft_ring_set_t     *mac_srs;
4670                 mac_srs_tx_t            *tx;
4671                 mac_ring_t              *rem_ring;
4672                 mac_group_t             *defgrp;
4673                 uint_t                  ring_info = 0;
4674 
4675                 /*
4676                  * For TX this function is invoked in three
4677                  * cases:
4678                  *
4679                  * 1) In the case of a failure during the
4680                  * initial creation of a group when a share is
4681                  * associated with a MAC client. So the SRS is not
4682                  * yet setup, and will be setup later after the
4683                  * group has been reserved and populated.
4684                  *
4685                  * 2) From mac_release_tx_group() when freeing
4686                  * a TX SRS.
4687                  *
4688                  * 3) In the case of aggr, when a port gets removed,
4689                  * the pseudo Tx rings that it exposed gets removed.
4690                  *
4691                  * In the first two cases the SRS and its soft
4692                  * rings are already quiesced.
4693                  */
4694                 if (driver_call) {
4695                         mac_client_impl_t *mcip;
4696                         mac_soft_ring_set_t *mac_srs;
4697                         mac_soft_ring_t *sringp;
4698                         mac_srs_tx_t *srs_tx;
4699 
4700                         if (mip->mi_state_flags & MIS_IS_AGGR &&
4701                             mip->mi_default_tx_ring ==
4702                             (mac_ring_handle_t)ring) {
4703                                 /* pick a new default Tx ring */
4704                                 mip->mi_default_tx_ring =
4705                                     (group->mrg_rings != ring) ?
4706                                     (mac_ring_handle_t)group->mrg_rings :
4707                                     (mac_ring_handle_t)(ring->mr_next);
4708                         }
4709                         /* Presently only aggr case comes here */
4710                         if (group->mrg_state != MAC_GROUP_STATE_RESERVED)
4711                                 break;
4712 
4713                         mcip = MAC_GROUP_ONLY_CLIENT(group);
4714                         ASSERT(mcip != NULL);
4715                         ASSERT(mcip->mci_state_flags & MCIS_IS_AGGR);
4716                         mac_srs = MCIP_TX_SRS(mcip);
4717                         ASSERT(mac_srs->srs_tx.st_mode == SRS_TX_AGGR ||
4718                             mac_srs->srs_tx.st_mode == SRS_TX_BW_AGGR);
4719                         srs_tx = &mac_srs->srs_tx;
4720                         /*
4721                          * Wakeup any callers blocked on this
4722                          * Tx ring due to flow control.
4723                          */
4724                         sringp = srs_tx->st_soft_rings[ring->mr_index];
4725                         ASSERT(sringp != NULL);
4726                         mac_tx_invoke_callbacks(mcip, (mac_tx_cookie_t)sringp);
4727                         mac_tx_client_quiesce((mac_client_handle_t)mcip);
4728                         mac_tx_srs_del_ring(mac_srs, ring);
4729                         mac_tx_client_restart((mac_client_handle_t)mcip);
4730                         break;
4731                 }
4732                 ASSERT(ring != (mac_ring_t *)mip->mi_default_tx_ring);
4733                 group_type = mip->mi_tx_group_type;
4734                 cap_rings = &mip->mi_tx_rings_cap;
4735                 /*
4736                  * See if we need to take it out of the MAC clients using
4737                  * this group
4738                  */
4739                 if (MAC_GROUP_NO_CLIENT(group))
4740                         break;
4741                 mgcp = group->mrg_clients;
4742                 defgrp = MAC_DEFAULT_TX_GROUP(mip);
4743                 while (mgcp != NULL) {
4744                         mcip = mgcp->mgc_client;
4745                         mac_srs = MCIP_TX_SRS(mcip);
4746                         tx = &mac_srs->srs_tx;
4747                         mac_tx_client_quiesce((mac_client_handle_t)mcip);
4748                         /*
4749                          * If we are here when removing rings from the
4750                          * defgroup, mac_reserve_tx_ring would have
4751                          * already deleted the ring from the MAC
4752                          * clients in the group.
4753                          */
4754                         if (group != defgrp) {
4755                                 mac_tx_invoke_callbacks(mcip,
4756                                     (mac_tx_cookie_t)
4757                                     mac_tx_srs_get_soft_ring(mac_srs, ring));
4758                                 mac_tx_srs_del_ring(mac_srs, ring);
4759                         }
4760                         /*
4761                          * Additionally, if  we are left with only
4762                          * one ring in the group after this, we need
4763                          * to modify the mode etc. to. (We haven't
4764                          * yet taken the ring out, so we check with 2).
4765                          */
4766                         if (group->mrg_cur_count == 2) {
4767                                 if (ring->mr_next == NULL)
4768                                         rem_ring = group->mrg_rings;
4769                                 else
4770                                         rem_ring = ring->mr_next;
4771                                 mac_tx_invoke_callbacks(mcip,
4772                                     (mac_tx_cookie_t)
4773                                     mac_tx_srs_get_soft_ring(mac_srs,
4774                                     rem_ring));
4775                                 mac_tx_srs_del_ring(mac_srs, rem_ring);
4776                                 if (rem_ring->mr_state != MR_INUSE) {
4777                                         (void) mac_start_ring(rem_ring);
4778                                 }
4779                                 tx->st_arg2 = (void *)rem_ring;
4780                                 mac_tx_srs_stat_recreate(mac_srs, B_FALSE);
4781                                 ring_info = mac_hwring_getinfo(
4782                                     (mac_ring_handle_t)rem_ring);
4783                                 /*
4784                                  * We are  shrinking from multiple
4785                                  * to 1 ring.
4786                                  */
4787                                 if (mac_srs->srs_type & SRST_BW_CONTROL) {
4788                                         tx->st_mode = SRS_TX_BW;
4789                                 } else if (mac_tx_serialize ||
4790                                     (ring_info & MAC_RING_TX_SERIALIZE)) {
4791                                         tx->st_mode = SRS_TX_SERIALIZE;
4792                                 } else {
4793                                         tx->st_mode = SRS_TX_DEFAULT;
4794                                 }
4795                                 tx->st_func = mac_tx_get_func(tx->st_mode);
4796                         }
4797                         mac_tx_client_restart((mac_client_handle_t)mcip);
4798                         mgcp = mgcp->mgc_next;
4799                 }
4800                 break;
4801         }
4802         default:
4803                 ASSERT(B_FALSE);
4804         }
4805 
4806         /*
4807          * Remove the ring from the group.
4808          */
4809         if (ring == group->mrg_rings)
4810                 group->mrg_rings = ring->mr_next;
4811         else {
4812                 mac_ring_t *pre;
4813 
4814                 pre = group->mrg_rings;
4815                 while (pre->mr_next != ring)
4816                         pre = pre->mr_next;
4817                 pre->mr_next = ring->mr_next;
4818         }
4819         group->mrg_cur_count--;
4820 
4821         if (!driver_call) {
4822                 ASSERT(group_type == MAC_GROUP_TYPE_DYNAMIC);
4823                 ASSERT(group->mrg_driver == NULL ||
4824                     cap_rings->mr_gremring != NULL);
4825 
4826                 /*
4827                  * Remove the driver level hardware ring.
4828                  */
4829                 if (group->mrg_driver != NULL) {
4830                         cap_rings->mr_gremring(group->mrg_driver,
4831                             ring->mr_driver, ring->mr_type);
4832                 }
4833         }
4834 
4835         ring->mr_gh = NULL;
4836         if (driver_call)
4837                 mac_ring_free(mip, ring);
4838         else
4839                 ring->mr_flag = 0;
4840 }
4841 
4842 /*
4843  * Move a ring to the target group. If needed, remove the ring from the group
4844  * that it currently belongs to.
4845  *
4846  * The caller need to enter MAC's perimeter by calling mac_perim_enter().
4847  */
4848 static int
4849 mac_group_mov_ring(mac_impl_t *mip, mac_group_t *d_group, mac_ring_t *ring)
4850 {
4851         mac_group_t *s_group = (mac_group_t *)ring->mr_gh;
4852         int rv;
4853 
4854         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
4855         ASSERT(d_group != NULL);
4856         ASSERT(s_group->mrg_mh == d_group->mrg_mh);
4857 
4858         if (s_group == d_group)
4859                 return (0);
4860 
4861         /*
4862          * Remove it from current group first.
4863          */
4864         if (s_group != NULL)
4865                 i_mac_group_rem_ring(s_group, ring, B_FALSE);
4866 
4867         /*
4868          * Add it to the new group.
4869          */
4870         rv = i_mac_group_add_ring(d_group, ring, 0);
4871         if (rv != 0) {
4872                 /*
4873                  * Failed to add ring back to source group. If
4874                  * that fails, the ring is stuck in limbo, log message.
4875                  */
4876                 if (i_mac_group_add_ring(s_group, ring, 0)) {
4877                         cmn_err(CE_WARN, "%s: failed to move ring %p\n",
4878                             mip->mi_name, (void *)ring);
4879                 }
4880         }
4881 
4882         return (rv);
4883 }
4884 
4885 /*
4886  * Find a MAC address according to its value.
4887  */
4888 mac_address_t *
4889 mac_find_macaddr(mac_impl_t *mip, uint8_t *mac_addr)
4890 {
4891         mac_address_t *map;
4892 
4893         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
4894 
4895         for (map = mip->mi_addresses; map != NULL; map = map->ma_next) {
4896                 if (bcmp(mac_addr, map->ma_addr, map->ma_len) == 0)
4897                         break;
4898         }
4899 
4900         return (map);
4901 }
4902 
4903 /*
4904  * Check whether the MAC address is shared by multiple clients.
4905  */
4906 boolean_t
4907 mac_check_macaddr_shared(mac_address_t *map)
4908 {
4909         ASSERT(MAC_PERIM_HELD((mac_handle_t)map->ma_mip));
4910 
4911         return (map->ma_nusers > 1);
4912 }
4913 
4914 /*
4915  * Remove the specified MAC address from the MAC address list and free it.
4916  */
4917 static void
4918 mac_free_macaddr(mac_address_t *map)
4919 {
4920         mac_impl_t *mip = map->ma_mip;
4921 
4922         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
4923         ASSERT(mip->mi_addresses != NULL);
4924 
4925         map = mac_find_macaddr(mip, map->ma_addr);
4926 
4927         ASSERT(map != NULL);
4928         ASSERT(map->ma_nusers == 0);
4929 
4930         if (map == mip->mi_addresses) {
4931                 mip->mi_addresses = map->ma_next;
4932         } else {
4933                 mac_address_t *pre;
4934 
4935                 pre = mip->mi_addresses;
4936                 while (pre->ma_next != map)
4937                         pre = pre->ma_next;
4938                 pre->ma_next = map->ma_next;
4939         }
4940 
4941         kmem_free(map, sizeof (mac_address_t));
4942 }
4943 
4944 /*
4945  * Add a MAC address reference for a client. If the desired MAC address
4946  * exists, add a reference to it. Otherwise, add the new address by adding
4947  * it to a reserved group or setting promiscuous mode. Won't try different
4948  * group is the group is non-NULL, so the caller must explictly share
4949  * default group when needed.
4950  *
4951  * Note, the primary MAC address is initialized at registration time, so
4952  * to add it to default group only need to activate it if its reference
4953  * count is still zero. Also, some drivers may not have advertised RINGS
4954  * capability.
4955  */
4956 int
4957 mac_add_macaddr(mac_impl_t *mip, mac_group_t *group, uint8_t *mac_addr,
4958     boolean_t use_hw)
4959 {
4960         mac_address_t *map;
4961         int err = 0;
4962         boolean_t allocated_map = B_FALSE;
4963 
4964         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
4965 
4966         map = mac_find_macaddr(mip, mac_addr);
4967 
4968         /*
4969          * If the new MAC address has not been added. Allocate a new one
4970          * and set it up.
4971          */
4972         if (map == NULL) {
4973                 map = kmem_zalloc(sizeof (mac_address_t), KM_SLEEP);
4974                 map->ma_len = mip->mi_type->mt_addr_length;
4975                 bcopy(mac_addr, map->ma_addr, map->ma_len);
4976                 map->ma_nusers = 0;
4977                 map->ma_group = group;
4978                 map->ma_mip = mip;
4979 
4980                 /* add the new MAC address to the head of the address list */
4981                 map->ma_next = mip->mi_addresses;
4982                 mip->mi_addresses = map;
4983 
4984                 allocated_map = B_TRUE;
4985         }
4986 
4987         ASSERT(map->ma_group == NULL || map->ma_group == group);
4988         if (map->ma_group == NULL)
4989                 map->ma_group = group;
4990 
4991         /*
4992          * If the MAC address is already in use, simply account for the
4993          * new client.
4994          */
4995         if (map->ma_nusers++ > 0)
4996                 return (0);
4997 
4998         /*
4999          * Activate this MAC address by adding it to the reserved group.
5000          */
5001         if (group != NULL) {
5002                 err = mac_group_addmac(group, (const uint8_t *)mac_addr);
5003                 if (err == 0) {
5004                         map->ma_type = MAC_ADDRESS_TYPE_UNICAST_CLASSIFIED;
5005                         return (0);
5006                 }
5007         }
5008 
5009         /*
5010          * The MAC address addition failed. If the client requires a
5011          * hardware classified MAC address, fail the operation.
5012          */
5013         if (use_hw) {
5014                 err = ENOSPC;
5015                 goto bail;
5016         }
5017 
5018         /*
5019          * Try promiscuous mode.
5020          *
5021          * For drivers that don't advertise RINGS capability, do
5022          * nothing for the primary address.
5023          */
5024         if ((group == NULL) &&
5025             (bcmp(map->ma_addr, mip->mi_addr, map->ma_len) == 0)) {
5026                 map->ma_type = MAC_ADDRESS_TYPE_UNICAST_CLASSIFIED;
5027                 return (0);
5028         }
5029 
5030         /*
5031          * Enable promiscuous mode in order to receive traffic
5032          * to the new MAC address.
5033          */
5034         if ((err = i_mac_promisc_set(mip, B_TRUE)) == 0) {
5035                 map->ma_type = MAC_ADDRESS_TYPE_UNICAST_PROMISC;
5036                 return (0);
5037         }
5038 
5039         /*
5040          * Free the MAC address that could not be added. Don't free
5041          * a pre-existing address, it could have been the entry
5042          * for the primary MAC address which was pre-allocated by
5043          * mac_init_macaddr(), and which must remain on the list.
5044          */
5045 bail:
5046         map->ma_nusers--;
5047         if (allocated_map)
5048                 mac_free_macaddr(map);
5049         return (err);
5050 }
5051 
5052 /*
5053  * Remove a reference to a MAC address. This may cause to remove the MAC
5054  * address from an associated group or to turn off promiscuous mode.
5055  * The caller needs to handle the failure properly.
5056  */
5057 int
5058 mac_remove_macaddr(mac_address_t *map)
5059 {
5060         mac_impl_t *mip = map->ma_mip;
5061         int err = 0;
5062 
5063         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
5064 
5065         ASSERT(map == mac_find_macaddr(mip, map->ma_addr));
5066 
5067         /*
5068          * If it's not the last client using this MAC address, only update
5069          * the MAC clients count.
5070          */
5071         if (--map->ma_nusers > 0)
5072                 return (0);
5073 
5074         /*
5075          * The MAC address is no longer used by any MAC client, so remove
5076          * it from its associated group, or turn off promiscuous mode
5077          * if it was enabled for the MAC address.
5078          */
5079         switch (map->ma_type) {
5080         case MAC_ADDRESS_TYPE_UNICAST_CLASSIFIED:
5081                 /*
5082                  * Don't free the preset primary address for drivers that
5083                  * don't advertise RINGS capability.
5084                  */
5085                 if (map->ma_group == NULL)
5086                         return (0);
5087 
5088                 err = mac_group_remmac(map->ma_group, map->ma_addr);
5089                 if (err == 0)
5090                         map->ma_group = NULL;
5091                 break;
5092         case MAC_ADDRESS_TYPE_UNICAST_PROMISC:
5093                 err = i_mac_promisc_set(mip, B_FALSE);
5094                 break;
5095         default:
5096                 ASSERT(B_FALSE);
5097         }
5098 
5099         if (err != 0)
5100                 return (err);
5101 
5102         /*
5103          * We created MAC address for the primary one at registration, so we
5104          * won't free it here. mac_fini_macaddr() will take care of it.
5105          */
5106         if (bcmp(map->ma_addr, mip->mi_addr, map->ma_len) != 0)
5107                 mac_free_macaddr(map);
5108 
5109         return (0);
5110 }
5111 
5112 /*
5113  * Update an existing MAC address. The caller need to make sure that the new
5114  * value has not been used.
5115  */
5116 int
5117 mac_update_macaddr(mac_address_t *map, uint8_t *mac_addr)
5118 {
5119         mac_impl_t *mip = map->ma_mip;
5120         int err = 0;
5121 
5122         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
5123         ASSERT(mac_find_macaddr(mip, mac_addr) == NULL);
5124 
5125         switch (map->ma_type) {
5126         case MAC_ADDRESS_TYPE_UNICAST_CLASSIFIED:
5127                 /*
5128                  * Update the primary address for drivers that are not
5129                  * RINGS capable.
5130                  */
5131                 if (mip->mi_rx_groups == NULL) {
5132                         err = mip->mi_unicst(mip->mi_driver, (const uint8_t *)
5133                             mac_addr);
5134                         if (err != 0)
5135                                 return (err);
5136                         break;
5137                 }
5138 
5139                 /*
5140                  * If this MAC address is not currently in use,
5141                  * simply break out and update the value.
5142                  */
5143                 if (map->ma_nusers == 0)
5144                         break;
5145 
5146                 /*
5147                  * Need to replace the MAC address associated with a group.
5148                  */
5149                 err = mac_group_remmac(map->ma_group, map->ma_addr);
5150                 if (err != 0)
5151                         return (err);
5152 
5153                 err = mac_group_addmac(map->ma_group, mac_addr);
5154 
5155                 /*
5156                  * Failure hints hardware error. The MAC layer needs to
5157                  * have error notification facility to handle this.
5158                  * Now, simply try to restore the value.
5159                  */
5160                 if (err != 0)
5161                         (void) mac_group_addmac(map->ma_group, map->ma_addr);
5162 
5163                 break;
5164         case MAC_ADDRESS_TYPE_UNICAST_PROMISC:
5165                 /*
5166                  * Need to do nothing more if in promiscuous mode.
5167                  */
5168                 break;
5169         default:
5170                 ASSERT(B_FALSE);
5171         }
5172 
5173         /*
5174          * Successfully replaced the MAC address.
5175          */
5176         if (err == 0)
5177                 bcopy(mac_addr, map->ma_addr, map->ma_len);
5178 
5179         return (err);
5180 }
5181 
5182 /*
5183  * Freshen the MAC address with new value. Its caller must have updated the
5184  * hardware MAC address before calling this function.
5185  * This funcitons is supposed to be used to handle the MAC address change
5186  * notification from underlying drivers.
5187  */
5188 void
5189 mac_freshen_macaddr(mac_address_t *map, uint8_t *mac_addr)
5190 {
5191         mac_impl_t *mip = map->ma_mip;
5192 
5193         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
5194         ASSERT(mac_find_macaddr(mip, mac_addr) == NULL);
5195 
5196         /*
5197          * Freshen the MAC address with new value.
5198          */
5199         bcopy(mac_addr, map->ma_addr, map->ma_len);
5200         bcopy(mac_addr, mip->mi_addr, map->ma_len);
5201 
5202         /*
5203          * Update all MAC clients that share this MAC address.
5204          */
5205         mac_unicast_update_clients(mip, map);
5206 }
5207 
5208 /*
5209  * Set up the primary MAC address.
5210  */
5211 void
5212 mac_init_macaddr(mac_impl_t *mip)
5213 {
5214         mac_address_t *map;
5215 
5216         /*
5217          * The reference count is initialized to zero, until it's really
5218          * activated.
5219          */
5220         map = kmem_zalloc(sizeof (mac_address_t), KM_SLEEP);
5221         map->ma_len = mip->mi_type->mt_addr_length;
5222         bcopy(mip->mi_addr, map->ma_addr, map->ma_len);
5223 
5224         /*
5225          * If driver advertises RINGS capability, it shouldn't have initialized
5226          * its primary MAC address. For other drivers, including VNIC, the
5227          * primary address must work after registration.
5228          */
5229         if (mip->mi_rx_groups == NULL)
5230                 map->ma_type = MAC_ADDRESS_TYPE_UNICAST_CLASSIFIED;
5231 
5232         map->ma_mip = mip;
5233 
5234         mip->mi_addresses = map;
5235 }
5236 
5237 /*
5238  * Clean up the primary MAC address. Note, only one primary MAC address
5239  * is allowed. All other MAC addresses must have been freed appropriately.
5240  */
5241 void
5242 mac_fini_macaddr(mac_impl_t *mip)
5243 {
5244         mac_address_t *map = mip->mi_addresses;
5245 
5246         if (map == NULL)
5247                 return;
5248 
5249         /*
5250          * If mi_addresses is initialized, there should be exactly one
5251          * entry left on the list with no users.
5252          */
5253         ASSERT(map->ma_nusers == 0);
5254         ASSERT(map->ma_next == NULL);
5255 
5256         kmem_free(map, sizeof (mac_address_t));
5257         mip->mi_addresses = NULL;
5258 }
5259 
5260 /*
5261  * Logging related functions.
5262  *
5263  * Note that Kernel statistics have been extended to maintain fine
5264  * granularity of statistics viz. hardware lane, software lane, fanout
5265  * stats etc. However, extended accounting continues to support only
5266  * aggregate statistics like before.
5267  */
5268 
5269 /* Write the flow description to a netinfo_t record */
5270 static netinfo_t *
5271 mac_write_flow_desc(flow_entry_t *flent, mac_client_impl_t *mcip)
5272 {
5273         netinfo_t               *ninfo;
5274         net_desc_t              *ndesc;
5275         flow_desc_t             *fdesc;
5276         mac_resource_props_t    *mrp;
5277 
5278         ninfo = kmem_zalloc(sizeof (netinfo_t), KM_NOSLEEP);
5279         if (ninfo == NULL)
5280                 return (NULL);
5281         ndesc = kmem_zalloc(sizeof (net_desc_t), KM_NOSLEEP);
5282         if (ndesc == NULL) {
5283                 kmem_free(ninfo, sizeof (netinfo_t));
5284                 return (NULL);
5285         }
5286 
5287         /*
5288          * Grab the fe_lock to see a self-consistent fe_flow_desc.
5289          * Updates to the fe_flow_desc are done under the fe_lock
5290          */
5291         mutex_enter(&flent->fe_lock);
5292         fdesc = &flent->fe_flow_desc;
5293         mrp = &flent->fe_resource_props;
5294 
5295         ndesc->nd_name = flent->fe_flow_name;
5296         ndesc->nd_devname = mcip->mci_name;
5297         bcopy(fdesc->fd_src_mac, ndesc->nd_ehost, ETHERADDRL);
5298         bcopy(fdesc->fd_dst_mac, ndesc->nd_edest, ETHERADDRL);
5299         ndesc->nd_sap = htonl(fdesc->fd_sap);
5300         ndesc->nd_isv4 = (uint8_t)fdesc->fd_ipversion == IPV4_VERSION;
5301         ndesc->nd_bw_limit = mrp->mrp_maxbw;
5302         if (ndesc->nd_isv4) {
5303                 ndesc->nd_saddr[3] = htonl(fdesc->fd_local_addr.s6_addr32[3]);
5304                 ndesc->nd_daddr[3] = htonl(fdesc->fd_remote_addr.s6_addr32[3]);
5305         } else {
5306                 bcopy(&fdesc->fd_local_addr, ndesc->nd_saddr, IPV6_ADDR_LEN);
5307                 bcopy(&fdesc->fd_remote_addr, ndesc->nd_daddr, IPV6_ADDR_LEN);
5308         }
5309         ndesc->nd_sport = htons(fdesc->fd_local_port);
5310         ndesc->nd_dport = htons(fdesc->fd_remote_port);
5311         ndesc->nd_protocol = (uint8_t)fdesc->fd_protocol;
5312         mutex_exit(&flent->fe_lock);
5313 
5314         ninfo->ni_record = ndesc;
5315         ninfo->ni_size = sizeof (net_desc_t);
5316         ninfo->ni_type = EX_NET_FLDESC_REC;
5317 
5318         return (ninfo);
5319 }
5320 
5321 /* Write the flow statistics to a netinfo_t record */
5322 static netinfo_t *
5323 mac_write_flow_stats(flow_entry_t *flent)
5324 {
5325         netinfo_t               *ninfo;
5326         net_stat_t              *nstat;
5327         mac_soft_ring_set_t     *mac_srs;
5328         mac_rx_stats_t          *mac_rx_stat;
5329         mac_tx_stats_t          *mac_tx_stat;
5330         int                     i;
5331 
5332         ninfo = kmem_zalloc(sizeof (netinfo_t), KM_NOSLEEP);
5333         if (ninfo == NULL)
5334                 return (NULL);
5335         nstat = kmem_zalloc(sizeof (net_stat_t), KM_NOSLEEP);
5336         if (nstat == NULL) {
5337                 kmem_free(ninfo, sizeof (netinfo_t));
5338                 return (NULL);
5339         }
5340 
5341         nstat->ns_name = flent->fe_flow_name;
5342         for (i = 0; i < flent->fe_rx_srs_cnt; i++) {
5343                 mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i];
5344                 mac_rx_stat = &mac_srs->srs_rx.sr_stat;
5345 
5346                 nstat->ns_ibytes += mac_rx_stat->mrs_intrbytes +
5347                     mac_rx_stat->mrs_pollbytes + mac_rx_stat->mrs_lclbytes;
5348                 nstat->ns_ipackets += mac_rx_stat->mrs_intrcnt +
5349                     mac_rx_stat->mrs_pollcnt + mac_rx_stat->mrs_lclcnt;
5350                 nstat->ns_oerrors += mac_rx_stat->mrs_ierrors;
5351         }
5352 
5353         mac_srs = (mac_soft_ring_set_t *)(flent->fe_tx_srs);
5354         if (mac_srs != NULL) {
5355                 mac_tx_stat = &mac_srs->srs_tx.st_stat;
5356 
5357                 nstat->ns_obytes = mac_tx_stat->mts_obytes;
5358                 nstat->ns_opackets = mac_tx_stat->mts_opackets;
5359                 nstat->ns_oerrors = mac_tx_stat->mts_oerrors;
5360         }
5361 
5362         ninfo->ni_record = nstat;
5363         ninfo->ni_size = sizeof (net_stat_t);
5364         ninfo->ni_type = EX_NET_FLSTAT_REC;
5365 
5366         return (ninfo);
5367 }
5368 
5369 /* Write the link description to a netinfo_t record */
5370 static netinfo_t *
5371 mac_write_link_desc(mac_client_impl_t *mcip)
5372 {
5373         netinfo_t               *ninfo;
5374         net_desc_t              *ndesc;
5375         flow_entry_t            *flent = mcip->mci_flent;
5376 
5377         ninfo = kmem_zalloc(sizeof (netinfo_t), KM_NOSLEEP);
5378         if (ninfo == NULL)
5379                 return (NULL);
5380         ndesc = kmem_zalloc(sizeof (net_desc_t), KM_NOSLEEP);
5381         if (ndesc == NULL) {
5382                 kmem_free(ninfo, sizeof (netinfo_t));
5383                 return (NULL);
5384         }
5385 
5386         ndesc->nd_name = mcip->mci_name;
5387         ndesc->nd_devname = mcip->mci_name;
5388         ndesc->nd_isv4 = B_TRUE;
5389         /*
5390          * Grab the fe_lock to see a self-consistent fe_flow_desc.
5391          * Updates to the fe_flow_desc are done under the fe_lock
5392          * after removing the flent from the flow table.
5393          */
5394         mutex_enter(&flent->fe_lock);
5395         bcopy(flent->fe_flow_desc.fd_src_mac, ndesc->nd_ehost, ETHERADDRL);
5396         mutex_exit(&flent->fe_lock);
5397 
5398         ninfo->ni_record = ndesc;
5399         ninfo->ni_size = sizeof (net_desc_t);
5400         ninfo->ni_type = EX_NET_LNDESC_REC;
5401 
5402         return (ninfo);
5403 }
5404 
5405 /* Write the link statistics to a netinfo_t record */
5406 static netinfo_t *
5407 mac_write_link_stats(mac_client_impl_t *mcip)
5408 {
5409         netinfo_t               *ninfo;
5410         net_stat_t              *nstat;
5411         flow_entry_t            *flent;
5412         mac_soft_ring_set_t     *mac_srs;
5413         mac_rx_stats_t          *mac_rx_stat;
5414         mac_tx_stats_t          *mac_tx_stat;
5415         int                     i;
5416 
5417         ninfo = kmem_zalloc(sizeof (netinfo_t), KM_NOSLEEP);
5418         if (ninfo == NULL)
5419                 return (NULL);
5420         nstat = kmem_zalloc(sizeof (net_stat_t), KM_NOSLEEP);
5421         if (nstat == NULL) {
5422                 kmem_free(ninfo, sizeof (netinfo_t));
5423                 return (NULL);
5424         }
5425 
5426         nstat->ns_name = mcip->mci_name;
5427         flent = mcip->mci_flent;
5428         if (flent != NULL)  {
5429                 for (i = 0; i < flent->fe_rx_srs_cnt; i++) {
5430                         mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i];
5431                         mac_rx_stat = &mac_srs->srs_rx.sr_stat;
5432 
5433                         nstat->ns_ibytes += mac_rx_stat->mrs_intrbytes +
5434                             mac_rx_stat->mrs_pollbytes +
5435                             mac_rx_stat->mrs_lclbytes;
5436                         nstat->ns_ipackets += mac_rx_stat->mrs_intrcnt +
5437                             mac_rx_stat->mrs_pollcnt + mac_rx_stat->mrs_lclcnt;
5438                         nstat->ns_oerrors += mac_rx_stat->mrs_ierrors;
5439                 }
5440         }
5441 
5442         mac_srs = (mac_soft_ring_set_t *)(mcip->mci_flent->fe_tx_srs);
5443         if (mac_srs != NULL) {
5444                 mac_tx_stat = &mac_srs->srs_tx.st_stat;
5445 
5446                 nstat->ns_obytes = mac_tx_stat->mts_obytes;
5447                 nstat->ns_opackets = mac_tx_stat->mts_opackets;
5448                 nstat->ns_oerrors = mac_tx_stat->mts_oerrors;
5449         }
5450 
5451         ninfo->ni_record = nstat;
5452         ninfo->ni_size = sizeof (net_stat_t);
5453         ninfo->ni_type = EX_NET_LNSTAT_REC;
5454 
5455         return (ninfo);
5456 }
5457 
5458 typedef struct i_mac_log_state_s {
5459         boolean_t       mi_last;
5460         int             mi_fenable;
5461         int             mi_lenable;
5462         list_t          *mi_list;
5463 } i_mac_log_state_t;
5464 
5465 /*
5466  * For a given flow, if the description has not been logged before, do it now.
5467  * If it is a VNIC, then we have collected information about it from the MAC
5468  * table, so skip it.
5469  *
5470  * Called through mac_flow_walk_nolock()
5471  *
5472  * Return 0 if successful.
5473  */
5474 static int
5475 mac_log_flowinfo(flow_entry_t *flent, void *arg)
5476 {
5477         mac_client_impl_t       *mcip = flent->fe_mcip;
5478         i_mac_log_state_t       *lstate = arg;
5479         netinfo_t               *ninfo;
5480 
5481         if (mcip == NULL)
5482                 return (0);
5483 
5484         /*
5485          * If the name starts with "vnic", and fe_user_generated is true (to
5486          * exclude the mcast and active flow entries created implicitly for
5487          * a vnic, it is a VNIC flow.  i.e. vnic1 is a vnic flow,
5488          * vnic/bge1/mcast1 is not and neither is vnic/bge1/active.
5489          */
5490         if (strncasecmp(flent->fe_flow_name, "vnic", 4) == 0 &&
5491             (flent->fe_type & FLOW_USER) != 0) {
5492                 return (0);
5493         }
5494 
5495         if (!flent->fe_desc_logged) {
5496                 /*
5497                  * We don't return error because we want to continue the
5498                  * walk in case this is the last walk which means we
5499                  * need to reset fe_desc_logged in all the flows.
5500                  */
5501                 if ((ninfo = mac_write_flow_desc(flent, mcip)) == NULL)
5502                         return (0);
5503                 list_insert_tail(lstate->mi_list, ninfo);
5504                 flent->fe_desc_logged = B_TRUE;
5505         }
5506 
5507         /*
5508          * Regardless of the error, we want to proceed in case we have to
5509          * reset fe_desc_logged.
5510          */
5511         ninfo = mac_write_flow_stats(flent);
5512         if (ninfo == NULL)
5513                 return (-1);
5514 
5515         list_insert_tail(lstate->mi_list, ninfo);
5516 
5517         if (mcip != NULL && !(mcip->mci_state_flags & MCIS_DESC_LOGGED))
5518                 flent->fe_desc_logged = B_FALSE;
5519 
5520         return (0);
5521 }
5522 
5523 /*
5524  * Log the description for each mac client of this mac_impl_t, if it
5525  * hasn't already been done. Additionally, log statistics for the link as
5526  * well. Walk the flow table and log information for each flow as well.
5527  * If it is the last walk (mci_last), then we turn off mci_desc_logged (and
5528  * also fe_desc_logged, if flow logging is on) since we want to log the
5529  * description if and when logging is restarted.
5530  *
5531  * Return 0 upon success or -1 upon failure
5532  */
5533 static int
5534 i_mac_impl_log(mac_impl_t *mip, i_mac_log_state_t *lstate)
5535 {
5536         mac_client_impl_t       *mcip;
5537         netinfo_t               *ninfo;
5538 
5539         i_mac_perim_enter(mip);
5540         /*
5541          * Only walk the client list for NIC and etherstub
5542          */
5543         if ((mip->mi_state_flags & MIS_DISABLED) ||
5544             ((mip->mi_state_flags & MIS_IS_VNIC) &&
5545             (mac_get_lower_mac_handle((mac_handle_t)mip) != NULL))) {
5546                 i_mac_perim_exit(mip);
5547                 return (0);
5548         }
5549 
5550         for (mcip = mip->mi_clients_list; mcip != NULL;
5551             mcip = mcip->mci_client_next) {
5552                 if (!MCIP_DATAPATH_SETUP(mcip))
5553                         continue;
5554                 if (lstate->mi_lenable) {
5555                         if (!(mcip->mci_state_flags & MCIS_DESC_LOGGED)) {
5556                                 ninfo = mac_write_link_desc(mcip);
5557                                 if (ninfo == NULL) {
5558                                 /*
5559                                  * We can't terminate it if this is the last
5560                                  * walk, else there might be some links with
5561                                  * mi_desc_logged set to true, which means
5562                                  * their description won't be logged the next
5563                                  * time logging is started (similarly for the
5564                                  * flows within such links). We can continue
5565                                  * without walking the flow table (i.e. to
5566                                  * set fe_desc_logged to false) because we
5567                                  * won't have written any flow stuff for this
5568                                  * link as we haven't logged the link itself.
5569                                  */
5570                                         i_mac_perim_exit(mip);
5571                                         if (lstate->mi_last)
5572                                                 return (0);
5573                                         else
5574                                                 return (-1);
5575                                 }
5576                                 mcip->mci_state_flags |= MCIS_DESC_LOGGED;
5577                                 list_insert_tail(lstate->mi_list, ninfo);
5578                         }
5579                 }
5580 
5581                 ninfo = mac_write_link_stats(mcip);
5582                 if (ninfo == NULL && !lstate->mi_last) {
5583                         i_mac_perim_exit(mip);
5584                         return (-1);
5585                 }
5586                 list_insert_tail(lstate->mi_list, ninfo);
5587 
5588                 if (lstate->mi_last)
5589                         mcip->mci_state_flags &= ~MCIS_DESC_LOGGED;
5590 
5591                 if (lstate->mi_fenable) {
5592                         if (mcip->mci_subflow_tab != NULL) {
5593                                 (void) mac_flow_walk_nolock(
5594                                     mcip->mci_subflow_tab, mac_log_flowinfo,
5595                                     lstate);
5596                         }
5597                 }
5598         }
5599         i_mac_perim_exit(mip);
5600         return (0);
5601 }
5602 
5603 /*
5604  * modhash walker function to add a mac_impl_t to a list
5605  */
5606 /*ARGSUSED*/
5607 static uint_t
5608 i_mac_impl_list_walker(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
5609 {
5610         list_t                  *list = (list_t *)arg;
5611         mac_impl_t              *mip = (mac_impl_t *)val;
5612 
5613         if ((mip->mi_state_flags & MIS_DISABLED) == 0) {
5614                 list_insert_tail(list, mip);
5615                 mip->mi_ref++;
5616         }
5617 
5618         return (MH_WALK_CONTINUE);
5619 }
5620 
5621 void
5622 i_mac_log_info(list_t *net_log_list, i_mac_log_state_t *lstate)
5623 {
5624         list_t                  mac_impl_list;
5625         mac_impl_t              *mip;
5626         netinfo_t               *ninfo;
5627 
5628         /* Create list of mac_impls */
5629         ASSERT(RW_LOCK_HELD(&i_mac_impl_lock));
5630         list_create(&mac_impl_list, sizeof (mac_impl_t), offsetof(mac_impl_t,
5631             mi_node));
5632         mod_hash_walk(i_mac_impl_hash, i_mac_impl_list_walker, &mac_impl_list);
5633         rw_exit(&i_mac_impl_lock);
5634 
5635         /* Create log entries for each mac_impl */
5636         for (mip = list_head(&mac_impl_list); mip != NULL;
5637             mip = list_next(&mac_impl_list, mip)) {
5638                 if (i_mac_impl_log(mip, lstate) != 0)
5639                         continue;
5640         }
5641 
5642         /* Remove elements and destroy list of mac_impls */
5643         rw_enter(&i_mac_impl_lock, RW_WRITER);
5644         while ((mip = list_remove_tail(&mac_impl_list)) != NULL) {
5645                 mip->mi_ref--;
5646         }
5647         rw_exit(&i_mac_impl_lock);
5648         list_destroy(&mac_impl_list);
5649 
5650         /*
5651          * Write log entries to files outside of locks, free associated
5652          * structures, and remove entries from the list.
5653          */
5654         while ((ninfo = list_head(net_log_list)) != NULL) {
5655                 (void) exacct_commit_netinfo(ninfo->ni_record, ninfo->ni_type);
5656                 list_remove(net_log_list, ninfo);
5657                 kmem_free(ninfo->ni_record, ninfo->ni_size);
5658                 kmem_free(ninfo, sizeof (*ninfo));
5659         }
5660         list_destroy(net_log_list);
5661 }
5662 
5663 /*
5664  * The timer thread that runs every mac_logging_interval seconds and logs
5665  * link and/or flow information.
5666  */
5667 /* ARGSUSED */
5668 void
5669 mac_log_linkinfo(void *arg)
5670 {
5671         i_mac_log_state_t       lstate;
5672         list_t                  net_log_list;
5673 
5674         list_create(&net_log_list, sizeof (netinfo_t),
5675             offsetof(netinfo_t, ni_link));
5676 
5677         rw_enter(&i_mac_impl_lock, RW_READER);
5678         if (!mac_flow_log_enable && !mac_link_log_enable) {
5679                 rw_exit(&i_mac_impl_lock);
5680                 return;
5681         }
5682         lstate.mi_fenable = mac_flow_log_enable;
5683         lstate.mi_lenable = mac_link_log_enable;
5684         lstate.mi_last = B_FALSE;
5685         lstate.mi_list = &net_log_list;
5686 
5687         /* Write log entries for each mac_impl in the list */
5688         i_mac_log_info(&net_log_list, &lstate);
5689 
5690         if (mac_flow_log_enable || mac_link_log_enable) {
5691                 mac_logging_timer = timeout(mac_log_linkinfo, NULL,
5692                     SEC_TO_TICK(mac_logging_interval));
5693         }
5694 }
5695 
5696 typedef struct i_mac_fastpath_state_s {
5697         boolean_t       mf_disable;
5698         int             mf_err;
5699 } i_mac_fastpath_state_t;
5700 
5701 /* modhash walker function to enable or disable fastpath */
5702 /*ARGSUSED*/
5703 static uint_t
5704 i_mac_fastpath_walker(mod_hash_key_t key, mod_hash_val_t *val,
5705     void *arg)
5706 {
5707         i_mac_fastpath_state_t  *state = arg;
5708         mac_handle_t            mh = (mac_handle_t)val;
5709 
5710         if (state->mf_disable)
5711                 state->mf_err = mac_fastpath_disable(mh);
5712         else
5713                 mac_fastpath_enable(mh);
5714 
5715         return (state->mf_err == 0 ? MH_WALK_CONTINUE : MH_WALK_TERMINATE);
5716 }
5717 
5718 /*
5719  * Start the logging timer.
5720  */
5721 int
5722 mac_start_logusage(mac_logtype_t type, uint_t interval)
5723 {
5724         i_mac_fastpath_state_t  dstate = {B_TRUE, 0};
5725         i_mac_fastpath_state_t  estate = {B_FALSE, 0};
5726         int                     err;
5727 
5728         rw_enter(&i_mac_impl_lock, RW_WRITER);
5729         switch (type) {
5730         case MAC_LOGTYPE_FLOW:
5731                 if (mac_flow_log_enable) {
5732                         rw_exit(&i_mac_impl_lock);
5733                         return (0);
5734                 }
5735                 /* FALLTHRU */
5736         case MAC_LOGTYPE_LINK:
5737                 if (mac_link_log_enable) {
5738                         rw_exit(&i_mac_impl_lock);
5739                         return (0);
5740                 }
5741                 break;
5742         default:
5743                 ASSERT(0);
5744         }
5745 
5746         /* Disable fastpath */
5747         mod_hash_walk(i_mac_impl_hash, i_mac_fastpath_walker, &dstate);
5748         if ((err = dstate.mf_err) != 0) {
5749                 /* Reenable fastpath  */
5750                 mod_hash_walk(i_mac_impl_hash, i_mac_fastpath_walker, &estate);
5751                 rw_exit(&i_mac_impl_lock);
5752                 return (err);
5753         }
5754 
5755         switch (type) {
5756         case MAC_LOGTYPE_FLOW:
5757                 mac_flow_log_enable = B_TRUE;
5758                 /* FALLTHRU */
5759         case MAC_LOGTYPE_LINK:
5760                 mac_link_log_enable = B_TRUE;
5761                 break;
5762         }
5763 
5764         mac_logging_interval = interval;
5765         rw_exit(&i_mac_impl_lock);
5766         mac_log_linkinfo(NULL);
5767         return (0);
5768 }
5769 
5770 /*
5771  * Stop the logging timer if both link and flow logging are turned off.
5772  */
5773 void
5774 mac_stop_logusage(mac_logtype_t type)
5775 {
5776         i_mac_log_state_t       lstate;
5777         i_mac_fastpath_state_t  estate = {B_FALSE, 0};
5778         list_t                  net_log_list;
5779 
5780         list_create(&net_log_list, sizeof (netinfo_t),
5781             offsetof(netinfo_t, ni_link));
5782 
5783         rw_enter(&i_mac_impl_lock, RW_WRITER);
5784 
5785         lstate.mi_fenable = mac_flow_log_enable;
5786         lstate.mi_lenable = mac_link_log_enable;
5787         lstate.mi_list = &net_log_list;
5788 
5789         /* Last walk */
5790         lstate.mi_last = B_TRUE;
5791 
5792         switch (type) {
5793         case MAC_LOGTYPE_FLOW:
5794                 if (lstate.mi_fenable) {
5795                         ASSERT(mac_link_log_enable);
5796                         mac_flow_log_enable = B_FALSE;
5797                         mac_link_log_enable = B_FALSE;
5798                         break;
5799                 }
5800                 /* FALLTHRU */
5801         case MAC_LOGTYPE_LINK:
5802                 if (!lstate.mi_lenable || mac_flow_log_enable) {
5803                         rw_exit(&i_mac_impl_lock);
5804                         return;
5805                 }
5806                 mac_link_log_enable = B_FALSE;
5807                 break;
5808         default:
5809                 ASSERT(0);
5810         }
5811 
5812         /* Reenable fastpath */
5813         mod_hash_walk(i_mac_impl_hash, i_mac_fastpath_walker, &estate);
5814 
5815         (void) untimeout(mac_logging_timer);
5816         mac_logging_timer = 0;
5817 
5818         /* Write log entries for each mac_impl in the list */
5819         i_mac_log_info(&net_log_list, &lstate);
5820 }
5821 
5822 /*
5823  * Walk the rx and tx SRS/SRs for a flow and update the priority value.
5824  */
5825 void
5826 mac_flow_update_priority(mac_client_impl_t *mcip, flow_entry_t *flent)
5827 {
5828         pri_t                   pri;
5829         int                     count;
5830         mac_soft_ring_set_t     *mac_srs;
5831 
5832         if (flent->fe_rx_srs_cnt <= 0)
5833                 return;
5834 
5835         if (((mac_soft_ring_set_t *)flent->fe_rx_srs[0])->srs_type ==
5836             SRST_FLOW) {
5837                 pri = FLOW_PRIORITY(mcip->mci_min_pri,
5838                     mcip->mci_max_pri,
5839                     flent->fe_resource_props.mrp_priority);
5840         } else {
5841                 pri = mcip->mci_max_pri;
5842         }
5843 
5844         for (count = 0; count < flent->fe_rx_srs_cnt; count++) {
5845                 mac_srs = flent->fe_rx_srs[count];
5846                 mac_update_srs_priority(mac_srs, pri);
5847         }
5848         /*
5849          * If we have a Tx SRS, we need to modify all the threads associated
5850          * with it.
5851          */
5852         if (flent->fe_tx_srs != NULL)
5853                 mac_update_srs_priority(flent->fe_tx_srs, pri);
5854 }
5855 
5856 /*
5857  * RX and TX rings are reserved according to different semantics depending
5858  * on the requests from the MAC clients and type of rings:
5859  *
5860  * On the Tx side, by default we reserve individual rings, independently from
5861  * the groups.
5862  *
5863  * On the Rx side, the reservation is at the granularity of the group
5864  * of rings, and used for v12n level 1 only. It has a special case for the
5865  * primary client.
5866  *
5867  * If a share is allocated to a MAC client, we allocate a TX group and an
5868  * RX group to the client, and assign TX rings and RX rings to these
5869  * groups according to information gathered from the driver through
5870  * the share capability.
5871  *
5872  * The foreseable evolution of Rx rings will handle v12n level 2 and higher
5873  * to allocate individual rings out of a group and program the hw classifier
5874  * based on IP address or higher level criteria.
5875  */
5876 
5877 /*
5878  * mac_reserve_tx_ring()
5879  * Reserve a unused ring by marking it with MR_INUSE state.
5880  * As reserved, the ring is ready to function.
5881  *
5882  * Notes for Hybrid I/O:
5883  *
5884  * If a specific ring is needed, it is specified through the desired_ring
5885  * argument. Otherwise that argument is set to NULL.
5886  * If the desired ring was previous allocated to another client, this
5887  * function swaps it with a new ring from the group of unassigned rings.
5888  */
5889 mac_ring_t *
5890 mac_reserve_tx_ring(mac_impl_t *mip, mac_ring_t *desired_ring)
5891 {
5892         mac_group_t             *group;
5893         mac_grp_client_t        *mgcp;
5894         mac_client_impl_t       *mcip;
5895         mac_soft_ring_set_t     *srs;
5896 
5897         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
5898 
5899         /*
5900          * Find an available ring and start it before changing its status.
5901          * The unassigned rings are at the end of the mi_tx_groups
5902          * array.
5903          */
5904         group = MAC_DEFAULT_TX_GROUP(mip);
5905 
5906         /* Can't take the default ring out of the default group */
5907         ASSERT(desired_ring != (mac_ring_t *)mip->mi_default_tx_ring);
5908 
5909         if (desired_ring->mr_state == MR_FREE) {
5910                 ASSERT(MAC_GROUP_NO_CLIENT(group));
5911                 if (mac_start_ring(desired_ring) != 0)
5912                         return (NULL);
5913                 return (desired_ring);
5914         }
5915         /*
5916          * There are clients using this ring, so let's move the clients
5917          * away from using this ring.
5918          */
5919         for (mgcp = group->mrg_clients; mgcp != NULL; mgcp = mgcp->mgc_next) {
5920                 mcip = mgcp->mgc_client;
5921                 mac_tx_client_quiesce((mac_client_handle_t)mcip);
5922                 srs = MCIP_TX_SRS(mcip);
5923                 ASSERT(mac_tx_srs_ring_present(srs, desired_ring));
5924                 mac_tx_invoke_callbacks(mcip,
5925                     (mac_tx_cookie_t)mac_tx_srs_get_soft_ring(srs,
5926                     desired_ring));
5927                 mac_tx_srs_del_ring(srs, desired_ring);
5928                 mac_tx_client_restart((mac_client_handle_t)mcip);
5929         }
5930         return (desired_ring);
5931 }
5932 
5933 /*
5934  * For a reserved group with multiple clients, return the primary client.
5935  */
5936 static mac_client_impl_t *
5937 mac_get_grp_primary(mac_group_t *grp)
5938 {
5939         mac_grp_client_t        *mgcp = grp->mrg_clients;
5940         mac_client_impl_t       *mcip;
5941 
5942         while (mgcp != NULL) {
5943                 mcip = mgcp->mgc_client;
5944                 if (mcip->mci_flent->fe_type & FLOW_PRIMARY_MAC)
5945                         return (mcip);
5946                 mgcp = mgcp->mgc_next;
5947         }
5948         return (NULL);
5949 }
5950 
5951 /*
5952  * Hybrid I/O specifies the ring that should be given to a share.
5953  * If the ring is already used by clients, then we need to release
5954  * the ring back to the default group so that we can give it to
5955  * the share. This means the clients using this ring now get a
5956  * replacement ring. If there aren't any replacement rings, this
5957  * function returns a failure.
5958  */
5959 static int
5960 mac_reclaim_ring_from_grp(mac_impl_t *mip, mac_ring_type_t ring_type,
5961     mac_ring_t *ring, mac_ring_t **rings, int nrings)
5962 {
5963         mac_group_t             *group = (mac_group_t *)ring->mr_gh;
5964         mac_resource_props_t    *mrp;
5965         mac_client_impl_t       *mcip;
5966         mac_group_t             *defgrp;
5967         mac_ring_t              *tring;
5968         mac_group_t             *tgrp;
5969         int                     i;
5970         int                     j;
5971 
5972         mcip = MAC_GROUP_ONLY_CLIENT(group);
5973         if (mcip == NULL)
5974                 mcip = mac_get_grp_primary(group);
5975         ASSERT(mcip != NULL);
5976         ASSERT(mcip->mci_share == 0);
5977 
5978         mrp = MCIP_RESOURCE_PROPS(mcip);
5979         if (ring_type == MAC_RING_TYPE_RX) {
5980                 defgrp = mip->mi_rx_donor_grp;
5981                 if ((mrp->mrp_mask & MRP_RX_RINGS) == 0) {
5982                         /* Need to put this mac client in the default group */
5983                         if (mac_rx_switch_group(mcip, group, defgrp) != 0)
5984                                 return (ENOSPC);
5985                 } else {
5986                         /*
5987                          * Switch this ring with some other ring from
5988                          * the default group.
5989                          */
5990                         for (tring = defgrp->mrg_rings; tring != NULL;
5991                             tring = tring->mr_next) {
5992                                 if (tring->mr_index == 0)
5993                                         continue;
5994                                 for (j = 0; j < nrings; j++) {
5995                                         if (rings[j] == tring)
5996                                                 break;
5997                                 }
5998                                 if (j >= nrings)
5999                                         break;
6000                         }
6001                         if (tring == NULL)
6002                                 return (ENOSPC);
6003                         if (mac_group_mov_ring(mip, group, tring) != 0)
6004                                 return (ENOSPC);
6005                         if (mac_group_mov_ring(mip, defgrp, ring) != 0) {
6006                                 (void) mac_group_mov_ring(mip, defgrp, tring);
6007                                 return (ENOSPC);
6008                         }
6009                 }
6010                 ASSERT(ring->mr_gh == (mac_group_handle_t)defgrp);
6011                 return (0);
6012         }
6013 
6014         defgrp = MAC_DEFAULT_TX_GROUP(mip);
6015         if (ring == (mac_ring_t *)mip->mi_default_tx_ring) {
6016                 /*
6017                  * See if we can get a spare ring to replace the default
6018                  * ring.
6019                  */
6020                 if (defgrp->mrg_cur_count == 1) {
6021                         /*
6022                          * Need to get a ring from another client, see if
6023                          * there are any clients that can be moved to
6024                          * the default group, thereby freeing some rings.
6025                          */
6026                         for (i = 0; i < mip->mi_tx_group_count; i++) {
6027                                 tgrp = &mip->mi_tx_groups[i];
6028                                 if (tgrp->mrg_state ==
6029                                     MAC_GROUP_STATE_REGISTERED) {
6030                                         continue;
6031                                 }
6032                                 mcip = MAC_GROUP_ONLY_CLIENT(tgrp);
6033                                 if (mcip == NULL)
6034                                         mcip = mac_get_grp_primary(tgrp);
6035                                 ASSERT(mcip != NULL);
6036                                 mrp = MCIP_RESOURCE_PROPS(mcip);
6037                                 if ((mrp->mrp_mask & MRP_TX_RINGS) == 0) {
6038                                         ASSERT(tgrp->mrg_cur_count == 1);
6039                                         /*
6040                                          * If this ring is part of the
6041                                          * rings asked by the share we cannot
6042                                          * use it as the default ring.
6043                                          */
6044                                         for (j = 0; j < nrings; j++) {
6045                                                 if (rings[j] == tgrp->mrg_rings)
6046                                                         break;
6047                                         }
6048                                         if (j < nrings)
6049                                                 continue;
6050                                         mac_tx_client_quiesce(
6051                                             (mac_client_handle_t)mcip);
6052                                         mac_tx_switch_group(mcip, tgrp,
6053                                             defgrp);
6054                                         mac_tx_client_restart(
6055                                             (mac_client_handle_t)mcip);
6056                                         break;
6057                                 }
6058                         }
6059                         /*
6060                          * All the rings are reserved, can't give up the
6061                          * default ring.
6062                          */
6063                         if (defgrp->mrg_cur_count <= 1)
6064                                 return (ENOSPC);
6065                 }
6066                 /*
6067                  * Swap the default ring with another.
6068                  */
6069                 for (tring = defgrp->mrg_rings; tring != NULL;
6070                     tring = tring->mr_next) {
6071                         /*
6072                          * If this ring is part of the rings asked by the
6073                          * share we cannot use it as the default ring.
6074                          */
6075                         for (j = 0; j < nrings; j++) {
6076                                 if (rings[j] == tring)
6077                                         break;
6078                         }
6079                         if (j >= nrings)
6080                                 break;
6081                 }
6082                 ASSERT(tring != NULL);
6083                 mip->mi_default_tx_ring = (mac_ring_handle_t)tring;
6084                 return (0);
6085         }
6086         /*
6087          * The Tx ring is with a group reserved by a MAC client. See if
6088          * we can swap it.
6089          */
6090         ASSERT(group->mrg_state == MAC_GROUP_STATE_RESERVED);
6091         mcip = MAC_GROUP_ONLY_CLIENT(group);
6092         if (mcip == NULL)
6093                 mcip = mac_get_grp_primary(group);
6094         ASSERT(mcip !=  NULL);
6095         mrp = MCIP_RESOURCE_PROPS(mcip);
6096         mac_tx_client_quiesce((mac_client_handle_t)mcip);
6097         if ((mrp->mrp_mask & MRP_TX_RINGS) == 0) {
6098                 ASSERT(group->mrg_cur_count == 1);
6099                 /* Put this mac client in the default group */
6100                 mac_tx_switch_group(mcip, group, defgrp);
6101         } else {
6102                 /*
6103                  * Switch this ring with some other ring from
6104                  * the default group.
6105                  */
6106                 for (tring = defgrp->mrg_rings; tring != NULL;
6107                     tring = tring->mr_next) {
6108                         if (tring == (mac_ring_t *)mip->mi_default_tx_ring)
6109                                 continue;
6110                         /*
6111                          * If this ring is part of the rings asked by the
6112                          * share we cannot use it for swapping.
6113                          */
6114                         for (j = 0; j < nrings; j++) {
6115                                 if (rings[j] == tring)
6116                                         break;
6117                         }
6118                         if (j >= nrings)
6119                                 break;
6120                 }
6121                 if (tring == NULL) {
6122                         mac_tx_client_restart((mac_client_handle_t)mcip);
6123                         return (ENOSPC);
6124                 }
6125                 if (mac_group_mov_ring(mip, group, tring) != 0) {
6126                         mac_tx_client_restart((mac_client_handle_t)mcip);
6127                         return (ENOSPC);
6128                 }
6129                 if (mac_group_mov_ring(mip, defgrp, ring) != 0) {
6130                         (void) mac_group_mov_ring(mip, defgrp, tring);
6131                         mac_tx_client_restart((mac_client_handle_t)mcip);
6132                         return (ENOSPC);
6133                 }
6134         }
6135         mac_tx_client_restart((mac_client_handle_t)mcip);
6136         ASSERT(ring->mr_gh == (mac_group_handle_t)defgrp);
6137         return (0);
6138 }
6139 
6140 /*
6141  * Populate a zero-ring group with rings. If the share is non-NULL,
6142  * the rings are chosen according to that share.
6143  * Invoked after allocating a new RX or TX group through
6144  * mac_reserve_rx_group() or mac_reserve_tx_group(), respectively.
6145  * Returns zero on success, an errno otherwise.
6146  */
6147 int
6148 i_mac_group_allocate_rings(mac_impl_t *mip, mac_ring_type_t ring_type,
6149     mac_group_t *src_group, mac_group_t *new_group, mac_share_handle_t share,
6150     uint32_t ringcnt)
6151 {
6152         mac_ring_t **rings, *ring;
6153         uint_t nrings;
6154         int rv = 0, i = 0, j;
6155 
6156         ASSERT((ring_type == MAC_RING_TYPE_RX &&
6157             mip->mi_rx_group_type == MAC_GROUP_TYPE_DYNAMIC) ||
6158             (ring_type == MAC_RING_TYPE_TX &&
6159             mip->mi_tx_group_type == MAC_GROUP_TYPE_DYNAMIC));
6160 
6161         /*
6162          * First find the rings to allocate to the group.
6163          */
6164         if (share != 0) {
6165                 /* get rings through ms_squery() */
6166                 mip->mi_share_capab.ms_squery(share, ring_type, NULL, &nrings);
6167                 ASSERT(nrings != 0);
6168                 rings = kmem_alloc(nrings * sizeof (mac_ring_handle_t),
6169                     KM_SLEEP);
6170                 mip->mi_share_capab.ms_squery(share, ring_type,
6171                     (mac_ring_handle_t *)rings, &nrings);
6172                 for (i = 0; i < nrings; i++) {
6173                         /*
6174                          * If we have given this ring to a non-default
6175                          * group, we need to check if we can get this
6176                          * ring.
6177                          */
6178                         ring = rings[i];
6179                         if (ring->mr_gh != (mac_group_handle_t)src_group ||
6180                             ring == (mac_ring_t *)mip->mi_default_tx_ring) {
6181                                 if (mac_reclaim_ring_from_grp(mip, ring_type,
6182                                     ring, rings, nrings) != 0) {
6183                                         rv = ENOSPC;
6184                                         goto bail;
6185                                 }
6186                         }
6187                 }
6188         } else {
6189                 /*
6190                  * Pick one ring from default group.
6191                  *
6192                  * for now pick the second ring which requires the first ring
6193                  * at index 0 to stay in the default group, since it is the
6194                  * ring which carries the multicast traffic.
6195                  * We need a better way for a driver to indicate this,
6196                  * for example a per-ring flag.
6197                  */
6198                 rings = kmem_alloc(ringcnt * sizeof (mac_ring_handle_t),
6199                     KM_SLEEP);
6200                 for (ring = src_group->mrg_rings; ring != NULL;
6201                     ring = ring->mr_next) {
6202                         if (ring_type == MAC_RING_TYPE_RX &&
6203                             ring->mr_index == 0) {
6204                                 continue;
6205                         }
6206                         if (ring_type == MAC_RING_TYPE_TX &&
6207                             ring == (mac_ring_t *)mip->mi_default_tx_ring) {
6208                                 continue;
6209                         }
6210                         rings[i++] = ring;
6211                         if (i == ringcnt)
6212                                 break;
6213                 }
6214                 ASSERT(ring != NULL);
6215                 nrings = i;
6216                 /* Not enough rings as required */
6217                 if (nrings != ringcnt) {
6218                         rv = ENOSPC;
6219                         goto bail;
6220                 }
6221         }
6222 
6223         switch (ring_type) {
6224         case MAC_RING_TYPE_RX:
6225                 if (src_group->mrg_cur_count - nrings < 1) {
6226                         /* we ran out of rings */
6227                         rv = ENOSPC;
6228                         goto bail;
6229                 }
6230 
6231                 /* move receive rings to new group */
6232                 for (i = 0; i < nrings; i++) {
6233                         rv = mac_group_mov_ring(mip, new_group, rings[i]);
6234                         if (rv != 0) {
6235                                 /* move rings back on failure */
6236                                 for (j = 0; j < i; j++) {
6237                                         (void) mac_group_mov_ring(mip,
6238                                             src_group, rings[j]);
6239                                 }
6240                                 goto bail;
6241                         }
6242                 }
6243                 break;
6244 
6245         case MAC_RING_TYPE_TX: {
6246                 mac_ring_t *tmp_ring;
6247 
6248                 /* move the TX rings to the new group */
6249                 for (i = 0; i < nrings; i++) {
6250                         /* get the desired ring */
6251                         tmp_ring = mac_reserve_tx_ring(mip, rings[i]);
6252                         if (tmp_ring == NULL) {
6253                                 rv = ENOSPC;
6254                                 goto bail;
6255                         }
6256                         ASSERT(tmp_ring == rings[i]);
6257                         rv = mac_group_mov_ring(mip, new_group, rings[i]);
6258                         if (rv != 0) {
6259                                 /* cleanup on failure */
6260                                 for (j = 0; j < i; j++) {
6261                                         (void) mac_group_mov_ring(mip,
6262                                             MAC_DEFAULT_TX_GROUP(mip),
6263                                             rings[j]);
6264                                 }
6265                                 goto bail;
6266                         }
6267                 }
6268                 break;
6269         }
6270         }
6271 
6272         /* add group to share */
6273         if (share != 0)
6274                 mip->mi_share_capab.ms_sadd(share, new_group->mrg_driver);
6275 
6276 bail:
6277         /* free temporary array of rings */
6278         kmem_free(rings, nrings * sizeof (mac_ring_handle_t));
6279 
6280         return (rv);
6281 }
6282 
6283 void
6284 mac_group_add_client(mac_group_t *grp, mac_client_impl_t *mcip)
6285 {
6286         mac_grp_client_t *mgcp;
6287 
6288         for (mgcp = grp->mrg_clients; mgcp != NULL; mgcp = mgcp->mgc_next) {
6289                 if (mgcp->mgc_client == mcip)
6290                         break;
6291         }
6292 
6293         VERIFY(mgcp == NULL);
6294 
6295         mgcp = kmem_zalloc(sizeof (mac_grp_client_t), KM_SLEEP);
6296         mgcp->mgc_client = mcip;
6297         mgcp->mgc_next = grp->mrg_clients;
6298         grp->mrg_clients = mgcp;
6299 
6300 }
6301 
6302 void
6303 mac_group_remove_client(mac_group_t *grp, mac_client_impl_t *mcip)
6304 {
6305         mac_grp_client_t *mgcp, **pprev;
6306 
6307         for (pprev = &grp->mrg_clients, mgcp = *pprev; mgcp != NULL;
6308             pprev = &mgcp->mgc_next, mgcp = *pprev) {
6309                 if (mgcp->mgc_client == mcip)
6310                         break;
6311         }
6312 
6313         ASSERT(mgcp != NULL);
6314 
6315         *pprev = mgcp->mgc_next;
6316         kmem_free(mgcp, sizeof (mac_grp_client_t));
6317 }
6318 
6319 /*
6320  * mac_reserve_rx_group()
6321  *
6322  * Finds an available group and exclusively reserves it for a client.
6323  * The group is chosen to suit the flow's resource controls (bandwidth and
6324  * fanout requirements) and the address type.
6325  * If the requestor is the pimary MAC then return the group with the
6326  * largest number of rings, otherwise the default ring when available.
6327  */
6328 mac_group_t *
6329 mac_reserve_rx_group(mac_client_impl_t *mcip, uint8_t *mac_addr, boolean_t move)
6330 {
6331         mac_share_handle_t      share = mcip->mci_share;
6332         mac_impl_t              *mip = mcip->mci_mip;
6333         mac_group_t             *grp = NULL;
6334         int                     i;
6335         int                     err = 0;
6336         mac_address_t           *map;
6337         mac_resource_props_t    *mrp = MCIP_RESOURCE_PROPS(mcip);
6338         int                     nrings;
6339         int                     donor_grp_rcnt;
6340         boolean_t               need_exclgrp = B_FALSE;
6341         int                     need_rings = 0;
6342         mac_group_t             *candidate_grp = NULL;
6343         mac_client_impl_t       *gclient;
6344         mac_resource_props_t    *gmrp;
6345         mac_group_t             *donorgrp = NULL;
6346         boolean_t               rxhw = mrp->mrp_mask & MRP_RX_RINGS;
6347         boolean_t               unspec = mrp->mrp_mask & MRP_RXRINGS_UNSPEC;
6348         boolean_t               isprimary;
6349 
6350         ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
6351 
6352         isprimary = mcip->mci_flent->fe_type & FLOW_PRIMARY_MAC;
6353 
6354         /*
6355          * Check if a group already has this mac address (case of VLANs)
6356          * unless we are moving this MAC client from one group to another.
6357          */
6358         if (!move && (map = mac_find_macaddr(mip, mac_addr)) != NULL) {
6359                 if (map->ma_group != NULL)
6360                         return (map->ma_group);
6361         }
6362         if (mip->mi_rx_groups == NULL || mip->mi_rx_group_count == 0)
6363                 return (NULL);
6364         /*
6365          * If exclusive open, return NULL which will enable the
6366          * caller to use the default group.
6367          */
6368         if (mcip->mci_state_flags & MCIS_EXCLUSIVE)
6369                 return (NULL);
6370 
6371         /* For dynamic groups default unspecified to 1 */
6372         if (rxhw && unspec &&
6373             mip->mi_rx_group_type == MAC_GROUP_TYPE_DYNAMIC) {
6374                 mrp->mrp_nrxrings = 1;
6375         }
6376         /*
6377          * For static grouping we allow only specifying rings=0 and
6378          * unspecified
6379          */
6380         if (rxhw && mrp->mrp_nrxrings > 0 &&
6381             mip->mi_rx_group_type == MAC_GROUP_TYPE_STATIC) {
6382                 return (NULL);
6383         }
6384         if (rxhw) {
6385                 /*
6386                  * We have explicitly asked for a group (with nrxrings,
6387                  * if unspec).
6388                  */
6389                 if (unspec || mrp->mrp_nrxrings > 0) {
6390                         need_exclgrp = B_TRUE;
6391                         need_rings = mrp->mrp_nrxrings;
6392                 } else if (mrp->mrp_nrxrings == 0) {
6393                         /*
6394                          * We have asked for a software group.
6395                          */
6396                         return (NULL);
6397                 }
6398         } else if (isprimary && mip->mi_nactiveclients == 1 &&
6399             mip->mi_rx_group_type == MAC_GROUP_TYPE_DYNAMIC) {
6400                 /*
6401                  * If the primary is the only active client on this
6402                  * mip and we have not asked for any rings, we give
6403                  * it the default group so that the primary gets to
6404                  * use all the rings.
6405                  */
6406                 return (NULL);
6407         }
6408 
6409         /* The group that can donate rings */
6410         donorgrp = mip->mi_rx_donor_grp;
6411 
6412         /*
6413          * The number of rings that the default group can donate.
6414          * We need to leave at least one ring.
6415          */
6416         donor_grp_rcnt = donorgrp->mrg_cur_count - 1;
6417 
6418         /*
6419          * Try to exclusively reserve a RX group.
6420          *
6421          * For flows requiring HW_DEFAULT_RING (unicast flow of the primary
6422          * client), try to reserve the a non-default RX group and give
6423          * it all the rings from the donor group, except the default ring
6424          *
6425          * For flows requiring HW_RING (unicast flow of other clients), try
6426          * to reserve non-default RX group with the specified number of
6427          * rings, if available.
6428          *
6429          * For flows that have not asked for software or hardware ring,
6430          * try to reserve a non-default group with 1 ring, if available.
6431          */
6432         for (i = 1; i < mip->mi_rx_group_count; i++) {
6433                 grp = &mip->mi_rx_groups[i];
6434 
6435                 DTRACE_PROBE3(rx__group__trying, char *, mip->mi_name,
6436                     int, grp->mrg_index, mac_group_state_t, grp->mrg_state);
6437 
6438                 /*
6439                  * Check if this group could be a candidate group for
6440                  * eviction if we need a group for this MAC client,
6441                  * but there aren't any. A candidate group is one
6442                  * that didn't ask for an exclusive group, but got
6443                  * one and it has enough rings (combined with what
6444                  * the donor group can donate) for the new MAC
6445                  * client
6446                  */
6447                 if (grp->mrg_state >= MAC_GROUP_STATE_RESERVED) {
6448                         /*
6449                          * If the primary/donor group is not the default
6450                          * group, don't bother looking for a candidate group.
6451                          * If we don't have enough rings we will check
6452                          * if the primary group can be vacated.
6453                          */
6454                         if (candidate_grp == NULL &&
6455                             donorgrp == MAC_DEFAULT_RX_GROUP(mip)) {
6456                                 ASSERT(!MAC_GROUP_NO_CLIENT(grp));
6457                                 gclient = MAC_GROUP_ONLY_CLIENT(grp);
6458                                 if (gclient == NULL)
6459                                         gclient = mac_get_grp_primary(grp);
6460                                 ASSERT(gclient != NULL);
6461                                 gmrp = MCIP_RESOURCE_PROPS(gclient);
6462                                 if (gclient->mci_share == 0 &&
6463                                     (gmrp->mrp_mask & MRP_RX_RINGS) == 0 &&
6464                                     (unspec ||
6465                                     (grp->mrg_cur_count + donor_grp_rcnt >=
6466                                     need_rings))) {
6467                                         candidate_grp = grp;
6468                                 }
6469                         }
6470                         continue;
6471                 }
6472                 /*
6473                  * This group could already be SHARED by other multicast
6474                  * flows on this client. In that case, the group would
6475                  * be shared and has already been started.
6476                  */
6477                 ASSERT(grp->mrg_state != MAC_GROUP_STATE_UNINIT);
6478 
6479                 if ((grp->mrg_state == MAC_GROUP_STATE_REGISTERED) &&
6480                     (mac_start_group(grp) != 0)) {
6481                         continue;
6482                 }
6483 
6484                 if (mip->mi_rx_group_type != MAC_GROUP_TYPE_DYNAMIC)
6485                         break;
6486                 ASSERT(grp->mrg_cur_count == 0);
6487 
6488                 /*
6489                  * Populate the group. Rings should be taken
6490                  * from the donor group.
6491                  */
6492                 nrings = rxhw ? need_rings : isprimary ? donor_grp_rcnt: 1;
6493 
6494                 /*
6495                  * If the donor group can't donate, let's just walk and
6496                  * see if someone can vacate a group, so that we have
6497                  * enough rings for this, unless we already have
6498                  * identified a candiate group..
6499                  */
6500                 if (nrings <= donor_grp_rcnt) {
6501                         err = i_mac_group_allocate_rings(mip, MAC_RING_TYPE_RX,
6502                             donorgrp, grp, share, nrings);
6503                         if (err == 0) {
6504                                 /*
6505                                  * For a share i_mac_group_allocate_rings gets
6506                                  * the rings from the driver, let's populate
6507                                  * the property for the client now.
6508                                  */
6509                                 if (share != 0) {
6510                                         mac_client_set_rings(
6511                                             (mac_client_handle_t)mcip,
6512                                             grp->mrg_cur_count, -1);
6513                                 }
6514                                 if (mac_is_primary_client(mcip) && !rxhw)
6515                                         mip->mi_rx_donor_grp = grp;
6516                                 break;
6517                         }
6518                 }
6519 
6520                 DTRACE_PROBE3(rx__group__reserve__alloc__rings, char *,
6521                     mip->mi_name, int, grp->mrg_index, int, err);
6522 
6523                 /*
6524                  * It's a dynamic group but the grouping operation
6525                  * failed.
6526                  */
6527                 mac_stop_group(grp);
6528         }
6529         /* We didn't find an exclusive group for this MAC client */
6530         if (i >= mip->mi_rx_group_count) {
6531 
6532                 if (!need_exclgrp)
6533                         return (NULL);
6534 
6535                 /*
6536                  * If we found a candidate group then we switch the
6537                  * MAC client from the candidate_group to the default
6538                  * group and give the group to this MAC client. If
6539                  * we didn't find a candidate_group, check if the
6540                  * primary is in its own group and if it can make way
6541                  * for this MAC client.
6542                  */
6543                 if (candidate_grp == NULL &&
6544                     donorgrp != MAC_DEFAULT_RX_GROUP(mip) &&
6545                     donorgrp->mrg_cur_count >= need_rings) {
6546                         candidate_grp = donorgrp;
6547                 }
6548                 if (candidate_grp != NULL) {
6549                         boolean_t       prim_grp = B_FALSE;
6550 
6551                         /*
6552                          * Switch the MAC client from the candidate group
6553                          * to the default group.. If this group was the
6554                          * donor group, then after the switch we need
6555                          * to update the donor group too.
6556                          */
6557                         grp = candidate_grp;
6558                         gclient = MAC_GROUP_ONLY_CLIENT(grp);
6559                         if (gclient == NULL)
6560                                 gclient = mac_get_grp_primary(grp);
6561                         if (grp == mip->mi_rx_donor_grp)
6562                                 prim_grp = B_TRUE;
6563                         if (mac_rx_switch_group(gclient, grp,
6564                             MAC_DEFAULT_RX_GROUP(mip)) != 0) {
6565                                 return (NULL);
6566                         }
6567                         if (prim_grp) {
6568                                 mip->mi_rx_donor_grp =
6569                                     MAC_DEFAULT_RX_GROUP(mip);
6570                                 donorgrp = MAC_DEFAULT_RX_GROUP(mip);
6571                         }
6572 
6573 
6574                         /*
6575                          * Now give this group with the required rings
6576                          * to this MAC client.
6577                          */
6578                         ASSERT(grp->mrg_state == MAC_GROUP_STATE_REGISTERED);
6579                         if (mac_start_group(grp) != 0)
6580                                 return (NULL);
6581 
6582                         if (mip->mi_rx_group_type != MAC_GROUP_TYPE_DYNAMIC)
6583                                 return (grp);
6584 
6585                         donor_grp_rcnt = donorgrp->mrg_cur_count - 1;
6586                         ASSERT(grp->mrg_cur_count == 0);
6587                         ASSERT(donor_grp_rcnt >= need_rings);
6588                         err = i_mac_group_allocate_rings(mip, MAC_RING_TYPE_RX,
6589                             donorgrp, grp, share, need_rings);
6590                         if (err == 0) {
6591                                 /*
6592                                  * For a share i_mac_group_allocate_rings gets
6593                                  * the rings from the driver, let's populate
6594                                  * the property for the client now.
6595                                  */
6596                                 if (share != 0) {
6597                                         mac_client_set_rings(
6598                                             (mac_client_handle_t)mcip,
6599                                             grp->mrg_cur_count, -1);
6600                                 }
6601                                 DTRACE_PROBE2(rx__group__reserved,
6602                                     char *, mip->mi_name, int, grp->mrg_index);
6603                                 return (grp);
6604                         }
6605                         DTRACE_PROBE3(rx__group__reserve__alloc__rings, char *,
6606                             mip->mi_name, int, grp->mrg_index, int, err);
6607                         mac_stop_group(grp);
6608                 }
6609                 return (NULL);
6610         }
6611         ASSERT(grp != NULL);
6612 
6613         DTRACE_PROBE2(rx__group__reserved,
6614             char *, mip->mi_name, int, grp->mrg_index);
6615         return (grp);
6616 }
6617 
6618 /*
6619  * mac_rx_release_group()
6620  *
6621  * This is called when there are no clients left for the group.
6622  * The group is stopped and marked MAC_GROUP_STATE_REGISTERED,
6623  * and if it is a non default group, the shares are removed and
6624  * all rings are assigned back to default group.
6625  */
6626 void
6627 mac_release_rx_group(mac_client_impl_t *mcip, mac_group_t *group)
6628 {
6629         mac_impl_t              *mip = mcip->mci_mip;
6630         mac_ring_t              *ring;
6631 
6632         ASSERT(group != MAC_DEFAULT_RX_GROUP(mip));
6633 
6634         if (mip->mi_rx_donor_grp == group)
6635                 mip->mi_rx_donor_grp = MAC_DEFAULT_RX_GROUP(mip);
6636 
6637         /*
6638          * This is the case where there are no clients left. Any
6639          * SRS etc on this group have also be quiesced.
6640          */
6641         for (ring = group->mrg_rings; ring != NULL; ring = ring->mr_next) {
6642                 if (ring->mr_classify_type == MAC_HW_CLASSIFIER) {
6643                         ASSERT(group->mrg_state == MAC_GROUP_STATE_RESERVED);
6644                         /*
6645                          * Remove the SRS associated with the HW ring.
6646                          * As a result, polling will be disabled.
6647                          */
6648                         ring->mr_srs = NULL;
6649                 }
6650                 ASSERT(group->mrg_state < MAC_GROUP_STATE_RESERVED ||
6651                     ring->mr_state == MR_INUSE);
6652                 if (ring->mr_state == MR_INUSE) {
6653                         mac_stop_ring(ring);
6654                         ring->mr_flag = 0;
6655                 }
6656         }
6657 
6658         /* remove group from share */
6659         if (mcip->mci_share != 0) {
6660                 mip->mi_share_capab.ms_sremove(mcip->mci_share,
6661                     group->mrg_driver);
6662         }
6663 
6664         if (mip->mi_rx_group_type == MAC_GROUP_TYPE_DYNAMIC) {
6665                 mac_ring_t *ring;
6666 
6667                 /*
6668                  * Rings were dynamically allocated to group.
6669                  * Move rings back to default group.
6670                  */
6671                 while ((ring = group->mrg_rings) != NULL) {
6672                         (void) mac_group_mov_ring(mip, mip->mi_rx_donor_grp,
6673                             ring);
6674                 }
6675         }
6676         mac_stop_group(group);
6677         /*
6678          * Possible improvement: See if we can assign the group just released
6679          * to a another client of the mip
6680          */
6681 }
6682 
6683 /*
6684  * When we move the primary's mac address between groups, we need to also
6685  * take all the clients sharing the same mac address along with it (VLANs)
6686  * We remove the mac address for such clients from the group after quiescing
6687  * them. When we add the mac address we restart the client. Note that
6688  * the primary's mac address is removed from the group after all the
6689  * other clients sharing the address are removed. Similarly, the primary's
6690  * mac address is added before all the other client's mac address are
6691  * added. While grp is the group where the clients reside, tgrp is
6692  * the group where the addresses have to be added.
6693  */
6694 static void
6695 mac_rx_move_macaddr_prim(mac_client_impl_t *mcip, mac_group_t *grp,
6696     mac_group_t *tgrp, uint8_t *maddr, boolean_t add)
6697 {
6698         mac_impl_t              *mip = mcip->mci_mip;
6699         mac_grp_client_t        *mgcp = grp->mrg_clients;
6700         mac_client_impl_t       *gmcip;
6701         boolean_t               prim;
6702 
6703         prim = (mcip->mci_state_flags & MCIS_UNICAST_HW) != 0;
6704 
6705         /*
6706          * If the clients are in a non-default group, we just have to
6707          * walk the group's client list. If it is in the default group
6708          * (which will be shared by other clients as well, we need to
6709          * check if the unicast address matches mcip's unicast.
6710          */
6711         while (mgcp != NULL) {
6712                 gmcip = mgcp->mgc_client;
6713                 if (gmcip != mcip &&
6714                     (grp != MAC_DEFAULT_RX_GROUP(mip) ||
6715                     mcip->mci_unicast == gmcip->mci_unicast)) {
6716                         if (!add) {
6717                                 mac_rx_client_quiesce(
6718                                     (mac_client_handle_t)gmcip);
6719                                 (void) mac_remove_macaddr(mcip->mci_unicast);
6720                         } else {
6721                                 (void) mac_add_macaddr(mip, tgrp, maddr, prim);
6722                                 mac_rx_client_restart(
6723                                     (mac_client_handle_t)gmcip);
6724                         }
6725                 }
6726                 mgcp = mgcp->mgc_next;
6727         }
6728 }
6729 
6730 
6731 /*
6732  * Move the MAC address from fgrp to tgrp. If this is the primary client,
6733  * we need to take any VLANs etc. together too.
6734  */
6735 static int
6736 mac_rx_move_macaddr(mac_client_impl_t *mcip, mac_group_t *fgrp,
6737     mac_group_t *tgrp)
6738 {
6739         mac_impl_t              *mip = mcip->mci_mip;
6740         uint8_t                 maddr[MAXMACADDRLEN];
6741         int                     err = 0;
6742         boolean_t               prim;
6743         boolean_t               multiclnt = B_FALSE;
6744 
6745         mac_rx_client_quiesce((mac_client_handle_t)mcip);
6746         ASSERT(mcip->mci_unicast != NULL);
6747         bcopy(mcip->mci_unicast->ma_addr, maddr, mcip->mci_unicast->ma_len);
6748 
6749         prim = (mcip->mci_state_flags & MCIS_UNICAST_HW) != 0;
6750         if (mcip->mci_unicast->ma_nusers > 1) {
6751                 mac_rx_move_macaddr_prim(mcip, fgrp, NULL, maddr, B_FALSE);
6752                 multiclnt = B_TRUE;
6753         }
6754         ASSERT(mcip->mci_unicast->ma_nusers == 1);
6755         err = mac_remove_macaddr(mcip->mci_unicast);
6756         if (err != 0) {
6757                 mac_rx_client_restart((mac_client_handle_t)mcip);
6758                 if (multiclnt) {
6759                         mac_rx_move_macaddr_prim(mcip, fgrp, fgrp, maddr,
6760                             B_TRUE);
6761                 }
6762                 return (err);
6763         }
6764         /*
6765          * Program the H/W Classifier first, if this fails we need
6766          * not proceed with the other stuff.
6767          */
6768         if ((err = mac_add_macaddr(mip, tgrp, maddr, prim)) != 0) {
6769                 /* Revert back the H/W Classifier */
6770                 if ((err = mac_add_macaddr(mip, fgrp, maddr, prim)) != 0) {
6771                         /*
6772                          * This should not fail now since it worked earlier,
6773                          * should we panic?
6774                          */
6775                         cmn_err(CE_WARN,
6776                             "mac_rx_switch_group: switching %p back"
6777                             " to group %p failed!!", (void *)mcip,
6778                             (void *)fgrp);
6779                 }
6780                 mac_rx_client_restart((mac_client_handle_t)mcip);
6781                 if (multiclnt) {
6782                         mac_rx_move_macaddr_prim(mcip, fgrp, fgrp, maddr,
6783                             B_TRUE);
6784                 }
6785                 return (err);
6786         }
6787         mcip->mci_unicast = mac_find_macaddr(mip, maddr);
6788         mac_rx_client_restart((mac_client_handle_t)mcip);
6789         if (multiclnt)
6790                 mac_rx_move_macaddr_prim(mcip, fgrp, tgrp, maddr, B_TRUE);
6791         return (err);
6792 }
6793 
6794 /*
6795  * Switch the MAC client from one group to another. This means we need
6796  * to remove the MAC address from the group, remove the MAC client,
6797  * teardown the SRSs and revert the group state. Then, we add the client
6798  * to the destination group, set the SRSs, and add the MAC address to the
6799  * group.
6800  */
6801 int
6802 mac_rx_switch_group(mac_client_impl_t *mcip, mac_group_t *fgrp,
6803     mac_group_t *tgrp)
6804 {
6805         int                     err;
6806         mac_group_state_t       next_state;
6807         mac_client_impl_t       *group_only_mcip;
6808         mac_client_impl_t       *gmcip;
6809         mac_impl_t              *mip = mcip->mci_mip;
6810         mac_grp_client_t        *mgcp;
6811 
6812         ASSERT(fgrp == mcip->mci_flent->fe_rx_ring_group);
6813 
6814         if ((err = mac_rx_move_macaddr(mcip, fgrp, tgrp)) != 0)
6815                 return (err);
6816 
6817         /*
6818          * The group might be reserved, but SRSs may not be set up, e.g.
6819          * primary and its vlans using a reserved group.
6820          */
6821         if (fgrp->mrg_state == MAC_GROUP_STATE_RESERVED &&
6822             MAC_GROUP_ONLY_CLIENT(fgrp) != NULL) {
6823                 mac_rx_srs_group_teardown(mcip->mci_flent, B_TRUE);
6824         }
6825         if (fgrp != MAC_DEFAULT_RX_GROUP(mip)) {
6826                 mgcp = fgrp->mrg_clients;
6827                 while (mgcp != NULL) {
6828                         gmcip = mgcp->mgc_client;
6829                         mgcp = mgcp->mgc_next;
6830                         mac_group_remove_client(fgrp, gmcip);
6831                         mac_group_add_client(tgrp, gmcip);
6832                         gmcip->mci_flent->fe_rx_ring_group = tgrp;
6833                 }
6834                 mac_release_rx_group(mcip, fgrp);
6835                 ASSERT(MAC_GROUP_NO_CLIENT(fgrp));
6836                 mac_set_group_state(fgrp, MAC_GROUP_STATE_REGISTERED);
6837         } else {
6838                 mac_group_remove_client(fgrp, mcip);
6839                 mac_group_add_client(tgrp, mcip);
6840                 mcip->mci_flent->fe_rx_ring_group = tgrp;
6841                 /*
6842                  * If there are other clients (VLANs) sharing this address
6843                  * we should be here only for the primary.
6844                  */
6845                 if (mcip->mci_unicast->ma_nusers > 1) {
6846                         /*
6847                          * We need to move all the clients that are using
6848                          * this h/w address.
6849                          */
6850                         mgcp = fgrp->mrg_clients;
6851                         while (mgcp != NULL) {
6852                                 gmcip = mgcp->mgc_client;
6853                                 mgcp = mgcp->mgc_next;
6854                                 if (mcip->mci_unicast == gmcip->mci_unicast) {
6855                                         mac_group_remove_client(fgrp, gmcip);
6856                                         mac_group_add_client(tgrp, gmcip);
6857                                         gmcip->mci_flent->fe_rx_ring_group =
6858                                             tgrp;
6859                                 }
6860                         }
6861                 }
6862                 /*
6863                  * The default group will still take the multicast,
6864                  * broadcast traffic etc., so it won't go to
6865                  * MAC_GROUP_STATE_REGISTERED.
6866                  */
6867                 if (fgrp->mrg_state == MAC_GROUP_STATE_RESERVED)
6868                         mac_rx_group_unmark(fgrp, MR_CONDEMNED);
6869                 mac_set_group_state(fgrp, MAC_GROUP_STATE_SHARED);
6870         }
6871         next_state = mac_group_next_state(tgrp, &group_only_mcip,
6872             MAC_DEFAULT_RX_GROUP(mip), B_TRUE);
6873         mac_set_group_state(tgrp, next_state);
6874         /*
6875          * If the destination group is reserved, setup the SRSs etc.
6876          */
6877         if (tgrp->mrg_state == MAC_GROUP_STATE_RESERVED) {
6878                 mac_rx_srs_group_setup(mcip, mcip->mci_flent, SRST_LINK);
6879                 mac_fanout_setup(mcip, mcip->mci_flent,
6880                     MCIP_RESOURCE_PROPS(mcip), mac_rx_deliver, mcip, NULL,
6881                     NULL);
6882                 mac_rx_group_unmark(tgrp, MR_INCIPIENT);
6883         } else {
6884                 mac_rx_switch_grp_to_sw(tgrp);
6885         }
6886         return (0);
6887 }
6888 
6889 /*
6890  * Reserves a TX group for the specified share. Invoked by mac_tx_srs_setup()
6891  * when a share was allocated to the client.
6892  */
6893 mac_group_t *
6894 mac_reserve_tx_group(mac_client_impl_t *mcip, boolean_t move)
6895 {
6896         mac_impl_t              *mip = mcip->mci_mip;
6897         mac_group_t             *grp = NULL;
6898         int                     rv;
6899         int                     i;
6900         int                     err;
6901         mac_group_t             *defgrp;
6902         mac_share_handle_t      share = mcip->mci_share;
6903         mac_resource_props_t    *mrp = MCIP_RESOURCE_PROPS(mcip);
6904         int                     nrings;
6905         int                     defnrings;
6906         boolean_t               need_exclgrp = B_FALSE;
6907         int                     need_rings = 0;
6908         mac_group_t             *candidate_grp = NULL;
6909         mac_client_impl_t       *gclient;
6910         mac_resource_props_t    *gmrp;
6911         boolean_t               txhw = mrp->mrp_mask & MRP_TX_RINGS;
6912         boolean_t               unspec = mrp->mrp_mask & MRP_TXRINGS_UNSPEC;
6913         boolean_t               isprimary;
6914 
6915         isprimary = mcip->mci_flent->fe_type & FLOW_PRIMARY_MAC;
6916         /*
6917          * When we come here for a VLAN on the primary (dladm create-vlan),
6918          * we need to pair it along with the primary (to keep it consistent
6919          * with the RX side). So, we check if the primary is already assigned
6920          * to a group and return the group if so. The other way is also
6921          * true, i.e. the VLAN is already created and now we are plumbing
6922          * the primary.
6923          */
6924         if (!move && isprimary) {
6925                 for (gclient = mip->mi_clients_list; gclient != NULL;
6926                     gclient = gclient->mci_client_next) {
6927                         if (gclient->mci_flent->fe_type & FLOW_PRIMARY_MAC &&
6928                             gclient->mci_flent->fe_tx_ring_group != NULL) {
6929                                 return (gclient->mci_flent->fe_tx_ring_group);
6930                         }
6931                 }
6932         }
6933 
6934         if (mip->mi_tx_groups == NULL || mip->mi_tx_group_count == 0)
6935                 return (NULL);
6936 
6937         /* For dynamic groups, default unspec to 1 */
6938         if (txhw && unspec &&
6939             mip->mi_tx_group_type == MAC_GROUP_TYPE_DYNAMIC) {
6940                 mrp->mrp_ntxrings = 1;
6941         }
6942         /*
6943          * For static grouping we allow only specifying rings=0 and
6944          * unspecified
6945          */
6946         if (txhw && mrp->mrp_ntxrings > 0 &&
6947             mip->mi_tx_group_type == MAC_GROUP_TYPE_STATIC) {
6948                 return (NULL);
6949         }
6950 
6951         if (txhw) {
6952                 /*
6953                  * We have explicitly asked for a group (with ntxrings,
6954                  * if unspec).
6955                  */
6956                 if (unspec || mrp->mrp_ntxrings > 0) {
6957                         need_exclgrp = B_TRUE;
6958                         need_rings = mrp->mrp_ntxrings;
6959                 } else if (mrp->mrp_ntxrings == 0) {
6960                         /*
6961                          * We have asked for a software group.
6962                          */
6963                         return (NULL);
6964                 }
6965         }
6966         defgrp = MAC_DEFAULT_TX_GROUP(mip);
6967         /*
6968          * The number of rings that the default group can donate.
6969          * We need to leave at least one ring - the default ring - in
6970          * this group.
6971          */
6972         defnrings = defgrp->mrg_cur_count - 1;
6973 
6974         /*
6975          * Primary gets default group unless explicitly told not
6976          * to  (i.e. rings > 0).
6977          */
6978         if (isprimary && !need_exclgrp)
6979                 return (NULL);
6980 
6981         nrings = (mrp->mrp_mask & MRP_TX_RINGS) != 0 ? mrp->mrp_ntxrings : 1;
6982         for (i = 0; i <  mip->mi_tx_group_count; i++) {
6983                 grp = &mip->mi_tx_groups[i];
6984                 if ((grp->mrg_state == MAC_GROUP_STATE_RESERVED) ||
6985                     (grp->mrg_state == MAC_GROUP_STATE_UNINIT)) {
6986                         /*
6987                          * Select a candidate for replacement if we don't
6988                          * get an exclusive group. A candidate group is one
6989                          * that didn't ask for an exclusive group, but got
6990                          * one and it has enough rings (combined with what
6991                          * the default group can donate) for the new MAC
6992                          * client.
6993                          */
6994                         if (grp->mrg_state == MAC_GROUP_STATE_RESERVED &&
6995                             candidate_grp == NULL) {
6996                                 gclient = MAC_GROUP_ONLY_CLIENT(grp);
6997                                 if (gclient == NULL)
6998                                         gclient = mac_get_grp_primary(grp);
6999                                 gmrp = MCIP_RESOURCE_PROPS(gclient);
7000                                 if (gclient->mci_share == 0 &&
7001                                     (gmrp->mrp_mask & MRP_TX_RINGS) == 0 &&
7002                                     (unspec ||
7003                                     (grp->mrg_cur_count + defnrings) >=
7004                                     need_rings)) {
7005                                         candidate_grp = grp;
7006                                 }
7007                         }
7008                         continue;
7009                 }
7010                 /*
7011                  * If the default can't donate let's just walk and
7012                  * see if someone can vacate a group, so that we have
7013                  * enough rings for this.
7014                  */
7015                 if (mip->mi_tx_group_type != MAC_GROUP_TYPE_DYNAMIC ||
7016                     nrings <= defnrings) {
7017                         if (grp->mrg_state == MAC_GROUP_STATE_REGISTERED) {
7018                                 rv = mac_start_group(grp);
7019                                 ASSERT(rv == 0);
7020                         }
7021                         break;
7022                 }
7023         }
7024 
7025         /* The default group */
7026         if (i >= mip->mi_tx_group_count) {
7027                 /*
7028                  * If we need an exclusive group and have identified a
7029                  * candidate group we switch the MAC client from the
7030                  * candidate group to the default group and give the
7031                  * candidate group to this client.
7032                  */
7033                 if (need_exclgrp && candidate_grp != NULL) {
7034                         /*
7035                          * Switch the MAC client from the candidate group
7036                          * to the default group.
7037                          */
7038                         grp = candidate_grp;
7039                         gclient = MAC_GROUP_ONLY_CLIENT(grp);
7040                         if (gclient == NULL)
7041                                 gclient = mac_get_grp_primary(grp);
7042                         mac_tx_client_quiesce((mac_client_handle_t)gclient);
7043                         mac_tx_switch_group(gclient, grp, defgrp);
7044                         mac_tx_client_restart((mac_client_handle_t)gclient);
7045 
7046                         /*
7047                          * Give the candidate group with the specified number
7048                          * of rings to this MAC client.
7049                          */
7050                         ASSERT(grp->mrg_state == MAC_GROUP_STATE_REGISTERED);
7051                         rv = mac_start_group(grp);
7052                         ASSERT(rv == 0);
7053 
7054                         if (mip->mi_tx_group_type != MAC_GROUP_TYPE_DYNAMIC)
7055                                 return (grp);
7056 
7057                         ASSERT(grp->mrg_cur_count == 0);
7058                         ASSERT(defgrp->mrg_cur_count > need_rings);
7059 
7060                         err = i_mac_group_allocate_rings(mip, MAC_RING_TYPE_TX,
7061                             defgrp, grp, share, need_rings);
7062                         if (err == 0) {
7063                                 /*
7064                                  * For a share i_mac_group_allocate_rings gets
7065                                  * the rings from the driver, let's populate
7066                                  * the property for the client now.
7067                                  */
7068                                 if (share != 0) {
7069                                         mac_client_set_rings(
7070                                             (mac_client_handle_t)mcip, -1,
7071                                             grp->mrg_cur_count);
7072                                 }
7073                                 mip->mi_tx_group_free--;
7074                                 return (grp);
7075                         }
7076                         DTRACE_PROBE3(tx__group__reserve__alloc__rings, char *,
7077                             mip->mi_name, int, grp->mrg_index, int, err);
7078                         mac_stop_group(grp);
7079                 }
7080                 return (NULL);
7081         }
7082         /*
7083          * We got an exclusive group, but it is not dynamic.
7084          */
7085         if (mip->mi_tx_group_type != MAC_GROUP_TYPE_DYNAMIC) {
7086                 mip->mi_tx_group_free--;
7087                 return (grp);
7088         }
7089 
7090         rv = i_mac_group_allocate_rings(mip, MAC_RING_TYPE_TX, defgrp, grp,
7091             share, nrings);
7092         if (rv != 0) {
7093                 DTRACE_PROBE3(tx__group__reserve__alloc__rings,
7094                     char *, mip->mi_name, int, grp->mrg_index, int, rv);
7095                 mac_stop_group(grp);
7096                 return (NULL);
7097         }
7098         /*
7099          * For a share i_mac_group_allocate_rings gets the rings from the
7100          * driver, let's populate the property for the client now.
7101          */
7102         if (share != 0) {
7103                 mac_client_set_rings((mac_client_handle_t)mcip, -1,
7104                     grp->mrg_cur_count);
7105         }
7106         mip->mi_tx_group_free--;
7107         return (grp);
7108 }
7109 
7110 void
7111 mac_release_tx_group(mac_client_impl_t *mcip, mac_group_t *grp)
7112 {
7113         mac_impl_t              *mip = mcip->mci_mip;
7114         mac_share_handle_t      share = mcip->mci_share;
7115         mac_ring_t              *ring;
7116         mac_soft_ring_set_t     *srs = MCIP_TX_SRS(mcip);
7117         mac_group_t             *defgrp;
7118 
7119         defgrp = MAC_DEFAULT_TX_GROUP(mip);
7120         if (srs != NULL) {
7121                 if (srs->srs_soft_ring_count > 0) {
7122                         for (ring = grp->mrg_rings; ring != NULL;
7123                             ring = ring->mr_next) {
7124                                 ASSERT(mac_tx_srs_ring_present(srs, ring));
7125                                 mac_tx_invoke_callbacks(mcip,
7126                                     (mac_tx_cookie_t)
7127                                     mac_tx_srs_get_soft_ring(srs, ring));
7128                                 mac_tx_srs_del_ring(srs, ring);
7129                         }
7130                 } else {
7131                         ASSERT(srs->srs_tx.st_arg2 != NULL);
7132                         srs->srs_tx.st_arg2 = NULL;
7133                         mac_srs_stat_delete(srs);
7134                 }
7135         }
7136         if (share != 0)
7137                 mip->mi_share_capab.ms_sremove(share, grp->mrg_driver);
7138 
7139         /* move the ring back to the pool */
7140         if (mip->mi_tx_group_type == MAC_GROUP_TYPE_DYNAMIC) {
7141                 while ((ring = grp->mrg_rings) != NULL)
7142                         (void) mac_group_mov_ring(mip, defgrp, ring);
7143         }
7144         mac_stop_group(grp);
7145         mip->mi_tx_group_free++;
7146 }
7147 
7148 /*
7149  * Disassociate a MAC client from a group, i.e go through the rings in the
7150  * group and delete all the soft rings tied to them.
7151  */
7152 static void
7153 mac_tx_dismantle_soft_rings(mac_group_t *fgrp, flow_entry_t *flent)
7154 {
7155         mac_client_impl_t       *mcip = flent->fe_mcip;
7156         mac_soft_ring_set_t     *tx_srs;
7157         mac_srs_tx_t            *tx;
7158         mac_ring_t              *ring;
7159 
7160         tx_srs = flent->fe_tx_srs;
7161         tx = &tx_srs->srs_tx;
7162 
7163         /* Single ring case we haven't created any soft rings */
7164         if (tx->st_mode == SRS_TX_BW || tx->st_mode == SRS_TX_SERIALIZE ||
7165             tx->st_mode == SRS_TX_DEFAULT) {
7166                 tx->st_arg2 = NULL;
7167                 mac_srs_stat_delete(tx_srs);
7168         /* Fanout case, where we have to dismantle the soft rings */
7169         } else {
7170                 for (ring = fgrp->mrg_rings; ring != NULL;
7171                     ring = ring->mr_next) {
7172                         ASSERT(mac_tx_srs_ring_present(tx_srs, ring));
7173                         mac_tx_invoke_callbacks(mcip,
7174                             (mac_tx_cookie_t)mac_tx_srs_get_soft_ring(tx_srs,
7175                             ring));
7176                         mac_tx_srs_del_ring(tx_srs, ring);
7177                 }
7178                 ASSERT(tx->st_arg2 == NULL);
7179         }
7180 }
7181 
7182 /*
7183  * Switch the MAC client from one group to another. This means we need
7184  * to remove the MAC client, teardown the SRSs and revert the group state.
7185  * Then, we add the client to the destination roup, set the SRSs etc.
7186  */
7187 void
7188 mac_tx_switch_group(mac_client_impl_t *mcip, mac_group_t *fgrp,
7189     mac_group_t *tgrp)
7190 {
7191         mac_client_impl_t       *group_only_mcip;
7192         mac_impl_t              *mip = mcip->mci_mip;
7193         flow_entry_t            *flent = mcip->mci_flent;
7194         mac_group_t             *defgrp;
7195         mac_grp_client_t        *mgcp;
7196         mac_client_impl_t       *gmcip;
7197         flow_entry_t            *gflent;
7198 
7199         defgrp = MAC_DEFAULT_TX_GROUP(mip);
7200         ASSERT(fgrp == flent->fe_tx_ring_group);
7201 
7202         if (fgrp == defgrp) {
7203                 /*
7204                  * If this is the primary we need to find any VLANs on
7205                  * the primary and move them too.
7206                  */
7207                 mac_group_remove_client(fgrp, mcip);
7208                 mac_tx_dismantle_soft_rings(fgrp, flent);
7209                 if (mcip->mci_unicast->ma_nusers > 1) {
7210                         mgcp = fgrp->mrg_clients;
7211                         while (mgcp != NULL) {
7212                                 gmcip = mgcp->mgc_client;
7213                                 mgcp = mgcp->mgc_next;
7214                                 if (mcip->mci_unicast != gmcip->mci_unicast)
7215                                         continue;
7216                                 mac_tx_client_quiesce(
7217                                     (mac_client_handle_t)gmcip);
7218 
7219                                 gflent = gmcip->mci_flent;
7220                                 mac_group_remove_client(fgrp, gmcip);
7221                                 mac_tx_dismantle_soft_rings(fgrp, gflent);
7222 
7223                                 mac_group_add_client(tgrp, gmcip);
7224                                 gflent->fe_tx_ring_group = tgrp;
7225                                 /* We could directly set this to SHARED */
7226                                 tgrp->mrg_state = mac_group_next_state(tgrp,
7227                                     &group_only_mcip, defgrp, B_FALSE);
7228 
7229                                 mac_tx_srs_group_setup(gmcip, gflent,
7230                                     SRST_LINK);
7231                                 mac_fanout_setup(gmcip, gflent,
7232                                     MCIP_RESOURCE_PROPS(gmcip), mac_rx_deliver,
7233                                     gmcip, NULL, NULL);
7234 
7235                                 mac_tx_client_restart(
7236                                     (mac_client_handle_t)gmcip);
7237                         }
7238                 }
7239                 if (MAC_GROUP_NO_CLIENT(fgrp)) {
7240                         mac_ring_t      *ring;
7241                         int             cnt;
7242                         int             ringcnt;
7243 
7244                         fgrp->mrg_state = MAC_GROUP_STATE_REGISTERED;
7245                         /*
7246                          * Additionally, we also need to stop all
7247                          * the rings in the default group, except
7248                          * the default ring. The reason being
7249                          * this group won't be released since it is
7250                          * the default group, so the rings won't
7251                          * be stopped otherwise.
7252                          */
7253                         ringcnt = fgrp->mrg_cur_count;
7254                         ring = fgrp->mrg_rings;
7255                         for (cnt = 0; cnt < ringcnt; cnt++) {
7256                                 if (ring->mr_state == MR_INUSE &&
7257                                     ring !=
7258                                     (mac_ring_t *)mip->mi_default_tx_ring) {
7259                                         mac_stop_ring(ring);
7260                                         ring->mr_flag = 0;
7261                                 }
7262                                 ring = ring->mr_next;
7263                         }
7264                 } else if (MAC_GROUP_ONLY_CLIENT(fgrp) != NULL) {
7265                         fgrp->mrg_state = MAC_GROUP_STATE_RESERVED;
7266                 } else {
7267                         ASSERT(fgrp->mrg_state == MAC_GROUP_STATE_SHARED);
7268                 }
7269         } else {
7270                 /*
7271                  * We could have VLANs sharing the non-default group with
7272                  * the primary.
7273                  */
7274                 mgcp = fgrp->mrg_clients;
7275                 while (mgcp != NULL) {
7276                         gmcip = mgcp->mgc_client;
7277                         mgcp = mgcp->mgc_next;
7278                         if (gmcip == mcip)
7279                                 continue;
7280                         mac_tx_client_quiesce((mac_client_handle_t)gmcip);
7281                         gflent = gmcip->mci_flent;
7282 
7283                         mac_group_remove_client(fgrp, gmcip);
7284                         mac_tx_dismantle_soft_rings(fgrp, gflent);
7285 
7286                         mac_group_add_client(tgrp, gmcip);
7287                         gflent->fe_tx_ring_group = tgrp;
7288                         /* We could directly set this to SHARED */
7289                         tgrp->mrg_state = mac_group_next_state(tgrp,
7290                             &group_only_mcip, defgrp, B_FALSE);
7291                         mac_tx_srs_group_setup(gmcip, gflent, SRST_LINK);
7292                         mac_fanout_setup(gmcip, gflent,
7293                             MCIP_RESOURCE_PROPS(gmcip), mac_rx_deliver,
7294                             gmcip, NULL, NULL);
7295 
7296                         mac_tx_client_restart((mac_client_handle_t)gmcip);
7297                 }
7298                 mac_group_remove_client(fgrp, mcip);
7299                 mac_release_tx_group(mcip, fgrp);
7300                 fgrp->mrg_state = MAC_GROUP_STATE_REGISTERED;
7301         }
7302 
7303         /* Add it to the tgroup */
7304         mac_group_add_client(tgrp, mcip);
7305         flent->fe_tx_ring_group = tgrp;
7306         tgrp->mrg_state = mac_group_next_state(tgrp, &group_only_mcip,
7307             defgrp, B_FALSE);
7308 
7309         mac_tx_srs_group_setup(mcip, flent, SRST_LINK);
7310         mac_fanout_setup(mcip, flent, MCIP_RESOURCE_PROPS(mcip),
7311             mac_rx_deliver, mcip, NULL, NULL);
7312 }
7313 
7314 /*
7315  * This is a 1-time control path activity initiated by the client (IP).
7316  * The mac perimeter protects against other simultaneous control activities,
7317  * for example an ioctl that attempts to change the degree of fanout and
7318  * increase or decrease the number of softrings associated with this Tx SRS.
7319  */
7320 static mac_tx_notify_cb_t *
7321 mac_client_tx_notify_add(mac_client_impl_t *mcip,
7322     mac_tx_notify_t notify, void *arg)
7323 {
7324         mac_cb_info_t *mcbi;
7325         mac_tx_notify_cb_t *mtnfp;
7326 
7327         ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip));
7328 
7329         mtnfp = kmem_zalloc(sizeof (mac_tx_notify_cb_t), KM_SLEEP);
7330         mtnfp->mtnf_fn = notify;
7331         mtnfp->mtnf_arg = arg;
7332         mtnfp->mtnf_link.mcb_objp = mtnfp;
7333         mtnfp->mtnf_link.mcb_objsize = sizeof (mac_tx_notify_cb_t);
7334         mtnfp->mtnf_link.mcb_flags = MCB_TX_NOTIFY_CB_T;
7335 
7336         mcbi = &mcip->mci_tx_notify_cb_info;
7337         mutex_enter(mcbi->mcbi_lockp);
7338         mac_callback_add(mcbi, &mcip->mci_tx_notify_cb_list, &mtnfp->mtnf_link);
7339         mutex_exit(mcbi->mcbi_lockp);
7340         return (mtnfp);
7341 }
7342 
7343 static void
7344 mac_client_tx_notify_remove(mac_client_impl_t *mcip, mac_tx_notify_cb_t *mtnfp)
7345 {
7346         mac_cb_info_t   *mcbi;
7347         mac_cb_t        **cblist;
7348 
7349         ASSERT(MAC_PERIM_HELD((mac_handle_t)mcip->mci_mip));
7350 
7351         if (!mac_callback_find(&mcip->mci_tx_notify_cb_info,
7352             &mcip->mci_tx_notify_cb_list, &mtnfp->mtnf_link)) {
7353                 cmn_err(CE_WARN,
7354                     "mac_client_tx_notify_remove: callback not "
7355                     "found, mcip 0x%p mtnfp 0x%p", (void *)mcip, (void *)mtnfp);
7356                 return;
7357         }
7358 
7359         mcbi = &mcip->mci_tx_notify_cb_info;
7360         cblist = &mcip->mci_tx_notify_cb_list;
7361         mutex_enter(mcbi->mcbi_lockp);
7362         if (mac_callback_remove(mcbi, cblist, &mtnfp->mtnf_link))
7363                 kmem_free(mtnfp, sizeof (mac_tx_notify_cb_t));
7364         else
7365                 mac_callback_remove_wait(&mcip->mci_tx_notify_cb_info);
7366         mutex_exit(mcbi->mcbi_lockp);
7367 }
7368 
7369 /*
7370  * mac_client_tx_notify():
7371  * call to add and remove flow control callback routine.
7372  */
7373 mac_tx_notify_handle_t
7374 mac_client_tx_notify(mac_client_handle_t mch, mac_tx_notify_t callb_func,
7375     void *ptr)
7376 {
7377         mac_client_impl_t       *mcip = (mac_client_impl_t *)mch;
7378         mac_tx_notify_cb_t      *mtnfp = NULL;
7379 
7380         i_mac_perim_enter(mcip->mci_mip);
7381 
7382         if (callb_func != NULL) {
7383                 /* Add a notify callback */
7384                 mtnfp = mac_client_tx_notify_add(mcip, callb_func, ptr);
7385         } else {
7386                 mac_client_tx_notify_remove(mcip, (mac_tx_notify_cb_t *)ptr);
7387         }
7388         i_mac_perim_exit(mcip->mci_mip);
7389 
7390         return ((mac_tx_notify_handle_t)mtnfp);
7391 }
7392 
7393 void
7394 mac_bridge_vectors(mac_bridge_tx_t txf, mac_bridge_rx_t rxf,
7395     mac_bridge_ref_t reff, mac_bridge_ls_t lsf)
7396 {
7397         mac_bridge_tx_cb = txf;
7398         mac_bridge_rx_cb = rxf;
7399         mac_bridge_ref_cb = reff;
7400         mac_bridge_ls_cb = lsf;
7401 }
7402 
7403 int
7404 mac_bridge_set(mac_handle_t mh, mac_handle_t link)
7405 {
7406         mac_impl_t *mip = (mac_impl_t *)mh;
7407         int retv;
7408 
7409         mutex_enter(&mip->mi_bridge_lock);
7410         if (mip->mi_bridge_link == NULL) {
7411                 mip->mi_bridge_link = link;
7412                 retv = 0;
7413         } else {
7414                 retv = EBUSY;
7415         }
7416         mutex_exit(&mip->mi_bridge_lock);
7417         if (retv == 0) {
7418                 mac_poll_state_change(mh, B_FALSE);
7419                 mac_capab_update(mh);
7420         }
7421         return (retv);
7422 }
7423 
7424 /*
7425  * Disable bridging on the indicated link.
7426  */
7427 void
7428 mac_bridge_clear(mac_handle_t mh, mac_handle_t link)
7429 {
7430         mac_impl_t *mip = (mac_impl_t *)mh;
7431 
7432         mutex_enter(&mip->mi_bridge_lock);
7433         ASSERT(mip->mi_bridge_link == link);
7434         mip->mi_bridge_link = NULL;
7435         mutex_exit(&mip->mi_bridge_lock);
7436         mac_poll_state_change(mh, B_TRUE);
7437         mac_capab_update(mh);
7438 }
7439 
7440 void
7441 mac_no_active(mac_handle_t mh)
7442 {
7443         mac_impl_t *mip = (mac_impl_t *)mh;
7444 
7445         i_mac_perim_enter(mip);
7446         mip->mi_state_flags |= MIS_NO_ACTIVE;
7447         i_mac_perim_exit(mip);
7448 }
7449 
7450 /*
7451  * Walk the primary VLAN clients whenever the primary's rings property
7452  * changes and update the mac_resource_props_t for the VLAN's client.
7453  * We need to do this since we don't support setting these properties
7454  * on the primary's VLAN clients, but the VLAN clients have to
7455  * follow the primary w.r.t the rings property;
7456  */
7457 void
7458 mac_set_prim_vlan_rings(mac_impl_t  *mip, mac_resource_props_t *mrp)
7459 {
7460         mac_client_impl_t       *vmcip;
7461         mac_resource_props_t    *vmrp;
7462 
7463         for (vmcip = mip->mi_clients_list; vmcip != NULL;
7464             vmcip = vmcip->mci_client_next) {
7465                 if (!(vmcip->mci_flent->fe_type & FLOW_PRIMARY_MAC) ||
7466                     mac_client_vid((mac_client_handle_t)vmcip) ==
7467                     VLAN_ID_NONE) {
7468                         continue;
7469                 }
7470                 vmrp = MCIP_RESOURCE_PROPS(vmcip);
7471 
7472                 vmrp->mrp_nrxrings =  mrp->mrp_nrxrings;
7473                 if (mrp->mrp_mask & MRP_RX_RINGS)
7474                         vmrp->mrp_mask |= MRP_RX_RINGS;
7475                 else if (vmrp->mrp_mask & MRP_RX_RINGS)
7476                         vmrp->mrp_mask &= ~MRP_RX_RINGS;
7477 
7478                 vmrp->mrp_ntxrings =  mrp->mrp_ntxrings;
7479                 if (mrp->mrp_mask & MRP_TX_RINGS)
7480                         vmrp->mrp_mask |= MRP_TX_RINGS;
7481                 else if (vmrp->mrp_mask & MRP_TX_RINGS)
7482                         vmrp->mrp_mask &= ~MRP_TX_RINGS;
7483 
7484                 if (mrp->mrp_mask & MRP_RXRINGS_UNSPEC)
7485                         vmrp->mrp_mask |= MRP_RXRINGS_UNSPEC;
7486                 else
7487                         vmrp->mrp_mask &= ~MRP_RXRINGS_UNSPEC;
7488 
7489                 if (mrp->mrp_mask & MRP_TXRINGS_UNSPEC)
7490                         vmrp->mrp_mask |= MRP_TXRINGS_UNSPEC;
7491                 else
7492                         vmrp->mrp_mask &= ~MRP_TXRINGS_UNSPEC;
7493         }
7494 }
7495 
7496 /*
7497  * We are adding or removing ring(s) from a group. The source for taking
7498  * rings is the default group. The destination for giving rings back is
7499  * the default group.
7500  */
7501 int
7502 mac_group_ring_modify(mac_client_impl_t *mcip, mac_group_t *group,
7503     mac_group_t *defgrp)
7504 {
7505         mac_resource_props_t    *mrp = MCIP_RESOURCE_PROPS(mcip);
7506         uint_t                  modify;
7507         int                     count;
7508         mac_ring_t              *ring;
7509         mac_ring_t              *next;
7510         mac_impl_t              *mip = mcip->mci_mip;
7511         mac_ring_t              **rings;
7512         uint_t                  ringcnt;
7513         int                     i = 0;
7514         boolean_t               rx_group = group->mrg_type == MAC_RING_TYPE_RX;
7515         int                     start;
7516         int                     end;
7517         mac_group_t             *tgrp;
7518         int                     j;
7519         int                     rv = 0;
7520 
7521         /*
7522          * If we are asked for just a group, we give 1 ring, else
7523          * the specified number of rings.
7524          */
7525         if (rx_group) {
7526                 ringcnt = (mrp->mrp_mask & MRP_RXRINGS_UNSPEC) ? 1:
7527                     mrp->mrp_nrxrings;
7528         } else {
7529                 ringcnt = (mrp->mrp_mask & MRP_TXRINGS_UNSPEC) ? 1:
7530                     mrp->mrp_ntxrings;
7531         }
7532 
7533         /* don't allow modifying rings for a share for now. */
7534         ASSERT(mcip->mci_share == 0);
7535 
7536         if (ringcnt == group->mrg_cur_count)
7537                 return (0);
7538 
7539         if (group->mrg_cur_count > ringcnt) {
7540                 modify = group->mrg_cur_count - ringcnt;
7541                 if (rx_group) {
7542                         if (mip->mi_rx_donor_grp == group) {
7543                                 ASSERT(mac_is_primary_client(mcip));
7544                                 mip->mi_rx_donor_grp = defgrp;
7545                         } else {
7546                                 defgrp = mip->mi_rx_donor_grp;
7547                         }
7548                 }
7549                 ring = group->mrg_rings;
7550                 rings = kmem_alloc(modify * sizeof (mac_ring_handle_t),
7551                     KM_SLEEP);
7552                 j = 0;
7553                 for (count = 0; count < modify; count++) {
7554                         next = ring->mr_next;
7555                         rv = mac_group_mov_ring(mip, defgrp, ring);
7556                         if (rv != 0) {
7557                                 /* cleanup on failure */
7558                                 for (j = 0; j < count; j++) {
7559                                         (void) mac_group_mov_ring(mip, group,
7560                                             rings[j]);
7561                                 }
7562                                 break;
7563                         }
7564                         rings[j++] = ring;
7565                         ring = next;
7566                 }
7567                 kmem_free(rings, modify * sizeof (mac_ring_handle_t));
7568                 return (rv);
7569         }
7570         if (ringcnt >= MAX_RINGS_PER_GROUP)
7571                 return (EINVAL);
7572 
7573         modify = ringcnt - group->mrg_cur_count;
7574 
7575         if (rx_group) {
7576                 if (group != mip->mi_rx_donor_grp)
7577                         defgrp = mip->mi_rx_donor_grp;
7578                 else
7579                         /*
7580                          * This is the donor group with all the remaining
7581                          * rings. Default group now gets to be the donor
7582                          */
7583                         mip->mi_rx_donor_grp = defgrp;
7584                 start = 1;
7585                 end = mip->mi_rx_group_count;
7586         } else {
7587                 start = 0;
7588                 end = mip->mi_tx_group_count - 1;
7589         }
7590         /*
7591          * If the default doesn't have any rings, lets see if we can
7592          * take rings given to an h/w client that doesn't need it.
7593          * For now, we just see if there is  any one client that can donate
7594          * all the required rings.
7595          */
7596         if (defgrp->mrg_cur_count < (modify + 1)) {
7597                 for (i = start; i < end; i++) {
7598                         if (rx_group) {
7599                                 tgrp = &mip->mi_rx_groups[i];
7600                                 if (tgrp == group || tgrp->mrg_state <
7601                                     MAC_GROUP_STATE_RESERVED) {
7602                                         continue;
7603                                 }
7604                                 mcip = MAC_GROUP_ONLY_CLIENT(tgrp);
7605                                 if (mcip == NULL)
7606                                         mcip = mac_get_grp_primary(tgrp);
7607                                 ASSERT(mcip != NULL);
7608                                 mrp = MCIP_RESOURCE_PROPS(mcip);
7609                                 if ((mrp->mrp_mask & MRP_RX_RINGS) != 0)
7610                                         continue;
7611                                 if ((tgrp->mrg_cur_count +
7612                                     defgrp->mrg_cur_count) < (modify + 1)) {
7613                                         continue;
7614                                 }
7615                                 if (mac_rx_switch_group(mcip, tgrp,
7616                                     defgrp) != 0) {
7617                                         return (ENOSPC);
7618                                 }
7619                         } else {
7620                                 tgrp = &mip->mi_tx_groups[i];
7621                                 if (tgrp == group || tgrp->mrg_state <
7622                                     MAC_GROUP_STATE_RESERVED) {
7623                                         continue;
7624                                 }
7625                                 mcip = MAC_GROUP_ONLY_CLIENT(tgrp);
7626                                 if (mcip == NULL)
7627                                         mcip = mac_get_grp_primary(tgrp);
7628                                 mrp = MCIP_RESOURCE_PROPS(mcip);
7629                                 if ((mrp->mrp_mask & MRP_TX_RINGS) != 0)
7630                                         continue;
7631                                 if ((tgrp->mrg_cur_count +
7632                                     defgrp->mrg_cur_count) < (modify + 1)) {
7633                                         continue;
7634                                 }
7635                                 /* OK, we can switch this to s/w */
7636                                 mac_tx_client_quiesce(
7637                                     (mac_client_handle_t)mcip);
7638                                 mac_tx_switch_group(mcip, tgrp, defgrp);
7639                                 mac_tx_client_restart(
7640                                     (mac_client_handle_t)mcip);
7641                         }
7642                 }
7643                 if (defgrp->mrg_cur_count < (modify + 1))
7644                         return (ENOSPC);
7645         }
7646         if ((rv = i_mac_group_allocate_rings(mip, group->mrg_type, defgrp,
7647             group, mcip->mci_share, modify)) != 0) {
7648                 return (rv);
7649         }
7650         return (0);
7651 }
7652 
7653 /*
7654  * Given the poolname in mac_resource_props, find the cpupart
7655  * that is associated with this pool.  The cpupart will be used
7656  * later for finding the cpus to be bound to the networking threads.
7657  *
7658  * use_default is set B_TRUE if pools are enabled and pool_default
7659  * is returned.  This avoids a 2nd lookup to set the poolname
7660  * for pool-effective.
7661  *
7662  * returns:
7663  *
7664  *    NULL -   pools are disabled or if the 'cpus' property is set.
7665  *    cpupart of pool_default  - pools are enabled and the pool
7666  *             is not available or poolname is blank
7667  *    cpupart of named pool    - pools are enabled and the pool
7668  *             is available.
7669  */
7670 cpupart_t *
7671 mac_pset_find(mac_resource_props_t *mrp, boolean_t *use_default)
7672 {
7673         pool_t          *pool;
7674         cpupart_t       *cpupart;
7675 
7676         *use_default = B_FALSE;
7677 
7678         /* CPUs property is set */
7679         if (mrp->mrp_mask & MRP_CPUS)
7680                 return (NULL);
7681 
7682         ASSERT(pool_lock_held());
7683 
7684         /* Pools are disabled, no pset */
7685         if (pool_state == POOL_DISABLED)
7686                 return (NULL);
7687 
7688         /* Pools property is set */
7689         if (mrp->mrp_mask & MRP_POOL) {
7690                 if ((pool = pool_lookup_pool_by_name(mrp->mrp_pool)) == NULL) {
7691                         /* Pool not found */
7692                         DTRACE_PROBE1(mac_pset_find_no_pool, char *,
7693                             mrp->mrp_pool);
7694                         *use_default = B_TRUE;
7695                         pool = pool_default;
7696                 }
7697         /* Pools property is not set */
7698         } else {
7699                 *use_default = B_TRUE;
7700                 pool = pool_default;
7701         }
7702 
7703         /* Find the CPU pset that corresponds to the pool */
7704         mutex_enter(&cpu_lock);
7705         if ((cpupart = cpupart_find(pool->pool_pset->pset_id)) == NULL) {
7706                 DTRACE_PROBE1(mac_find_pset_no_pset, psetid_t,
7707                     pool->pool_pset->pset_id);
7708         }
7709         mutex_exit(&cpu_lock);
7710 
7711         return (cpupart);
7712 }
7713 
7714 void
7715 mac_set_pool_effective(boolean_t use_default, cpupart_t *cpupart,
7716     mac_resource_props_t *mrp, mac_resource_props_t *emrp)
7717 {
7718         ASSERT(pool_lock_held());
7719 
7720         if (cpupart != NULL) {
7721                 emrp->mrp_mask |= MRP_POOL;
7722                 if (use_default) {
7723                         (void) strcpy(emrp->mrp_pool,
7724                             "pool_default");
7725                 } else {
7726                         ASSERT(strlen(mrp->mrp_pool) != 0);
7727                         (void) strcpy(emrp->mrp_pool,
7728                             mrp->mrp_pool);
7729                 }
7730         } else {
7731                 emrp->mrp_mask &= ~MRP_POOL;
7732                 bzero(emrp->mrp_pool, MAXPATHLEN);
7733         }
7734 }
7735 
7736 struct mac_pool_arg {
7737         char            mpa_poolname[MAXPATHLEN];
7738         pool_event_t    mpa_what;
7739 };
7740 
7741 /*ARGSUSED*/
7742 static uint_t
7743 mac_pool_link_update(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
7744 {
7745         struct mac_pool_arg     *mpa = arg;
7746         mac_impl_t              *mip = (mac_impl_t *)val;
7747         mac_client_impl_t       *mcip;
7748         mac_resource_props_t    *mrp, *emrp;
7749         boolean_t               pool_update = B_FALSE;
7750         boolean_t               pool_clear = B_FALSE;
7751         boolean_t               use_default = B_FALSE;
7752         cpupart_t               *cpupart = NULL;
7753 
7754         mrp = kmem_zalloc(sizeof (*mrp), KM_SLEEP);
7755         i_mac_perim_enter(mip);
7756         for (mcip = mip->mi_clients_list; mcip != NULL;
7757             mcip = mcip->mci_client_next) {
7758                 pool_update = B_FALSE;
7759                 pool_clear = B_FALSE;
7760                 use_default = B_FALSE;
7761                 mac_client_get_resources((mac_client_handle_t)mcip, mrp);
7762                 emrp = MCIP_EFFECTIVE_PROPS(mcip);
7763 
7764                 /*
7765                  * When pools are enabled
7766                  */
7767                 if ((mpa->mpa_what == POOL_E_ENABLE) &&
7768                     ((mrp->mrp_mask & MRP_CPUS) == 0)) {
7769                         mrp->mrp_mask |= MRP_POOL;
7770                         pool_update = B_TRUE;
7771                 }
7772 
7773                 /*
7774                  * When pools are disabled
7775                  */
7776                 if ((mpa->mpa_what == POOL_E_DISABLE) &&
7777                     ((mrp->mrp_mask & MRP_CPUS) == 0)) {
7778                         mrp->mrp_mask |= MRP_POOL;
7779                         pool_clear = B_TRUE;
7780                 }
7781 
7782                 /*
7783                  * Look for links with the pool property set and the poolname
7784                  * matching the one which is changing.
7785                  */
7786                 if (strcmp(mrp->mrp_pool, mpa->mpa_poolname) == 0) {
7787                         /*
7788                          * The pool associated with the link has changed.
7789                          */
7790                         if (mpa->mpa_what == POOL_E_CHANGE) {
7791                                 mrp->mrp_mask |= MRP_POOL;
7792                                 pool_update = B_TRUE;
7793                         }
7794                 }
7795 
7796                 /*
7797                  * This link is associated with pool_default and
7798                  * pool_default has changed.
7799                  */
7800                 if ((mpa->mpa_what == POOL_E_CHANGE) &&
7801                     (strcmp(emrp->mrp_pool, "pool_default") == 0) &&
7802                     (strcmp(mpa->mpa_poolname, "pool_default") == 0)) {
7803                         mrp->mrp_mask |= MRP_POOL;
7804                         pool_update = B_TRUE;
7805                 }
7806 
7807                 /*
7808                  * Get new list of cpus for the pool, bind network
7809                  * threads to new list of cpus and update resources.
7810                  */
7811                 if (pool_update) {
7812                         if (MCIP_DATAPATH_SETUP(mcip)) {
7813                                 pool_lock();
7814                                 cpupart = mac_pset_find(mrp, &use_default);
7815                                 mac_fanout_setup(mcip, mcip->mci_flent, mrp,
7816                                     mac_rx_deliver, mcip, NULL, cpupart);
7817                                 mac_set_pool_effective(use_default, cpupart,
7818                                     mrp, emrp);
7819                                 pool_unlock();
7820                         }
7821                         mac_update_resources(mrp, MCIP_RESOURCE_PROPS(mcip),
7822                             B_FALSE);
7823                 }
7824 
7825                 /*
7826                  * Clear the effective pool and bind network threads
7827                  * to any available CPU.
7828                  */
7829                 if (pool_clear) {
7830                         if (MCIP_DATAPATH_SETUP(mcip)) {
7831                                 emrp->mrp_mask &= ~MRP_POOL;
7832                                 bzero(emrp->mrp_pool, MAXPATHLEN);
7833                                 mac_fanout_setup(mcip, mcip->mci_flent, mrp,
7834                                     mac_rx_deliver, mcip, NULL, NULL);
7835                         }
7836                         mac_update_resources(mrp, MCIP_RESOURCE_PROPS(mcip),
7837                             B_FALSE);
7838                 }
7839         }
7840         i_mac_perim_exit(mip);
7841         kmem_free(mrp, sizeof (*mrp));
7842         return (MH_WALK_CONTINUE);
7843 }
7844 
7845 static void
7846 mac_pool_update(void *arg)
7847 {
7848         mod_hash_walk(i_mac_impl_hash, mac_pool_link_update, arg);
7849         kmem_free(arg, sizeof (struct mac_pool_arg));
7850 }
7851 
7852 /*
7853  * Callback function to be executed when a noteworthy pool event
7854  * takes place.
7855  */
7856 /* ARGSUSED */
7857 static void
7858 mac_pool_event_cb(pool_event_t what, poolid_t id, void *arg)
7859 {
7860         pool_t                  *pool;
7861         char                    *poolname = NULL;
7862         struct mac_pool_arg     *mpa;
7863 
7864         pool_lock();
7865         mpa = kmem_zalloc(sizeof (struct mac_pool_arg), KM_SLEEP);
7866 
7867         switch (what) {
7868         case POOL_E_ENABLE:
7869         case POOL_E_DISABLE:
7870                 break;
7871 
7872         case POOL_E_CHANGE:
7873                 pool = pool_lookup_pool_by_id(id);
7874                 if (pool == NULL) {
7875                         kmem_free(mpa, sizeof (struct mac_pool_arg));
7876                         pool_unlock();
7877                         return;
7878                 }
7879                 pool_get_name(pool, &poolname);
7880                 (void) strlcpy(mpa->mpa_poolname, poolname,
7881                     sizeof (mpa->mpa_poolname));
7882                 break;
7883 
7884         default:
7885                 kmem_free(mpa, sizeof (struct mac_pool_arg));
7886                 pool_unlock();
7887                 return;
7888         }
7889         pool_unlock();
7890 
7891         mpa->mpa_what = what;
7892 
7893         mac_pool_update(mpa);
7894 }
7895 
7896 /*
7897  * Set effective rings property. This could be called from datapath_setup/
7898  * datapath_teardown or set-linkprop.
7899  * If the group is reserved we just go ahead and set the effective rings.
7900  * Additionally, for TX this could mean the default  group has lost/gained
7901  * some rings, so if the default group is reserved, we need to adjust the
7902  * effective rings for the default group clients. For RX, if we are working
7903  * with the non-default group, we just need * to reset the effective props
7904  * for the default group clients.
7905  */
7906 void
7907 mac_set_rings_effective(mac_client_impl_t *mcip)
7908 {
7909         mac_impl_t              *mip = mcip->mci_mip;
7910         mac_group_t             *grp;
7911         mac_group_t             *defgrp;
7912         flow_entry_t            *flent = mcip->mci_flent;
7913         mac_resource_props_t    *emrp = MCIP_EFFECTIVE_PROPS(mcip);
7914         mac_grp_client_t        *mgcp;
7915         mac_client_impl_t       *gmcip;
7916 
7917         grp = flent->fe_rx_ring_group;
7918         if (grp != NULL) {
7919                 defgrp = MAC_DEFAULT_RX_GROUP(mip);
7920                 /*
7921                  * If we have reserved a group, set the effective rings
7922                  * to the ring count in the group.
7923                  */
7924                 if (grp->mrg_state == MAC_GROUP_STATE_RESERVED) {
7925                         emrp->mrp_mask |= MRP_RX_RINGS;
7926                         emrp->mrp_nrxrings = grp->mrg_cur_count;
7927                 }
7928 
7929                 /*
7930                  * We go through the clients in the shared group and
7931                  * reset the effective properties. It is possible this
7932                  * might have already been done for some client (i.e.
7933                  * if some client is being moved to a group that is
7934                  * already shared). The case where the default group is
7935                  * RESERVED is taken care of above (note in the RX side if
7936                  * there is a non-default group, the default group is always
7937                  * SHARED).
7938                  */
7939                 if (grp != defgrp || grp->mrg_state == MAC_GROUP_STATE_SHARED) {
7940                         if (grp->mrg_state == MAC_GROUP_STATE_SHARED)
7941                                 mgcp = grp->mrg_clients;
7942                         else
7943                                 mgcp = defgrp->mrg_clients;
7944                         while (mgcp != NULL) {
7945                                 gmcip = mgcp->mgc_client;
7946                                 emrp = MCIP_EFFECTIVE_PROPS(gmcip);
7947                                 if (emrp->mrp_mask & MRP_RX_RINGS) {
7948                                         emrp->mrp_mask &= ~MRP_RX_RINGS;
7949                                         emrp->mrp_nrxrings = 0;
7950                                 }
7951                                 mgcp = mgcp->mgc_next;
7952                         }
7953                 }
7954         }
7955 
7956         /* Now the TX side */
7957         grp = flent->fe_tx_ring_group;
7958         if (grp != NULL) {
7959                 defgrp = MAC_DEFAULT_TX_GROUP(mip);
7960 
7961                 if (grp->mrg_state == MAC_GROUP_STATE_RESERVED) {
7962                         emrp->mrp_mask |= MRP_TX_RINGS;
7963                         emrp->mrp_ntxrings = grp->mrg_cur_count;
7964                 } else if (grp->mrg_state == MAC_GROUP_STATE_SHARED) {
7965                         mgcp = grp->mrg_clients;
7966                         while (mgcp != NULL) {
7967                                 gmcip = mgcp->mgc_client;
7968                                 emrp = MCIP_EFFECTIVE_PROPS(gmcip);
7969                                 if (emrp->mrp_mask & MRP_TX_RINGS) {
7970                                         emrp->mrp_mask &= ~MRP_TX_RINGS;
7971                                         emrp->mrp_ntxrings = 0;
7972                                 }
7973                                 mgcp = mgcp->mgc_next;
7974                         }
7975                 }
7976 
7977                 /*
7978                  * If the group is not the default group and the default
7979                  * group is reserved, the ring count in the default group
7980                  * might have changed, update it.
7981                  */
7982                 if (grp != defgrp &&
7983                     defgrp->mrg_state == MAC_GROUP_STATE_RESERVED) {
7984                         gmcip = MAC_GROUP_ONLY_CLIENT(defgrp);
7985                         emrp = MCIP_EFFECTIVE_PROPS(gmcip);
7986                         emrp->mrp_ntxrings = defgrp->mrg_cur_count;
7987                 }
7988         }
7989         emrp = MCIP_EFFECTIVE_PROPS(mcip);
7990 }
7991 
7992 /*
7993  * Check if the primary is in the default group. If so, see if we
7994  * can give it a an exclusive group now that another client is
7995  * being configured. We take the primary out of the default group
7996  * because the multicast/broadcast packets for the all the clients
7997  * will land in the default ring in the default group which means
7998  * any client in the default group, even if it is the only on in
7999  * the group, will lose exclusive access to the rings, hence
8000  * polling.
8001  */
8002 mac_client_impl_t *
8003 mac_check_primary_relocation(mac_client_impl_t *mcip, boolean_t rxhw)
8004 {
8005         mac_impl_t              *mip = mcip->mci_mip;
8006         mac_group_t             *defgrp = MAC_DEFAULT_RX_GROUP(mip);
8007         flow_entry_t            *flent = mcip->mci_flent;
8008         mac_resource_props_t    *mrp = MCIP_RESOURCE_PROPS(mcip);
8009         uint8_t                 *mac_addr;
8010         mac_group_t             *ngrp;
8011 
8012         /*
8013          * Check if the primary is in the default group, if not
8014          * or if it is explicitly configured to be in the default
8015          * group OR set the RX rings property, return.
8016          */
8017         if (flent->fe_rx_ring_group != defgrp || mrp->mrp_mask & MRP_RX_RINGS)
8018                 return (NULL);
8019 
8020         /*
8021          * If the new client needs an exclusive group and we
8022          * don't have another for the primary, return.
8023          */
8024         if (rxhw && mip->mi_rxhwclnt_avail < 2)
8025                 return (NULL);
8026 
8027         mac_addr = flent->fe_flow_desc.fd_dst_mac;
8028         /*
8029          * We call this when we are setting up the datapath for
8030          * the first non-primary.
8031          */
8032         ASSERT(mip->mi_nactiveclients == 2);
8033         /*
8034          * OK, now we have the primary that needs to be relocated.
8035          */
8036         ngrp =  mac_reserve_rx_group(mcip, mac_addr, B_TRUE);
8037         if (ngrp == NULL)
8038                 return (NULL);
8039         if (mac_rx_switch_group(mcip, defgrp, ngrp) != 0) {
8040                 mac_stop_group(ngrp);
8041                 return (NULL);
8042         }
8043         return (mcip);
8044 }
8045 
8046 void
8047 mac_transceiver_init(mac_impl_t *mip)
8048 {
8049         if (mac_capab_get((mac_handle_t)mip, MAC_CAPAB_TRANSCEIVER,
8050             &mip->mi_transceiver)) {
8051                 /*
8052                  * The driver set a flag that we don't know about. In this case,
8053                  * we need to warn about that case and ignore this capability.
8054                  */
8055                 if (mip->mi_transceiver.mct_flags != 0) {
8056                         dev_err(mip->mi_dip, CE_WARN, "driver set transceiver "
8057                             "flags to invalid value: 0x%x, ignoring "
8058                             "capability", mip->mi_transceiver.mct_flags);
8059                         bzero(&mip->mi_transceiver,
8060                             sizeof (mac_capab_transceiver_t));
8061                 }
8062         } else {
8063                         bzero(&mip->mi_transceiver,
8064                             sizeof (mac_capab_transceiver_t));
8065         }
8066 }
8067 
8068 int
8069 mac_transceiver_count(mac_handle_t mh, uint_t *countp)
8070 {
8071         mac_impl_t *mip = (mac_impl_t *)mh;
8072 
8073         ASSERT(MAC_PERIM_HELD(mh));
8074 
8075         if (mip->mi_transceiver.mct_ntransceivers == 0)
8076                 return (ENOTSUP);
8077 
8078         *countp = mip->mi_transceiver.mct_ntransceivers;
8079         return (0);
8080 }
8081 
8082 int
8083 mac_transceiver_info(mac_handle_t mh, uint_t tranid, boolean_t *present,
8084     boolean_t *usable)
8085 {
8086         int ret;
8087         mac_transceiver_info_t info;
8088 
8089         mac_impl_t *mip = (mac_impl_t *)mh;
8090 
8091         ASSERT(MAC_PERIM_HELD(mh));
8092 
8093         if (mip->mi_transceiver.mct_info == NULL ||
8094             mip->mi_transceiver.mct_ntransceivers == 0)
8095                 return (ENOTSUP);
8096 
8097         if (tranid >= mip->mi_transceiver.mct_ntransceivers)
8098                 return (EINVAL);
8099 
8100         bzero(&info, sizeof (mac_transceiver_info_t));
8101         if ((ret = mip->mi_transceiver.mct_info(mip->mi_driver, tranid,
8102             &info)) != 0) {
8103                 return (ret);
8104         }
8105 
8106         *present = info.mti_present;
8107         *usable = info.mti_usable;
8108         return (0);
8109 }
8110 
8111 int
8112 mac_transceiver_read(mac_handle_t mh, uint_t tranid, uint_t page, void *buf,
8113     size_t nbytes, off_t offset, size_t *nread)
8114 {
8115         int ret;
8116         size_t nr;
8117         mac_impl_t *mip = (mac_impl_t *)mh;
8118 
8119         ASSERT(MAC_PERIM_HELD(mh));
8120 
8121         if (mip->mi_transceiver.mct_read == NULL)
8122                 return (ENOTSUP);
8123 
8124         if (tranid >= mip->mi_transceiver.mct_ntransceivers)
8125                 return (EINVAL);
8126 
8127         /*
8128          * All supported pages today are 256 bytes wide. Make sure offset +
8129          * nbytes never exceeds that.
8130          */
8131         if (offset < 0 || offset >= 256 || nbytes > 256 ||
8132             offset + nbytes > 256)
8133                 return (EINVAL);
8134 
8135         if (nread == NULL)
8136                 nread = &nr;
8137         ret = mip->mi_transceiver.mct_read(mip->mi_driver, tranid, page, buf,
8138             nbytes, offset, nread);
8139         if (ret == 0 && *nread > nbytes) {
8140                 dev_err(mip->mi_dip, CE_PANIC, "driver wrote %lu bytes into "
8141                     "%lu byte sized buffer, possible memory corruption",
8142                     *nread, nbytes);
8143         }
8144 
8145         return (ret);
8146 }
8147 
8148 void
8149 mac_led_init(mac_impl_t *mip)
8150 {
8151         mip->mi_led_modes = MAC_LED_DEFAULT;
8152 
8153         if (!mac_capab_get((mac_handle_t)mip, MAC_CAPAB_LED, &mip->mi_led)) {
8154                 bzero(&mip->mi_led, sizeof (mac_capab_led_t));
8155                 return;
8156         }
8157 
8158         if (mip->mi_led.mcl_flags != 0) {
8159                 dev_err(mip->mi_dip, CE_WARN, "driver set led capability "
8160                     "flags to invalid value: 0x%x, ignoring "
8161                     "capability", mip->mi_transceiver.mct_flags);
8162                 bzero(&mip->mi_led, sizeof (mac_capab_led_t));
8163                 return;
8164         }
8165 
8166         if ((mip->mi_led.mcl_modes & ~MAC_LED_ALL) != 0) {
8167                 dev_err(mip->mi_dip, CE_WARN, "driver set led capability "
8168                     "supported modes to invalid value: 0x%x, ignoring "
8169                     "capability", mip->mi_transceiver.mct_flags);
8170                 bzero(&mip->mi_led, sizeof (mac_capab_led_t));
8171                 return;
8172         }
8173 }
8174 
8175 int
8176 mac_led_get(mac_handle_t mh, mac_led_mode_t *supported, mac_led_mode_t *active)
8177 {
8178         mac_impl_t *mip = (mac_impl_t *)mh;
8179 
8180         ASSERT(MAC_PERIM_HELD(mh));
8181 
8182         if (mip->mi_led.mcl_set == NULL)
8183                 return (ENOTSUP);
8184 
8185         *supported = mip->mi_led.mcl_modes;
8186         *active = mip->mi_led_modes;
8187 
8188         return (0);
8189 }
8190 
8191 /*
8192  * Update and multiplex the various LED requests. We only ever send one LED to
8193  * the underlying driver at a time. As such, we end up multiplexing all
8194  * requested states and picking one to send down to the driver.
8195  */
8196 int
8197 mac_led_set(mac_handle_t mh, mac_led_mode_t desired)
8198 {
8199         int ret;
8200         mac_led_mode_t driver;
8201 
8202         mac_impl_t *mip = (mac_impl_t *)mh;
8203 
8204         ASSERT(MAC_PERIM_HELD(mh));
8205 
8206         /*
8207          * If we've been passed a desired value of zero, that indicates that
8208          * we're basically resetting to the value of zero, which is our default
8209          * value.
8210          */
8211         if (desired == 0)
8212                 desired = MAC_LED_DEFAULT;
8213 
8214         if (mip->mi_led.mcl_set == NULL)
8215                 return (ENOTSUP);
8216 
8217         /*
8218          * Catch both values that we don't know about and those that the driver
8219          * doesn't support.
8220          */
8221         if ((desired & ~MAC_LED_ALL) != 0)
8222                 return (EINVAL);
8223 
8224         if ((desired & ~mip->mi_led.mcl_modes) != 0)
8225                 return (ENOTSUP);
8226 
8227         /*
8228          * If we have the same value, then there is nothing to do.
8229          */
8230         if (desired == mip->mi_led_modes)
8231                 return (0);
8232 
8233         /*
8234          * Based on the desired value, determine what to send to the driver. We
8235          * only will send a single bit to the driver at any given time. IDENT
8236          * takes priority over OFF or ON. We also let OFF take priority over the
8237          * rest.
8238          */
8239         if (desired & MAC_LED_IDENT) {
8240                 driver = MAC_LED_IDENT;
8241         } else if (desired & MAC_LED_OFF) {
8242                 driver = MAC_LED_OFF;
8243         } else if (desired & MAC_LED_ON) {
8244                 driver = MAC_LED_ON;
8245         } else {
8246                 driver = MAC_LED_DEFAULT;
8247         }
8248 
8249         if ((ret = mip->mi_led.mcl_set(mip->mi_driver, driver, 0)) == 0) {
8250                 mip->mi_led_modes = desired;
8251         }
8252 
8253         return (ret);
8254 }