1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/sysmacros.h>
28 #include <sys/conf.h>
29 #include <sys/cmn_err.h>
30 #include <sys/list.h>
31 #include <sys/kmem.h>
32 #include <sys/stream.h>
33 #include <sys/modctl.h>
34 #include <sys/ddi.h>
35 #include <sys/sunddi.h>
36 #include <sys/atomic.h>
37 #include <sys/stat.h>
38 #include <sys/modhash.h>
39 #include <sys/strsubr.h>
40 #include <sys/strsun.h>
41 #include <sys/sdt.h>
42 #include <sys/mac.h>
43 #include <sys/mac_impl.h>
44 #include <sys/mac_client_impl.h>
45 #include <sys/mac_client_priv.h>
46 #include <sys/mac_flow_impl.h>
47
48 /*
49 * Broadcast and multicast traffic must be distributed to the MAC clients
50 * that are defined on top of the same MAC. The set of
51 * destinations to which a multicast packet must be sent is a subset
52 * of all MAC clients defined on top of the MAC. A MAC client can be member
53 * of more than one such subset.
54 *
55 * To accomodate these requirements, we introduce broadcast groups.
56 * A broadcast group is associated with a broadcast or multicast
57 * address. The members of a broadcast group consist of the MAC clients
58 * that should received copies of packets sent to the address
59 * associated with the group, and are defined on top of the
60 * same MAC.
61 *
62 * The broadcast groups defined on top of a MAC are chained,
63 * hanging off the mac_impl_t. The broadcast group id's are
64 * unique globally (tracked by mac_bcast_id).
65 */
66
67 /*
68 * The same MAC client may be added for different <addr,vid> tuple,
69 * we maintain a ref count for the number of times it has been added
70 * to account for deleting the MAC client from the group.
71 */
72 typedef struct mac_bcast_grp_mcip_s {
73 mac_client_impl_t *mgb_client;
74 int mgb_client_ref;
75 } mac_bcast_grp_mcip_t;
76
77 typedef struct mac_bcast_grp_s { /* Protected by */
78 struct mac_bcast_grp_s *mbg_next; /* SL */
79 void *mbg_addr; /* SL */
80 uint16_t mbg_vid; /* SL */
81 mac_impl_t *mbg_mac_impl; /* WO */
82 mac_addrtype_t mbg_addrtype; /* WO */
83 flow_entry_t *mbg_flow_ent; /* WO */
84 mac_bcast_grp_mcip_t *mbg_clients; /* mi_rw_lock */
85 uint_t mbg_nclients; /* mi_rw_lock */
86 uint_t mbg_nclients_alloc; /* SL */
87 uint64_t mbg_clients_gen; /* mi_rw_lock */
88 uint32_t mbg_id; /* atomic */
89 } mac_bcast_grp_t;
90
91 static kmem_cache_t *mac_bcast_grp_cache;
92 static uint32_t mac_bcast_id = 0;
93
94 void
95 mac_bcast_init(void)
96 {
97 mac_bcast_grp_cache = kmem_cache_create("mac_bcast_grp_cache",
98 sizeof (mac_bcast_grp_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
99 }
100
101 void
102 mac_bcast_fini(void)
103 {
104 kmem_cache_destroy(mac_bcast_grp_cache);
105 }
106
107 mac_impl_t *
108 mac_bcast_grp_mip(void *grp)
109 {
110 mac_bcast_grp_t *bcast_grp = grp;
111
112 return (bcast_grp->mbg_mac_impl);
113 }
114
115 /*
116 * Free the specific broadcast group. Invoked when the last reference
117 * to the group is released.
118 */
119 void
120 mac_bcast_grp_free(void *bcast_grp)
121 {
122 mac_bcast_grp_t *grp = bcast_grp;
123 mac_impl_t *mip = grp->mbg_mac_impl;
124
125 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
126
127 ASSERT(grp->mbg_addr != NULL);
128 kmem_free(grp->mbg_addr, mip->mi_type->mt_addr_length);
129 kmem_free(grp->mbg_clients,
130 grp->mbg_nclients_alloc * sizeof (mac_bcast_grp_mcip_t));
131 mip->mi_bcast_ngrps--;
132 kmem_cache_free(mac_bcast_grp_cache, grp);
133 }
134
135 /*
136 * arg1: broadcast group
137 * arg2: sender MAC client if it is being sent by a MAC client,
138 * NULL if it was received from the wire.
139 */
140 void
141 mac_bcast_send(void *arg1, void *arg2, mblk_t *mp_chain, boolean_t is_loopback)
142 {
143 mac_bcast_grp_t *grp = arg1;
144 mac_client_impl_t *src_mcip = arg2, *dst_mcip;
145 mac_impl_t *mip = grp->mbg_mac_impl;
146 uint64_t gen;
147 uint_t i;
148 mblk_t *mp_chain1;
149 flow_entry_t *flent;
150 int err;
151
152 rw_enter(&mip->mi_rw_lock, RW_READER);
153
154 /*
155 * Pass a copy of the mp chain to every MAC client except the sender
156 * MAC client, if the packet was not received from the underlying NIC.
157 *
158 * The broadcast group lock should not be held across calls to
159 * the flow's callback function, since the same group could
160 * potentially be accessed from the same context. When the lock
161 * is reacquired, changes to the broadcast group while the lock
162 * was released are caught using a generation counter incremented
163 * each time the list of MAC clients associated with the broadcast
164 * group is changed.
165 */
166 for (i = 0; i < grp->mbg_nclients_alloc; i++) {
167 dst_mcip = grp->mbg_clients[i].mgb_client;
168 if (dst_mcip == NULL)
169 continue;
170 flent = dst_mcip->mci_flent;
171 if (flent == NULL || dst_mcip == src_mcip) {
172 /*
173 * Don't send a copy of the packet back to
174 * its sender.
175 */
176 continue;
177 }
178
179 /*
180 * It is important to hold a reference on the
181 * flow_ent here.
182 */
183 if ((mp_chain1 = mac_copymsgchain_cksum(mp_chain)) == NULL)
184 break;
185 /*
186 * Fix the checksum for packets originating
187 * from the local machine.
188 */
189 if ((src_mcip != NULL) &&
190 (mp_chain1 = mac_fix_cksum(mp_chain1)) == NULL)
191 break;
192
193 FLOW_TRY_REFHOLD(flent, err);
194 if (err != 0) {
195 freemsgchain(mp_chain1);
196 continue;
197 }
198
199 gen = grp->mbg_clients_gen;
200
201 rw_exit(&mip->mi_rw_lock);
202
203 DTRACE_PROBE4(mac__bcast__send__to, mac_client_impl_t *,
204 src_mcip, flow_fn_t, dst_mcip->mci_flent->fe_cb_fn,
205 void *, dst_mcip->mci_flent->fe_cb_arg1,
206 void *, dst_mcip->mci_flent->fe_cb_arg2);
207
208 (dst_mcip->mci_flent->fe_cb_fn)(dst_mcip->mci_flent->fe_cb_arg1,
209 dst_mcip->mci_flent->fe_cb_arg2, mp_chain1, is_loopback);
210 FLOW_REFRELE(flent);
211
212 rw_enter(&mip->mi_rw_lock, RW_READER);
213
214 /* update stats */
215 if (grp->mbg_addrtype == MAC_ADDRTYPE_MULTICAST) {
216 MCIP_STAT_UPDATE(dst_mcip, multircv, 1);
217 MCIP_STAT_UPDATE(dst_mcip, multircvbytes,
218 msgdsize(mp_chain));
219 } else {
220 MCIP_STAT_UPDATE(dst_mcip, brdcstrcv, 1);
221 MCIP_STAT_UPDATE(dst_mcip, brdcstrcvbytes,
222 msgdsize(mp_chain));
223 }
224
225 if (grp->mbg_clients_gen != gen) {
226 /*
227 * The list of MAC clients associated with the group
228 * was changed while the lock was released.
229 * Give up on the current packet.
230 */
231 rw_exit(&mip->mi_rw_lock);
232 freemsgchain(mp_chain);
233 return;
234 }
235 }
236 rw_exit(&mip->mi_rw_lock);
237
238 if (src_mcip != NULL) {
239 /*
240 * The packet was sent from one of the MAC clients,
241 * so we need to send a copy of the packet to the
242 * underlying NIC so that it can be sent on the wire.
243 */
244 MCIP_STAT_UPDATE(src_mcip, multixmt, 1);
245 MCIP_STAT_UPDATE(src_mcip, multixmtbytes, msgdsize(mp_chain));
246 MCIP_STAT_UPDATE(src_mcip, brdcstxmt, 1);
247 MCIP_STAT_UPDATE(src_mcip, brdcstxmtbytes, msgdsize(mp_chain));
248
249 MAC_TX(mip, mip->mi_default_tx_ring, mp_chain, src_mcip);
250 if (mp_chain != NULL)
251 freemsgchain(mp_chain);
252 } else {
253 freemsgchain(mp_chain);
254 }
255 }
256
257 /*
258 * Add the specified MAC client to the group corresponding to the specified
259 * broadcast or multicast address.
260 * Return 0 on success, or an errno value on failure.
261 */
262 int
263 mac_bcast_add(mac_client_impl_t *mcip, const uint8_t *addr, uint16_t vid,
264 mac_addrtype_t addrtype)
265 {
266 mac_impl_t *mip = mcip->mci_mip;
267 mac_bcast_grp_t *grp = NULL, **last_grp;
268 size_t addr_len = mip->mi_type->mt_addr_length;
269 int rc = 0;
270 int i, index = -1;
271 mac_mcast_addrs_t **prev_mi_addr = NULL;
272 mac_mcast_addrs_t **prev_mci_addr = NULL;
273
274 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
275
276 ASSERT(addrtype == MAC_ADDRTYPE_MULTICAST ||
277 addrtype == MAC_ADDRTYPE_BROADCAST);
278
279 /*
280 * Add the MAC client to the list of MAC clients associated
281 * with the group.
282 */
283 if (addrtype == MAC_ADDRTYPE_MULTICAST) {
284 mac_mcast_addrs_t *maddr;
285
286 /*
287 * In case of a driver (say aggr), we need this information
288 * on a per MAC instance basis.
289 */
290 prev_mi_addr = &mip->mi_mcast_addrs;
291 for (maddr = *prev_mi_addr; maddr != NULL;
292 prev_mi_addr = &maddr->mma_next, maddr = maddr->mma_next) {
293 if (bcmp(maddr->mma_addr, addr, addr_len) == 0)
294 break;
295 }
296 if (maddr == NULL) {
297 /*
298 * For multicast addresses, have the underlying MAC
299 * join the corresponding multicast group.
300 */
301 rc = mip->mi_multicst(mip->mi_driver, B_TRUE, addr);
302 if (rc != 0)
303 return (rc);
304 maddr = kmem_zalloc(sizeof (mac_mcast_addrs_t),
305 KM_SLEEP);
306 bcopy(addr, maddr->mma_addr, addr_len);
307 *prev_mi_addr = maddr;
308 } else {
309 prev_mi_addr = NULL;
310 }
311 maddr->mma_ref++;
312
313 /*
314 * We maintain a separate list for each MAC client. Get
315 * the entry or add, if it is not present.
316 */
317 prev_mci_addr = &mcip->mci_mcast_addrs;
318 for (maddr = *prev_mci_addr; maddr != NULL;
319 prev_mci_addr = &maddr->mma_next, maddr = maddr->mma_next) {
320 if (bcmp(maddr->mma_addr, addr, addr_len) == 0)
321 break;
322 }
323 if (maddr == NULL) {
324 maddr = kmem_zalloc(sizeof (mac_mcast_addrs_t),
325 KM_SLEEP);
326 bcopy(addr, maddr->mma_addr, addr_len);
327 *prev_mci_addr = maddr;
328 } else {
329 prev_mci_addr = NULL;
330 }
331 maddr->mma_ref++;
332 }
333
334 /* The list is protected by the perimeter */
335 last_grp = &mip->mi_bcast_grp;
336 for (grp = *last_grp; grp != NULL;
337 last_grp = &grp->mbg_next, grp = grp->mbg_next) {
338 if (bcmp(grp->mbg_addr, addr, addr_len) == 0 &&
339 grp->mbg_vid == vid)
340 break;
341 }
342
343 if (grp == NULL) {
344 /*
345 * The group does not yet exist, create it.
346 */
347 flow_desc_t flow_desc;
348 char flow_name[MAXFLOWNAMELEN];
349
350 grp = kmem_cache_alloc(mac_bcast_grp_cache, KM_SLEEP);
351 bzero(grp, sizeof (mac_bcast_grp_t));
352 grp->mbg_next = NULL;
353 grp->mbg_mac_impl = mip;
354
355 DTRACE_PROBE1(mac__bcast__add__new__group, mac_bcast_grp_t *,
356 grp);
357
358 grp->mbg_addr = kmem_zalloc(addr_len, KM_SLEEP);
359 bcopy(addr, grp->mbg_addr, addr_len);
360 grp->mbg_addrtype = addrtype;
361 grp->mbg_vid = vid;
362
363 /*
364 * Add a new flow to the underlying MAC.
365 */
366 bzero(&flow_desc, sizeof (flow_desc));
367 bcopy(addr, &flow_desc.fd_dst_mac, addr_len);
368 flow_desc.fd_mac_len = (uint32_t)addr_len;
369
370 flow_desc.fd_mask = FLOW_LINK_DST;
371 if (vid != 0) {
372 flow_desc.fd_vid = vid;
373 flow_desc.fd_mask |= FLOW_LINK_VID;
374 }
375
376 grp->mbg_id = atomic_add_32_nv(&mac_bcast_id, 1);
377 (void) sprintf(flow_name,
378 "mac/%s/mcast%d", mip->mi_name, grp->mbg_id);
379
380 rc = mac_flow_create(&flow_desc, NULL, flow_name,
381 grp, FLOW_MCAST, &grp->mbg_flow_ent);
382 if (rc != 0) {
383 kmem_free(grp->mbg_addr, addr_len);
384 kmem_cache_free(mac_bcast_grp_cache, grp);
385 goto fail;
386 }
387 grp->mbg_flow_ent->fe_mbg = grp;
388 mip->mi_bcast_ngrps++;
389
390 /*
391 * Initial creation reference on the flow. This is released
392 * in the corresponding delete action i_mac_bcast_delete()
393 */
394 FLOW_REFHOLD(grp->mbg_flow_ent);
395
396 /*
397 * When the multicast and broadcast packet is received
398 * by the underlying NIC, mac_rx_classify() will invoke
399 * mac_bcast_send() with arg2=NULL, which will cause
400 * mac_bcast_send() to send a copy of the packet(s)
401 * to every MAC client opened on top of the underlying MAC.
402 *
403 * When the mac_bcast_send() function is invoked from
404 * the transmit path of a MAC client, it will specify the
405 * transmitting MAC client as the arg2 value, which will
406 * allow mac_bcast_send() to skip that MAC client and not
407 * send it a copy of the packet.
408 *
409 * We program the classifier to dispatch matching broadcast
410 * packets to mac_bcast_send().
411 */
412
413 grp->mbg_flow_ent->fe_cb_fn = mac_bcast_send;
414 grp->mbg_flow_ent->fe_cb_arg1 = grp;
415 grp->mbg_flow_ent->fe_cb_arg2 = NULL;
416
417 rc = mac_flow_add(mip->mi_flow_tab, grp->mbg_flow_ent);
418 if (rc != 0) {
419 FLOW_FINAL_REFRELE(grp->mbg_flow_ent);
420 goto fail;
421 }
422
423 *last_grp = grp;
424 }
425
426 ASSERT(grp->mbg_addrtype == addrtype);
427
428 /*
429 * Add the MAC client to the list of MAC clients associated
430 * with the group.
431 */
432 rw_enter(&mip->mi_rw_lock, RW_WRITER);
433 for (i = 0; i < grp->mbg_nclients_alloc; i++) {
434 /*
435 * The MAC client was already added, say when we have
436 * different unicast addresses with the same vid.
437 * Just increment the ref and we are done.
438 */
439 if (grp->mbg_clients[i].mgb_client == mcip) {
440 grp->mbg_clients[i].mgb_client_ref++;
441 rw_exit(&mip->mi_rw_lock);
442 return (0);
443 } else if (grp->mbg_clients[i].mgb_client == NULL &&
444 index == -1) {
445 index = i;
446 }
447 }
448 if (grp->mbg_nclients_alloc == grp->mbg_nclients) {
449 mac_bcast_grp_mcip_t *new_clients;
450 uint_t new_size = grp->mbg_nclients+1;
451
452 new_clients = kmem_zalloc(new_size *
453 sizeof (mac_bcast_grp_mcip_t), KM_SLEEP);
454
455 if (grp->mbg_nclients > 0) {
456 ASSERT(grp->mbg_clients != NULL);
457 bcopy(grp->mbg_clients, new_clients, grp->mbg_nclients *
458 sizeof (mac_bcast_grp_mcip_t));
459 kmem_free(grp->mbg_clients, grp->mbg_nclients *
460 sizeof (mac_bcast_grp_mcip_t));
461 }
462
463 grp->mbg_clients = new_clients;
464 grp->mbg_nclients_alloc = new_size;
465 index = new_size - 1;
466 }
467
468 ASSERT(index != -1);
469 grp->mbg_clients[index].mgb_client = mcip;
470 grp->mbg_clients[index].mgb_client_ref = 1;
471 grp->mbg_nclients++;
472 /*
473 * Since we're adding to the list of MAC clients using that group,
474 * kick the generation count, which will allow mac_bcast_send()
475 * to detect that condition after re-acquiring the lock.
476 */
477 grp->mbg_clients_gen++;
478 rw_exit(&mip->mi_rw_lock);
479 return (0);
480
481 fail:
482 if (prev_mi_addr != NULL) {
483 kmem_free(*prev_mi_addr, sizeof (mac_mcast_addrs_t));
484 *prev_mi_addr = NULL;
485 (void) mip->mi_multicst(mip->mi_driver, B_FALSE, addr);
486 }
487 if (prev_mci_addr != NULL) {
488 kmem_free(*prev_mci_addr, sizeof (mac_mcast_addrs_t));
489 *prev_mci_addr = NULL;
490 }
491 return (rc);
492 }
493
494 /*
495 * Remove the specified MAC client from the group corresponding to
496 * the specific broadcast or multicast address.
497 *
498 * Note: mac_bcast_delete() calls mac_remove_flow() which
499 * will call cv_wait for fe_refcnt to drop to 0. So this function
500 * should not be called from interrupt or STREAMS context.
501 */
502 void
503 mac_bcast_delete(mac_client_impl_t *mcip, const uint8_t *addr, uint16_t vid)
504 {
505 mac_impl_t *mip = mcip->mci_mip;
506 mac_bcast_grp_t *grp = NULL, **prev;
507 size_t addr_len = mip->mi_type->mt_addr_length;
508 flow_entry_t *flent;
509 uint_t i;
510 mac_mcast_addrs_t *maddr = NULL;
511 mac_mcast_addrs_t **mprev;
512
513 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
514
515 /* find the broadcast group. The list is protected by the perimeter */
516 prev = &mip->mi_bcast_grp;
517 for (grp = mip->mi_bcast_grp; grp != NULL; prev = &grp->mbg_next,
518 grp = grp->mbg_next) {
519 if (bcmp(grp->mbg_addr, addr, addr_len) == 0 &&
520 grp->mbg_vid == vid)
521 break;
522 }
523 ASSERT(grp != NULL);
524
525 /*
526 * Remove the MAC client from the list of MAC clients associated
527 * with that broadcast group.
528 *
529 * We mark the mbg_clients[] location corresponding to the removed MAC
530 * client NULL and reuse that location when we add a new MAC client.
531 */
532
533 rw_enter(&mip->mi_rw_lock, RW_WRITER);
534
535 for (i = 0; i < grp->mbg_nclients_alloc; i++) {
536 if (grp->mbg_clients[i].mgb_client == mcip)
537 break;
538 }
539
540 ASSERT(i < grp->mbg_nclients_alloc);
541 /*
542 * If there are more references to this MAC client, then we let
543 * it remain till it goes to 0.
544 */
545 if (--grp->mbg_clients[i].mgb_client_ref > 0)
546 goto update_maddr;
547
548 grp->mbg_clients[i].mgb_client = NULL;
549 grp->mbg_clients[i].mgb_client_ref = 0;
550
551 /*
552 * Since we're removing from the list of MAC clients using that group,
553 * kick the generation count, which will allow mac_bcast_send()
554 * to detect that condition.
555 */
556 grp->mbg_clients_gen++;
557
558 if (--grp->mbg_nclients == 0) {
559 /*
560 * The last MAC client of the group was just removed.
561 * Unlink the current group from the list of groups
562 * defined on top of the underlying NIC. The group
563 * structure will stay around until the last reference
564 * is dropped.
565 */
566 *prev = grp->mbg_next;
567 }
568 update_maddr:
569 rw_exit(&mip->mi_rw_lock);
570
571 if (grp->mbg_addrtype == MAC_ADDRTYPE_MULTICAST) {
572 mprev = &mcip->mci_mcast_addrs;
573 for (maddr = mcip->mci_mcast_addrs; maddr != NULL;
574 mprev = &maddr->mma_next, maddr = maddr->mma_next) {
575 if (bcmp(grp->mbg_addr, maddr->mma_addr,
576 mip->mi_type->mt_addr_length) == 0)
577 break;
578 }
579 ASSERT(maddr != NULL);
580 if (--maddr->mma_ref == 0) {
581 *mprev = maddr->mma_next;
582 maddr->mma_next = NULL;
583 kmem_free(maddr, sizeof (mac_mcast_addrs_t));
584 }
585
586 mprev = &mip->mi_mcast_addrs;
587 for (maddr = mip->mi_mcast_addrs; maddr != NULL;
588 mprev = &maddr->mma_next, maddr = maddr->mma_next) {
589 if (bcmp(grp->mbg_addr, maddr->mma_addr,
590 mip->mi_type->mt_addr_length) == 0)
591 break;
592 }
593 ASSERT(maddr != NULL);
594 if (--maddr->mma_ref == 0) {
595 (void) mip->mi_multicst(mip->mi_driver, B_FALSE, addr);
596 *mprev = maddr->mma_next;
597 maddr->mma_next = NULL;
598 kmem_free(maddr, sizeof (mac_mcast_addrs_t));
599 }
600 }
601
602 /*
603 * If the group itself is being removed, remove the
604 * corresponding flow from the underlying NIC.
605 */
606 flent = grp->mbg_flow_ent;
607 if (grp->mbg_nclients == 0) {
608 mac_flow_remove(mip->mi_flow_tab, flent, B_FALSE);
609 mac_flow_wait(flent, FLOW_DRIVER_UPCALL);
610 FLOW_FINAL_REFRELE(flent);
611 }
612 }
613
614 /*
615 * This will be called by a driver, such as aggr, when a port is added/removed
616 * to add/remove the port to/from all the multcast addresses for that aggr.
617 */
618 void
619 mac_bcast_refresh(mac_impl_t *mip, mac_multicst_t refresh_fn, void *arg,
620 boolean_t add)
621 {
622 mac_mcast_addrs_t *grp, *next;
623
624 ASSERT(refresh_fn != NULL);
625
626 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
627
628 /*
629 * Walk the multicast address list and call the refresh function for
630 * each address.
631 */
632
633 for (grp = mip->mi_mcast_addrs; grp != NULL; grp = next) {
634 /*
635 * Save the next pointer just in case the refresh
636 * function's action causes the group entry to be
637 * freed.
638 * We won't be adding to this list as part of the
639 * refresh.
640 */
641 next = grp->mma_next;
642 refresh_fn(arg, add, grp->mma_addr);
643 }
644 }
645
646 /*
647 * Walk the MAC client's multicast address list and add/remove the addr/vid
648 * ('arg' is 'flent') to all the addresses.
649 */
650 void
651 mac_client_bcast_refresh(mac_client_impl_t *mcip, mac_multicst_t refresh_fn,
652 void *arg, boolean_t add)
653 {
654 mac_mcast_addrs_t *grp, *next;
655 mac_impl_t *mip = mcip->mci_mip;
656
657 ASSERT(refresh_fn != NULL);
658
659 ASSERT(MAC_PERIM_HELD((mac_handle_t)mip));
660 /*
661 * Walk the multicast address list and call the refresh function for
662 * each address.
663 * Broadcast addresses are not added or removed through the multicast
664 * entry points, so don't include them as part of the refresh.
665 */
666 for (grp = mcip->mci_mcast_addrs; grp != NULL; grp = next) {
667 /*
668 * Save the next pointer just in case the refresh
669 * function's action causes the group entry to be
670 * freed.
671 * We won't be adding to this list as part of the
672 * refresh.
673 */
674 next = grp->mma_next;
675 refresh_fn(arg, add, grp->mma_addr);
676 }
677 }