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