1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * net/core/dev_addr_lists.c - Functions for handling net device lists
4 * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
6 * This file contains functions for working with unicast, multicast and device
10 #include <linux/netdevice.h>
11 #include <linux/rtnetlink.h>
12 #include <linux/export.h>
13 #include <linux/list.h>
16 * General list handling functions
19 static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
20 const unsigned char *addr, int addr_len,
21 unsigned char addr_type, bool global,
24 struct netdev_hw_addr *ha;
27 alloc_size = sizeof(*ha);
28 if (alloc_size < L1_CACHE_BYTES)
29 alloc_size = L1_CACHE_BYTES;
30 ha = kmalloc(alloc_size, GFP_ATOMIC);
33 memcpy(ha->addr, addr, addr_len);
36 ha->global_use = global;
37 ha->synced = sync ? 1 : 0;
39 list_add_tail_rcu(&ha->list, &list->list);
45 static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
46 const unsigned char *addr, int addr_len,
47 unsigned char addr_type, bool global, bool sync,
50 struct netdev_hw_addr *ha;
52 if (addr_len > MAX_ADDR_LEN)
55 list_for_each_entry(ha, &list->list, list) {
56 if (ha->type == addr_type &&
57 !memcmp(ha->addr, addr, addr_len)) {
59 /* check if addr is already used as global */
63 ha->global_use = true;
66 if (ha->synced && sync_count)
76 return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
80 static int __hw_addr_add(struct netdev_hw_addr_list *list,
81 const unsigned char *addr, int addr_len,
82 unsigned char addr_type)
84 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
88 static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
89 struct netdev_hw_addr *ha, bool global,
92 if (global && !ha->global_use)
95 if (sync && !ha->synced)
99 ha->global_use = false;
106 list_del_rcu(&ha->list);
107 kfree_rcu(ha, rcu_head);
112 static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
113 const unsigned char *addr, int addr_len,
114 unsigned char addr_type, bool global, bool sync)
116 struct netdev_hw_addr *ha;
118 list_for_each_entry(ha, &list->list, list) {
119 if (!memcmp(ha->addr, addr, addr_len) &&
120 (ha->type == addr_type || !addr_type))
121 return __hw_addr_del_entry(list, ha, global, sync);
126 static int __hw_addr_del(struct netdev_hw_addr_list *list,
127 const unsigned char *addr, int addr_len,
128 unsigned char addr_type)
130 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
133 static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
134 struct netdev_hw_addr *ha,
139 err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
140 false, true, ha->sync_cnt);
141 if (err && err != -EEXIST)
152 static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
153 struct netdev_hw_addr_list *from_list,
154 struct netdev_hw_addr *ha,
159 err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
164 /* address on from list is not marked synced */
165 __hw_addr_del_entry(from_list, ha, false, false);
168 static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
169 struct netdev_hw_addr_list *from_list,
173 struct netdev_hw_addr *ha, *tmp;
175 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
176 if (ha->sync_cnt == ha->refcount) {
177 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
179 err = __hw_addr_sync_one(to_list, ha, addr_len);
187 /* This function only works where there is a strict 1-1 relationship
188 * between source and destionation of they synch. If you ever need to
189 * sync addresses to more then 1 destination, you need to use
190 * __hw_addr_sync_multiple().
192 int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
193 struct netdev_hw_addr_list *from_list,
197 struct netdev_hw_addr *ha, *tmp;
199 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
201 err = __hw_addr_sync_one(to_list, ha, addr_len);
204 } else if (ha->refcount == 1)
205 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
209 EXPORT_SYMBOL(__hw_addr_sync);
211 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
212 struct netdev_hw_addr_list *from_list,
215 struct netdev_hw_addr *ha, *tmp;
217 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
219 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
222 EXPORT_SYMBOL(__hw_addr_unsync);
225 * __hw_addr_sync_dev - Synchonize device's multicast list
226 * @list: address list to syncronize
227 * @dev: device to sync
228 * @sync: function to call if address should be added
229 * @unsync: function to call if address should be removed
231 * This function is intended to be called from the ndo_set_rx_mode
232 * function of devices that require explicit address add/remove
233 * notifications. The unsync function may be NULL in which case
234 * the addresses requiring removal will simply be removed without
235 * any notification to the device.
237 int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
238 struct net_device *dev,
239 int (*sync)(struct net_device *, const unsigned char *),
240 int (*unsync)(struct net_device *,
241 const unsigned char *))
243 struct netdev_hw_addr *ha, *tmp;
246 /* first go through and flush out any stale entries */
247 list_for_each_entry_safe(ha, tmp, &list->list, list) {
248 if (!ha->sync_cnt || ha->refcount != 1)
251 /* if unsync is defined and fails defer unsyncing address */
252 if (unsync && unsync(dev, ha->addr))
256 __hw_addr_del_entry(list, ha, false, false);
259 /* go through and sync new entries to the list */
260 list_for_each_entry_safe(ha, tmp, &list->list, list) {
264 err = sync(dev, ha->addr);
274 EXPORT_SYMBOL(__hw_addr_sync_dev);
277 * __hw_addr_ref_sync_dev - Synchronize device's multicast address list taking
278 * into account references
279 * @list: address list to synchronize
280 * @dev: device to sync
281 * @sync: function to call if address or reference on it should be added
282 * @unsync: function to call if address or some reference on it should removed
284 * This function is intended to be called from the ndo_set_rx_mode
285 * function of devices that require explicit address or references on it
286 * add/remove notifications. The unsync function may be NULL in which case
287 * the addresses or references on it requiring removal will simply be
288 * removed without any notification to the device. That is responsibility of
289 * the driver to identify and distribute address or references on it between
290 * internal address tables.
292 int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
293 struct net_device *dev,
294 int (*sync)(struct net_device *,
295 const unsigned char *, int),
296 int (*unsync)(struct net_device *,
297 const unsigned char *, int))
299 struct netdev_hw_addr *ha, *tmp;
302 /* first go through and flush out any unsynced/stale entries */
303 list_for_each_entry_safe(ha, tmp, &list->list, list) {
304 /* sync if address is not used */
305 if ((ha->sync_cnt << 1) <= ha->refcount)
308 /* if fails defer unsyncing address */
309 ref_cnt = ha->refcount - ha->sync_cnt;
310 if (unsync && unsync(dev, ha->addr, ref_cnt))
313 ha->refcount = (ref_cnt << 1) + 1;
314 ha->sync_cnt = ref_cnt;
315 __hw_addr_del_entry(list, ha, false, false);
318 /* go through and sync updated/new entries to the list */
319 list_for_each_entry_safe(ha, tmp, &list->list, list) {
320 /* sync if address added or reused */
321 if ((ha->sync_cnt << 1) >= ha->refcount)
324 ref_cnt = ha->refcount - ha->sync_cnt;
325 err = sync(dev, ha->addr, ref_cnt);
329 ha->refcount = ref_cnt << 1;
330 ha->sync_cnt = ref_cnt;
335 EXPORT_SYMBOL(__hw_addr_ref_sync_dev);
338 * __hw_addr_ref_unsync_dev - Remove synchronized addresses and references on
340 * @list: address list to remove synchronized addresses (references on it) from
341 * @dev: device to sync
342 * @unsync: function to call if address and references on it should be removed
344 * Remove all addresses that were added to the device by
345 * __hw_addr_ref_sync_dev(). This function is intended to be called from the
346 * ndo_stop or ndo_open functions on devices that require explicit address (or
347 * references on it) add/remove notifications. If the unsync function pointer
348 * is NULL then this function can be used to just reset the sync_cnt for the
349 * addresses in the list.
351 void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
352 struct net_device *dev,
353 int (*unsync)(struct net_device *,
354 const unsigned char *, int))
356 struct netdev_hw_addr *ha, *tmp;
358 list_for_each_entry_safe(ha, tmp, &list->list, list) {
362 /* if fails defer unsyncing address */
363 if (unsync && unsync(dev, ha->addr, ha->sync_cnt))
366 ha->refcount -= ha->sync_cnt - 1;
368 __hw_addr_del_entry(list, ha, false, false);
371 EXPORT_SYMBOL(__hw_addr_ref_unsync_dev);
374 * __hw_addr_unsync_dev - Remove synchronized addresses from device
375 * @list: address list to remove synchronized addresses from
376 * @dev: device to sync
377 * @unsync: function to call if address should be removed
379 * Remove all addresses that were added to the device by __hw_addr_sync_dev().
380 * This function is intended to be called from the ndo_stop or ndo_open
381 * functions on devices that require explicit address add/remove
382 * notifications. If the unsync function pointer is NULL then this function
383 * can be used to just reset the sync_cnt for the addresses in the list.
385 void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
386 struct net_device *dev,
387 int (*unsync)(struct net_device *,
388 const unsigned char *))
390 struct netdev_hw_addr *ha, *tmp;
392 list_for_each_entry_safe(ha, tmp, &list->list, list) {
396 /* if unsync is defined and fails defer unsyncing address */
397 if (unsync && unsync(dev, ha->addr))
401 __hw_addr_del_entry(list, ha, false, false);
404 EXPORT_SYMBOL(__hw_addr_unsync_dev);
406 static void __hw_addr_flush(struct netdev_hw_addr_list *list)
408 struct netdev_hw_addr *ha, *tmp;
410 list_for_each_entry_safe(ha, tmp, &list->list, list) {
411 list_del_rcu(&ha->list);
412 kfree_rcu(ha, rcu_head);
417 void __hw_addr_init(struct netdev_hw_addr_list *list)
419 INIT_LIST_HEAD(&list->list);
422 EXPORT_SYMBOL(__hw_addr_init);
425 * Device addresses handling functions
429 * dev_addr_flush - Flush device address list
432 * Flush device address list and reset ->dev_addr.
434 * The caller must hold the rtnl_mutex.
436 void dev_addr_flush(struct net_device *dev)
438 /* rtnl_mutex must be held here */
440 __hw_addr_flush(&dev->dev_addrs);
441 dev->dev_addr = NULL;
443 EXPORT_SYMBOL(dev_addr_flush);
446 * dev_addr_init - Init device address list
449 * Init device address list and create the first element,
450 * used by ->dev_addr.
452 * The caller must hold the rtnl_mutex.
454 int dev_addr_init(struct net_device *dev)
456 unsigned char addr[MAX_ADDR_LEN];
457 struct netdev_hw_addr *ha;
460 /* rtnl_mutex must be held here */
462 __hw_addr_init(&dev->dev_addrs);
463 memset(addr, 0, sizeof(addr));
464 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
465 NETDEV_HW_ADDR_T_LAN);
468 * Get the first (previously created) address from the list
469 * and set dev_addr pointer to this location.
471 ha = list_first_entry(&dev->dev_addrs.list,
472 struct netdev_hw_addr, list);
473 dev->dev_addr = ha->addr;
477 EXPORT_SYMBOL(dev_addr_init);
480 * dev_addr_add - Add a device address
482 * @addr: address to add
483 * @addr_type: address type
485 * Add a device address to the device or increase the reference count if
488 * The caller must hold the rtnl_mutex.
490 int dev_addr_add(struct net_device *dev, const unsigned char *addr,
491 unsigned char addr_type)
497 err = dev_pre_changeaddr_notify(dev, addr, NULL);
500 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
502 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
505 EXPORT_SYMBOL(dev_addr_add);
508 * dev_addr_del - Release a device address.
510 * @addr: address to delete
511 * @addr_type: address type
513 * Release reference to a device address and remove it from the device
514 * if the reference count drops to zero.
516 * The caller must hold the rtnl_mutex.
518 int dev_addr_del(struct net_device *dev, const unsigned char *addr,
519 unsigned char addr_type)
522 struct netdev_hw_addr *ha;
527 * We can not remove the first address from the list because
528 * dev->dev_addr points to that.
530 ha = list_first_entry(&dev->dev_addrs.list,
531 struct netdev_hw_addr, list);
532 if (!memcmp(ha->addr, addr, dev->addr_len) &&
533 ha->type == addr_type && ha->refcount == 1)
536 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
539 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
542 EXPORT_SYMBOL(dev_addr_del);
545 * Unicast list handling functions
549 * dev_uc_add_excl - Add a global secondary unicast address
551 * @addr: address to add
553 int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
555 struct netdev_hw_addr *ha;
558 netif_addr_lock_bh(dev);
559 list_for_each_entry(ha, &dev->uc.list, list) {
560 if (!memcmp(ha->addr, addr, dev->addr_len) &&
561 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
566 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
567 NETDEV_HW_ADDR_T_UNICAST, true, false);
569 __dev_set_rx_mode(dev);
571 netif_addr_unlock_bh(dev);
574 EXPORT_SYMBOL(dev_uc_add_excl);
577 * dev_uc_add - Add a secondary unicast address
579 * @addr: address to add
581 * Add a secondary unicast address to the device or increase
582 * the reference count if it already exists.
584 int dev_uc_add(struct net_device *dev, const unsigned char *addr)
588 netif_addr_lock_bh(dev);
589 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
590 NETDEV_HW_ADDR_T_UNICAST);
592 __dev_set_rx_mode(dev);
593 netif_addr_unlock_bh(dev);
596 EXPORT_SYMBOL(dev_uc_add);
599 * dev_uc_del - Release secondary unicast address.
601 * @addr: address to delete
603 * Release reference to a secondary unicast address and remove it
604 * from the device if the reference count drops to zero.
606 int dev_uc_del(struct net_device *dev, const unsigned char *addr)
610 netif_addr_lock_bh(dev);
611 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
612 NETDEV_HW_ADDR_T_UNICAST);
614 __dev_set_rx_mode(dev);
615 netif_addr_unlock_bh(dev);
618 EXPORT_SYMBOL(dev_uc_del);
621 * dev_uc_sync - Synchronize device's unicast list to another device
622 * @to: destination device
623 * @from: source device
625 * Add newly added addresses to the destination device and release
626 * addresses that have no users left. The source device must be
627 * locked by netif_addr_lock_bh.
629 * This function is intended to be called from the dev->set_rx_mode
630 * function of layered software devices. This function assumes that
631 * addresses will only ever be synced to the @to devices and no other.
633 int dev_uc_sync(struct net_device *to, struct net_device *from)
637 if (to->addr_len != from->addr_len)
641 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
643 __dev_set_rx_mode(to);
644 netif_addr_unlock(to);
647 EXPORT_SYMBOL(dev_uc_sync);
650 * dev_uc_sync_multiple - Synchronize device's unicast list to another
651 * device, but allow for multiple calls to sync to multiple devices.
652 * @to: destination device
653 * @from: source device
655 * Add newly added addresses to the destination device and release
656 * addresses that have been deleted from the source. The source device
657 * must be locked by netif_addr_lock_bh.
659 * This function is intended to be called from the dev->set_rx_mode
660 * function of layered software devices. It allows for a single source
661 * device to be synced to multiple destination devices.
663 int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
667 if (to->addr_len != from->addr_len)
671 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
673 __dev_set_rx_mode(to);
674 netif_addr_unlock(to);
677 EXPORT_SYMBOL(dev_uc_sync_multiple);
680 * dev_uc_unsync - Remove synchronized addresses from the destination device
681 * @to: destination device
682 * @from: source device
684 * Remove all addresses that were added to the destination device by
685 * dev_uc_sync(). This function is intended to be called from the
686 * dev->stop function of layered software devices.
688 void dev_uc_unsync(struct net_device *to, struct net_device *from)
690 if (to->addr_len != from->addr_len)
693 /* netif_addr_lock_bh() uses lockdep subclass 0, this is okay for two
695 * 1) This is always called without any addr_list_lock, so as the
696 * outermost one here, it must be 0.
697 * 2) This is called by some callers after unlinking the upper device,
698 * so the dev->lower_level becomes 1 again.
699 * Therefore, the subclass for 'from' is 0, for 'to' is either 1 or
702 netif_addr_lock_bh(from);
704 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
705 __dev_set_rx_mode(to);
706 netif_addr_unlock(to);
707 netif_addr_unlock_bh(from);
709 EXPORT_SYMBOL(dev_uc_unsync);
712 * dev_uc_flush - Flush unicast addresses
715 * Flush unicast addresses.
717 void dev_uc_flush(struct net_device *dev)
719 netif_addr_lock_bh(dev);
720 __hw_addr_flush(&dev->uc);
721 netif_addr_unlock_bh(dev);
723 EXPORT_SYMBOL(dev_uc_flush);
726 * dev_uc_init - Init unicast address list
729 * Init unicast address list.
731 void dev_uc_init(struct net_device *dev)
733 __hw_addr_init(&dev->uc);
735 EXPORT_SYMBOL(dev_uc_init);
738 * Multicast list handling functions
742 * dev_mc_add_excl - Add a global secondary multicast address
744 * @addr: address to add
746 int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
748 struct netdev_hw_addr *ha;
751 netif_addr_lock_bh(dev);
752 list_for_each_entry(ha, &dev->mc.list, list) {
753 if (!memcmp(ha->addr, addr, dev->addr_len) &&
754 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
759 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
760 NETDEV_HW_ADDR_T_MULTICAST, true, false);
762 __dev_set_rx_mode(dev);
764 netif_addr_unlock_bh(dev);
767 EXPORT_SYMBOL(dev_mc_add_excl);
769 static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
774 netif_addr_lock_bh(dev);
775 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
776 NETDEV_HW_ADDR_T_MULTICAST, global, false, 0);
778 __dev_set_rx_mode(dev);
779 netif_addr_unlock_bh(dev);
783 * dev_mc_add - Add a multicast address
785 * @addr: address to add
787 * Add a multicast address to the device or increase
788 * the reference count if it already exists.
790 int dev_mc_add(struct net_device *dev, const unsigned char *addr)
792 return __dev_mc_add(dev, addr, false);
794 EXPORT_SYMBOL(dev_mc_add);
797 * dev_mc_add_global - Add a global multicast address
799 * @addr: address to add
801 * Add a global multicast address to the device.
803 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
805 return __dev_mc_add(dev, addr, true);
807 EXPORT_SYMBOL(dev_mc_add_global);
809 static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
814 netif_addr_lock_bh(dev);
815 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
816 NETDEV_HW_ADDR_T_MULTICAST, global, false);
818 __dev_set_rx_mode(dev);
819 netif_addr_unlock_bh(dev);
824 * dev_mc_del - Delete a multicast address.
826 * @addr: address to delete
828 * Release reference to a multicast address and remove it
829 * from the device if the reference count drops to zero.
831 int dev_mc_del(struct net_device *dev, const unsigned char *addr)
833 return __dev_mc_del(dev, addr, false);
835 EXPORT_SYMBOL(dev_mc_del);
838 * dev_mc_del_global - Delete a global multicast address.
840 * @addr: address to delete
842 * Release reference to a multicast address and remove it
843 * from the device if the reference count drops to zero.
845 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
847 return __dev_mc_del(dev, addr, true);
849 EXPORT_SYMBOL(dev_mc_del_global);
852 * dev_mc_sync - Synchronize device's multicast list to another device
853 * @to: destination device
854 * @from: source device
856 * Add newly added addresses to the destination device and release
857 * addresses that have no users left. The source device must be
858 * locked by netif_addr_lock_bh.
860 * This function is intended to be called from the ndo_set_rx_mode
861 * function of layered software devices.
863 int dev_mc_sync(struct net_device *to, struct net_device *from)
867 if (to->addr_len != from->addr_len)
871 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
873 __dev_set_rx_mode(to);
874 netif_addr_unlock(to);
877 EXPORT_SYMBOL(dev_mc_sync);
880 * dev_mc_sync_multiple - Synchronize device's multicast list to another
881 * device, but allow for multiple calls to sync to multiple devices.
882 * @to: destination device
883 * @from: source device
885 * Add newly added addresses to the destination device and release
886 * addresses that have no users left. The source device must be
887 * locked by netif_addr_lock_bh.
889 * This function is intended to be called from the ndo_set_rx_mode
890 * function of layered software devices. It allows for a single
891 * source device to be synced to multiple destination devices.
893 int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
897 if (to->addr_len != from->addr_len)
901 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
903 __dev_set_rx_mode(to);
904 netif_addr_unlock(to);
907 EXPORT_SYMBOL(dev_mc_sync_multiple);
910 * dev_mc_unsync - Remove synchronized addresses from the destination device
911 * @to: destination device
912 * @from: source device
914 * Remove all addresses that were added to the destination device by
915 * dev_mc_sync(). This function is intended to be called from the
916 * dev->stop function of layered software devices.
918 void dev_mc_unsync(struct net_device *to, struct net_device *from)
920 if (to->addr_len != from->addr_len)
923 /* See the above comments inside dev_uc_unsync(). */
924 netif_addr_lock_bh(from);
926 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
927 __dev_set_rx_mode(to);
928 netif_addr_unlock(to);
929 netif_addr_unlock_bh(from);
931 EXPORT_SYMBOL(dev_mc_unsync);
934 * dev_mc_flush - Flush multicast addresses
937 * Flush multicast addresses.
939 void dev_mc_flush(struct net_device *dev)
941 netif_addr_lock_bh(dev);
942 __hw_addr_flush(&dev->mc);
943 netif_addr_unlock_bh(dev);
945 EXPORT_SYMBOL(dev_mc_flush);
948 * dev_mc_init - Init multicast address list
951 * Init multicast address list.
953 void dev_mc_init(struct net_device *dev)
955 __hw_addr_init(&dev->mc);
957 EXPORT_SYMBOL(dev_mc_init);