1 /*
2 * net/core/dev_addr_lists.c - Functions for handling net device lists
3 * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
4 *
5 * This file contains functions for working with unicast, multicast and device
6 * addresses lists.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 */
13
14 #include <linux/netdevice.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/export.h>
17 #include <linux/list.h>
18
19 /*
20 * General list handling functions
21 */
22
23 static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
24 const unsigned char *addr, int addr_len,
25 unsigned char addr_type, bool global,
26 bool sync)
27 {
28 struct netdev_hw_addr *ha;
29 int alloc_size;
30
31 alloc_size = sizeof(*ha);
32 if (alloc_size < L1_CACHE_BYTES)
33 alloc_size = L1_CACHE_BYTES;
34 ha = kmalloc(alloc_size, GFP_ATOMIC);
35 if (!ha)
36 return -ENOMEM;
37 memcpy(ha->addr, addr, addr_len);
38 ha->type = addr_type;
39 ha->refcount = 1;
40 ha->global_use = global;
41 ha->synced = sync ? 1 : 0;
42 ha->sync_cnt = 0;
43 list_add_tail_rcu(&ha->list, &list->list);
44 list->count++;
45
46 return 0;
47 }
48
49 static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
50 const unsigned char *addr, int addr_len,
51 unsigned char addr_type, bool global, bool sync,
52 int sync_count)
53 {
54 struct netdev_hw_addr *ha;
55
56 if (addr_len > MAX_ADDR_LEN)
57 return -EINVAL;
58
59 list_for_each_entry(ha, &list->list, list) {
60 if (ha->type == addr_type &&
61 !memcmp(ha->addr, addr, addr_len)) {
62 if (global) {
63 /* check if addr is already used as global */
64 if (ha->global_use)
65 return 0;
66 else
67 ha->global_use = true;
68 }
69 if (sync) {
70 if (ha->synced && sync_count)
71 return -EEXIST;
72 else
73 ha->synced++;
74 }
75 ha->refcount++;
76 return 0;
77 }
78 }
79
80 return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
81 sync);
82 }
83
84 static int __hw_addr_add(struct netdev_hw_addr_list *list,
85 const unsigned char *addr, int addr_len,
86 unsigned char addr_type)
87 {
88 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
89 0);
90 }
91
92 static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
93 struct netdev_hw_addr *ha, bool global,
94 bool sync)
95 {
96 if (global && !ha->global_use)
97 return -ENOENT;
98
99 if (sync && !ha->synced)
100 return -ENOENT;
101
102 if (global)
103 ha->global_use = false;
104
105 if (sync)
106 ha->synced--;
107
108 if (--ha->refcount)
109 return 0;
110 list_del_rcu(&ha->list);
111 kfree_rcu(ha, rcu_head);
112 list->count--;
113 return 0;
114 }
115
116 static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
117 const unsigned char *addr, int addr_len,
118 unsigned char addr_type, bool global, bool sync)
119 {
120 struct netdev_hw_addr *ha;
121
122 list_for_each_entry(ha, &list->list, list) {
123 if (!memcmp(ha->addr, addr, addr_len) &&
124 (ha->type == addr_type || !addr_type))
125 return __hw_addr_del_entry(list, ha, global, sync);
126 }
127 return -ENOENT;
128 }
129
130 static int __hw_addr_del(struct netdev_hw_addr_list *list,
131 const unsigned char *addr, int addr_len,
132 unsigned char addr_type)
133 {
134 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
135 }
136
137 static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
138 struct netdev_hw_addr *ha,
139 int addr_len)
140 {
141 int err;
142
143 err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
144 false, true, ha->sync_cnt);
145 if (err && err != -EEXIST)
146 return err;
147
148 if (!err) {
149 ha->sync_cnt++;
150 ha->refcount++;
151 }
152
153 return 0;
154 }
155
156 static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
157 struct netdev_hw_addr_list *from_list,
158 struct netdev_hw_addr *ha,
159 int addr_len)
160 {
161 int err;
162
163 err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
164 false, true);
165 if (err)
166 return;
167 ha->sync_cnt--;
168 /* address on from list is not marked synced */
169 __hw_addr_del_entry(from_list, ha, false, false);
170 }
171
172 static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
173 struct netdev_hw_addr_list *from_list,
174 int addr_len)
175 {
176 int err = 0;
177 struct netdev_hw_addr *ha, *tmp;
178
179 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
180 if (ha->sync_cnt == ha->refcount) {
181 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
182 } else {
183 err = __hw_addr_sync_one(to_list, ha, addr_len);
184 if (err)
185 break;
186 }
187 }
188 return err;
189 }
190
191 /* This function only works where there is a strict 1-1 relationship
192 * between source and destionation of they synch. If you ever need to
193 * sync addresses to more then 1 destination, you need to use
194 * __hw_addr_sync_multiple().
195 */
196 int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
197 struct netdev_hw_addr_list *from_list,
198 int addr_len)
199 {
200 int err = 0;
201 struct netdev_hw_addr *ha, *tmp;
202
203 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
204 if (!ha->sync_cnt) {
205 err = __hw_addr_sync_one(to_list, ha, addr_len);
206 if (err)
207 break;
208 } else if (ha->refcount == 1)
209 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
210 }
211 return err;
212 }
213 EXPORT_SYMBOL(__hw_addr_sync);
214
215 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
216 struct netdev_hw_addr_list *from_list,
217 int addr_len)
218 {
219 struct netdev_hw_addr *ha, *tmp;
220
221 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
222 if (ha->sync_cnt)
223 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
224 }
225 }
226 EXPORT_SYMBOL(__hw_addr_unsync);
227
228 /**
229 * __hw_addr_sync_dev - Synchonize device's multicast list
230 * @list: address list to syncronize
231 * @dev: device to sync
232 * @sync: function to call if address should be added
233 * @unsync: function to call if address should be removed
234 *
235 * This funciton is intended to be called from the ndo_set_rx_mode
236 * function of devices that require explicit address add/remove
237 * notifications. The unsync function may be NULL in which case
238 * the addresses requiring removal will simply be removed without
239 * any notification to the device.
240 **/
241 int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
242 struct net_device *dev,
243 int (*sync)(struct net_device *, const unsigned char *),
244 int (*unsync)(struct net_device *,
245 const unsigned char *))
246 {
247 struct netdev_hw_addr *ha, *tmp;
248 int err;
249
250 /* first go through and flush out any stale entries */
251 list_for_each_entry_safe(ha, tmp, &list->list, list) {
252 if (!ha->sync_cnt || ha->refcount != 1)
253 continue;
254
255 /* if unsync is defined and fails defer unsyncing address */
256 if (unsync && unsync(dev, ha->addr))
257 continue;
258
259 ha->sync_cnt--;
260 __hw_addr_del_entry(list, ha, false, false);
261 }
262
263 /* go through and sync new entries to the list */
264 list_for_each_entry_safe(ha, tmp, &list->list, list) {
265 if (ha->sync_cnt)
266 continue;
267
268 err = sync(dev, ha->addr);
269 if (err)
270 return err;
271
272 ha->sync_cnt++;
273 ha->refcount++;
274 }
275
276 return 0;
277 }
278 EXPORT_SYMBOL(__hw_addr_sync_dev);
279
280 /**
281 * __hw_addr_ref_sync_dev - Synchronize device's multicast address list taking
282 * into account references
283 * @list: address list to synchronize
284 * @dev: device to sync
285 * @sync: function to call if address or reference on it should be added
286 * @unsync: function to call if address or some reference on it should removed
287 *
288 * This function is intended to be called from the ndo_set_rx_mode
289 * function of devices that require explicit address or references on it
290 * add/remove notifications. The unsync function may be NULL in which case
291 * the addresses or references on it requiring removal will simply be
292 * removed without any notification to the device. That is responsibility of
293 * the driver to identify and distribute address or references on it between
294 * internal address tables.
295 **/
296 int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
297 struct net_device *dev,
298 int (*sync)(struct net_device *,
299 const unsigned char *, int),
300 int (*unsync)(struct net_device *,
301 const unsigned char *, int))
302 {
303 struct netdev_hw_addr *ha, *tmp;
304 int err, ref_cnt;
305
306 /* first go through and flush out any unsynced/stale entries */
307 list_for_each_entry_safe(ha, tmp, &list->list, list) {
308 /* sync if address is not used */
309 if ((ha->sync_cnt << 1) <= ha->refcount)
310 continue;
311
312 /* if fails defer unsyncing address */
313 ref_cnt = ha->refcount - ha->sync_cnt;
314 if (unsync && unsync(dev, ha->addr, ref_cnt))
315 continue;
316
317 ha->refcount = (ref_cnt << 1) + 1;
318 ha->sync_cnt = ref_cnt;
319 __hw_addr_del_entry(list, ha, false, false);
320 }
321
322 /* go through and sync updated/new entries to the list */
323 list_for_each_entry_safe(ha, tmp, &list->list, list) {
324 /* sync if address added or reused */
325 if ((ha->sync_cnt << 1) >= ha->refcount)
326 continue;
327
328 ref_cnt = ha->refcount - ha->sync_cnt;
329 err = sync(dev, ha->addr, ref_cnt);
330 if (err)
331 return err;
332
333 ha->refcount = ref_cnt << 1;
334 ha->sync_cnt = ref_cnt;
335 }
336
337 return 0;
338 }
339 EXPORT_SYMBOL(__hw_addr_ref_sync_dev);
340
341 /**
342 * __hw_addr_ref_unsync_dev - Remove synchronized addresses and references on
343 * it from device
344 * @list: address list to remove synchronized addresses (references on it) from
345 * @dev: device to sync
346 * @unsync: function to call if address and references on it should be removed
347 *
348 * Remove all addresses that were added to the device by
349 * __hw_addr_ref_sync_dev(). This function is intended to be called from the
350 * ndo_stop or ndo_open functions on devices that require explicit address (or
351 * references on it) add/remove notifications. If the unsync function pointer
352 * is NULL then this function can be used to just reset the sync_cnt for the
353 * addresses in the list.
354 **/
355 void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
356 struct net_device *dev,
357 int (*unsync)(struct net_device *,
358 const unsigned char *, int))
359 {
360 struct netdev_hw_addr *ha, *tmp;
361
362 list_for_each_entry_safe(ha, tmp, &list->list, list) {
363 if (!ha->sync_cnt)
364 continue;
365
366 /* if fails defer unsyncing address */
367 if (unsync && unsync(dev, ha->addr, ha->sync_cnt))
368 continue;
369
370 ha->refcount -= ha->sync_cnt - 1;
371 ha->sync_cnt = 0;
372 __hw_addr_del_entry(list, ha, false, false);
373 }
374 }
375 EXPORT_SYMBOL(__hw_addr_ref_unsync_dev);
376
377 /**
378 * __hw_addr_unsync_dev - Remove synchronized addresses from device
379 * @list: address list to remove synchronized addresses from
380 * @dev: device to sync
381 * @unsync: function to call if address should be removed
382 *
383 * Remove all addresses that were added to the device by __hw_addr_sync_dev().
384 * This function is intended to be called from the ndo_stop or ndo_open
385 * functions on devices that require explicit address add/remove
386 * notifications. If the unsync function pointer is NULL then this function
387 * can be used to just reset the sync_cnt for the addresses in the list.
388 **/
389 void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
390 struct net_device *dev,
391 int (*unsync)(struct net_device *,
392 const unsigned char *))
393 {
394 struct netdev_hw_addr *ha, *tmp;
395
396 list_for_each_entry_safe(ha, tmp, &list->list, list) {
397 if (!ha->sync_cnt)
398 continue;
399
400 /* if unsync is defined and fails defer unsyncing address */
401 if (unsync && unsync(dev, ha->addr))
402 continue;
403
404 ha->sync_cnt--;
405 __hw_addr_del_entry(list, ha, false, false);
406 }
407 }
408 EXPORT_SYMBOL(__hw_addr_unsync_dev);
409
410 static void __hw_addr_flush(struct netdev_hw_addr_list *list)
411 {
412 struct netdev_hw_addr *ha, *tmp;
413
414 list_for_each_entry_safe(ha, tmp, &list->list, list) {
415 list_del_rcu(&ha->list);
416 kfree_rcu(ha, rcu_head);
417 }
418 list->count = 0;
419 }
420
421 void __hw_addr_init(struct netdev_hw_addr_list *list)
422 {
423 INIT_LIST_HEAD(&list->list);
424 list->count = 0;
425 }
426 EXPORT_SYMBOL(__hw_addr_init);
427
428 /*
429 * Device addresses handling functions
430 */
431
432 /**
433 * dev_addr_flush - Flush device address list
434 * @dev: device
435 *
436 * Flush device address list and reset ->dev_addr.
437 *
438 * The caller must hold the rtnl_mutex.
439 */
440 void dev_addr_flush(struct net_device *dev)
441 {
442 /* rtnl_mutex must be held here */
443
444 __hw_addr_flush(&dev->dev_addrs);
445 dev->dev_addr = NULL;
446 }
447 EXPORT_SYMBOL(dev_addr_flush);
448
449 /**
450 * dev_addr_init - Init device address list
451 * @dev: device
452 *
453 * Init device address list and create the first element,
454 * used by ->dev_addr.
455 *
456 * The caller must hold the rtnl_mutex.
457 */
458 int dev_addr_init(struct net_device *dev)
459 {
460 unsigned char addr[MAX_ADDR_LEN];
461 struct netdev_hw_addr *ha;
462 int err;
463
464 /* rtnl_mutex must be held here */
465
466 __hw_addr_init(&dev->dev_addrs);
467 memset(addr, 0, sizeof(addr));
468 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
469 NETDEV_HW_ADDR_T_LAN);
470 if (!err) {
471 /*
472 * Get the first (previously created) address from the list
473 * and set dev_addr pointer to this location.
474 */
475 ha = list_first_entry(&dev->dev_addrs.list,
476 struct netdev_hw_addr, list);
477 dev->dev_addr = ha->addr;
478 }
479 return err;
480 }
481 EXPORT_SYMBOL(dev_addr_init);
482
483 /**
484 * dev_addr_add - Add a device address
485 * @dev: device
486 * @addr: address to add
487 * @addr_type: address type
488 *
489 * Add a device address to the device or increase the reference count if
490 * it already exists.
491 *
492 * The caller must hold the rtnl_mutex.
493 */
494 int dev_addr_add(struct net_device *dev, const unsigned char *addr,
495 unsigned char addr_type)
496 {
497 int err;
498
499 ASSERT_RTNL();
500
501 err = dev_pre_changeaddr_notify(dev, addr, NULL);
502 if (err)
503 return err;
504 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
505 if (!err)
506 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
507 return err;
508 }
509 EXPORT_SYMBOL(dev_addr_add);
510
511 /**
512 * dev_addr_del - Release a device address.
513 * @dev: device
514 * @addr: address to delete
515 * @addr_type: address type
516 *
517 * Release reference to a device address and remove it from the device
518 * if the reference count drops to zero.
519 *
520 * The caller must hold the rtnl_mutex.
521 */
522 int dev_addr_del(struct net_device *dev, const unsigned char *addr,
523 unsigned char addr_type)
524 {
525 int err;
526 struct netdev_hw_addr *ha;
527
528 ASSERT_RTNL();
529
530 /*
531 * We can not remove the first address from the list because
532 * dev->dev_addr points to that.
533 */
534 ha = list_first_entry(&dev->dev_addrs.list,
535 struct netdev_hw_addr, list);
536 if (!memcmp(ha->addr, addr, dev->addr_len) &&
537 ha->type == addr_type && ha->refcount == 1)
538 return -ENOENT;
539
540 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
541 addr_type);
542 if (!err)
543 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
544 return err;
545 }
546 EXPORT_SYMBOL(dev_addr_del);
547
548 /*
549 * Unicast list handling functions
550 */
551
552 /**
553 * dev_uc_add_excl - Add a global secondary unicast address
554 * @dev: device
555 * @addr: address to add
556 */
557 int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
558 {
559 struct netdev_hw_addr *ha;
560 int err;
561
562 netif_addr_lock_bh(dev);
563 list_for_each_entry(ha, &dev->uc.list, list) {
564 if (!memcmp(ha->addr, addr, dev->addr_len) &&
565 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
566 err = -EEXIST;
567 goto out;
568 }
569 }
570 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
571 NETDEV_HW_ADDR_T_UNICAST, true, false);
572 if (!err)
573 __dev_set_rx_mode(dev);
574 out:
575 netif_addr_unlock_bh(dev);
576 return err;
577 }
578 EXPORT_SYMBOL(dev_uc_add_excl);
579
580 /**
581 * dev_uc_add - Add a secondary unicast address
582 * @dev: device
583 * @addr: address to add
584 *
585 * Add a secondary unicast address to the device or increase
586 * the reference count if it already exists.
587 */
588 int dev_uc_add(struct net_device *dev, const unsigned char *addr)
589 {
590 int err;
591
592 netif_addr_lock_bh(dev);
593 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
594 NETDEV_HW_ADDR_T_UNICAST);
595 if (!err)
596 __dev_set_rx_mode(dev);
597 netif_addr_unlock_bh(dev);
598 return err;
599 }
600 EXPORT_SYMBOL(dev_uc_add);
601
602 /**
603 * dev_uc_del - Release secondary unicast address.
604 * @dev: device
605 * @addr: address to delete
606 *
607 * Release reference to a secondary unicast address and remove it
608 * from the device if the reference count drops to zero.
609 */
610 int dev_uc_del(struct net_device *dev, const unsigned char *addr)
611 {
612 int err;
613
614 netif_addr_lock_bh(dev);
615 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
616 NETDEV_HW_ADDR_T_UNICAST);
617 if (!err)
618 __dev_set_rx_mode(dev);
619 netif_addr_unlock_bh(dev);
620 return err;
621 }
622 EXPORT_SYMBOL(dev_uc_del);
623
624 /**
625 * dev_uc_sync - Synchronize device's unicast list to another device
626 * @to: destination device
627 * @from: source device
628 *
629 * Add newly added addresses to the destination device and release
630 * addresses that have no users left. The source device must be
631 * locked by netif_addr_lock_bh.
632 *
633 * This function is intended to be called from the dev->set_rx_mode
634 * function of layered software devices. This function assumes that
635 * addresses will only ever be synced to the @to devices and no other.
636 */
637 int dev_uc_sync(struct net_device *to, struct net_device *from)
638 {
639 int err = 0;
640
641 if (to->addr_len != from->addr_len)
642 return -EINVAL;
643
644 netif_addr_lock_nested(to);
645 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
646 if (!err)
647 __dev_set_rx_mode(to);
648 netif_addr_unlock(to);
649 return err;
650 }
651 EXPORT_SYMBOL(dev_uc_sync);
652
653 /**
654 * dev_uc_sync_multiple - Synchronize device's unicast list to another
655 * device, but allow for multiple calls to sync to multiple devices.
656 * @to: destination device
657 * @from: source device
658 *
659 * Add newly added addresses to the destination device and release
660 * addresses that have been deleted from the source. The source device
661 * must be locked by netif_addr_lock_bh.
662 *
663 * This function is intended to be called from the dev->set_rx_mode
664 * function of layered software devices. It allows for a single source
665 * device to be synced to multiple destination devices.
666 */
667 int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
668 {
669 int err = 0;
670
671 if (to->addr_len != from->addr_len)
672 return -EINVAL;
673
674 netif_addr_lock_nested(to);
675 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
676 if (!err)
677 __dev_set_rx_mode(to);
678 netif_addr_unlock(to);
679 return err;
680 }
681 EXPORT_SYMBOL(dev_uc_sync_multiple);
682
683 /**
684 * dev_uc_unsync - Remove synchronized addresses from the destination device
685 * @to: destination device
686 * @from: source device
687 *
688 * Remove all addresses that were added to the destination device by
689 * dev_uc_sync(). This function is intended to be called from the
690 * dev->stop function of layered software devices.
691 */
692 void dev_uc_unsync(struct net_device *to, struct net_device *from)
693 {
694 if (to->addr_len != from->addr_len)
695 return;
696
697 netif_addr_lock_bh(from);
698 netif_addr_lock_nested(to);
699 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
700 __dev_set_rx_mode(to);
701 netif_addr_unlock(to);
702 netif_addr_unlock_bh(from);
703 }
704 EXPORT_SYMBOL(dev_uc_unsync);
705
706 /**
707 * dev_uc_flush - Flush unicast addresses
708 * @dev: device
709 *
710 * Flush unicast addresses.
711 */
712 void dev_uc_flush(struct net_device *dev)
713 {
714 netif_addr_lock_bh(dev);
715 __hw_addr_flush(&dev->uc);
716 netif_addr_unlock_bh(dev);
717 }
718 EXPORT_SYMBOL(dev_uc_flush);
719
720 /**
721 * dev_uc_flush - Init unicast address list
722 * @dev: device
723 *
724 * Init unicast address list.
725 */
726 void dev_uc_init(struct net_device *dev)
727 {
728 __hw_addr_init(&dev->uc);
729 }
730 EXPORT_SYMBOL(dev_uc_init);
731
732 /*
733 * Multicast list handling functions
734 */
735
736 /**
737 * dev_mc_add_excl - Add a global secondary multicast address
738 * @dev: device
739 * @addr: address to add
740 */
741 int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
742 {
743 struct netdev_hw_addr *ha;
744 int err;
745
746 netif_addr_lock_bh(dev);
747 list_for_each_entry(ha, &dev->mc.list, list) {
748 if (!memcmp(ha->addr, addr, dev->addr_len) &&
749 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
750 err = -EEXIST;
751 goto out;
752 }
753 }
754 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
755 NETDEV_HW_ADDR_T_MULTICAST, true, false);
756 if (!err)
757 __dev_set_rx_mode(dev);
758 out:
759 netif_addr_unlock_bh(dev);
760 return err;
761 }
762 EXPORT_SYMBOL(dev_mc_add_excl);
763
764 static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
765 bool global)
766 {
767 int err;
768
769 netif_addr_lock_bh(dev);
770 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
771 NETDEV_HW_ADDR_T_MULTICAST, global, false, 0);
772 if (!err)
773 __dev_set_rx_mode(dev);
774 netif_addr_unlock_bh(dev);
775 return err;
776 }
777 /**
778 * dev_mc_add - Add a multicast address
779 * @dev: device
780 * @addr: address to add
781 *
782 * Add a multicast address to the device or increase
783 * the reference count if it already exists.
784 */
785 int dev_mc_add(struct net_device *dev, const unsigned char *addr)
786 {
787 return __dev_mc_add(dev, addr, false);
788 }
789 EXPORT_SYMBOL(dev_mc_add);
790
791 /**
792 * dev_mc_add_global - Add a global multicast address
793 * @dev: device
794 * @addr: address to add
795 *
796 * Add a global multicast address to the device.
797 */
798 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
799 {
800 return __dev_mc_add(dev, addr, true);
801 }
802 EXPORT_SYMBOL(dev_mc_add_global);
803
804 static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
805 bool global)
806 {
807 int err;
808
809 netif_addr_lock_bh(dev);
810 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
811 NETDEV_HW_ADDR_T_MULTICAST, global, false);
812 if (!err)
813 __dev_set_rx_mode(dev);
814 netif_addr_unlock_bh(dev);
815 return err;
816 }
817
818 /**
819 * dev_mc_del - Delete a multicast address.
820 * @dev: device
821 * @addr: address to delete
822 *
823 * Release reference to a multicast address and remove it
824 * from the device if the reference count drops to zero.
825 */
826 int dev_mc_del(struct net_device *dev, const unsigned char *addr)
827 {
828 return __dev_mc_del(dev, addr, false);
829 }
830 EXPORT_SYMBOL(dev_mc_del);
831
832 /**
833 * dev_mc_del_global - Delete a global multicast address.
834 * @dev: device
835 * @addr: address to delete
836 *
837 * Release reference to a multicast address and remove it
838 * from the device if the reference count drops to zero.
839 */
840 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
841 {
842 return __dev_mc_del(dev, addr, true);
843 }
844 EXPORT_SYMBOL(dev_mc_del_global);
845
846 /**
847 * dev_mc_sync - Synchronize device's multicast list to another device
848 * @to: destination device
849 * @from: source device
850 *
851 * Add newly added addresses to the destination device and release
852 * addresses that have no users left. The source device must be
853 * locked by netif_addr_lock_bh.
854 *
855 * This function is intended to be called from the ndo_set_rx_mode
856 * function of layered software devices.
857 */
858 int dev_mc_sync(struct net_device *to, struct net_device *from)
859 {
860 int err = 0;
861
862 if (to->addr_len != from->addr_len)
863 return -EINVAL;
864
865 netif_addr_lock_nested(to);
866 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
867 if (!err)
868 __dev_set_rx_mode(to);
869 netif_addr_unlock(to);
870 return err;
871 }
872 EXPORT_SYMBOL(dev_mc_sync);
873
874 /**
875 * dev_mc_sync_multiple - Synchronize device's multicast list to another
876 * device, but allow for multiple calls to sync to multiple devices.
877 * @to: destination device
878 * @from: source device
879 *
880 * Add newly added addresses to the destination device and release
881 * addresses that have no users left. The source device must be
882 * locked by netif_addr_lock_bh.
883 *
884 * This function is intended to be called from the ndo_set_rx_mode
885 * function of layered software devices. It allows for a single
886 * source device to be synced to multiple destination devices.
887 */
888 int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
889 {
890 int err = 0;
891
892 if (to->addr_len != from->addr_len)
893 return -EINVAL;
894
895 netif_addr_lock_nested(to);
896 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
897 if (!err)
898 __dev_set_rx_mode(to);
899 netif_addr_unlock(to);
900 return err;
901 }
902 EXPORT_SYMBOL(dev_mc_sync_multiple);
903
904 /**
905 * dev_mc_unsync - Remove synchronized addresses from the destination device
906 * @to: destination device
907 * @from: source device
908 *
909 * Remove all addresses that were added to the destination device by
910 * dev_mc_sync(). This function is intended to be called from the
911 * dev->stop function of layered software devices.
912 */
913 void dev_mc_unsync(struct net_device *to, struct net_device *from)
914 {
915 if (to->addr_len != from->addr_len)
916 return;
917
918 netif_addr_lock_bh(from);
919 netif_addr_lock_nested(to);
920 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
921 __dev_set_rx_mode(to);
922 netif_addr_unlock(to);
923 netif_addr_unlock_bh(from);
924 }
925 EXPORT_SYMBOL(dev_mc_unsync);
926
927 /**
928 * dev_mc_flush - Flush multicast addresses
929 * @dev: device
930 *
931 * Flush multicast addresses.
932 */
933 void dev_mc_flush(struct net_device *dev)
934 {
935 netif_addr_lock_bh(dev);
936 __hw_addr_flush(&dev->mc);
937 netif_addr_unlock_bh(dev);
938 }
939 EXPORT_SYMBOL(dev_mc_flush);
940
941 /**
942 * dev_mc_init - Init multicast address list
943 * @dev: device
944 *
945 * Init multicast address list.
946 */
947 void dev_mc_init(struct net_device *dev)
948 {
949 __hw_addr_init(&dev->mc);
950 }
951 EXPORT_SYMBOL(dev_mc_init);
952
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.