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