2 * net/core/dev_addr_lists.c - Functions for handling net device lists
3 * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
5 * This file contains functions for working with unicast, multicast and device
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.
14 #include <linux/netdevice.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/export.h>
17 #include <linux/list.h>
18 #include <linux/proc_fs.h>
21 * General list handling functions
24 static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
25 unsigned char *addr, int addr_len,
26 unsigned char addr_type, bool global)
28 struct netdev_hw_addr *ha;
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);
37 memcpy(ha->addr, addr, addr_len);
40 ha->global_use = global;
42 list_add_tail_rcu(&ha->list, &list->list);
48 static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
49 unsigned char *addr, int addr_len,
50 unsigned char addr_type, bool global)
52 struct netdev_hw_addr *ha;
54 if (addr_len > MAX_ADDR_LEN)
57 list_for_each_entry(ha, &list->list, list) {
58 if (!memcmp(ha->addr, addr, addr_len) &&
59 ha->type == addr_type) {
61 /* check if addr is already used as global */
65 ha->global_use = true;
72 return __hw_addr_create_ex(list, addr, addr_len, addr_type, global);
75 static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
76 int addr_len, unsigned char addr_type)
78 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false);
81 static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
82 unsigned char *addr, int addr_len,
83 unsigned char addr_type, bool global)
85 struct netdev_hw_addr *ha;
87 list_for_each_entry(ha, &list->list, list) {
88 if (!memcmp(ha->addr, addr, addr_len) &&
89 (ha->type == addr_type || !addr_type)) {
94 ha->global_use = false;
98 list_del_rcu(&ha->list);
99 kfree_rcu(ha, rcu_head);
107 static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
108 int addr_len, unsigned char addr_type)
110 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false);
113 int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
114 struct netdev_hw_addr_list *from_list,
115 int addr_len, unsigned char addr_type)
118 struct netdev_hw_addr *ha, *ha2;
121 list_for_each_entry(ha, &from_list->list, list) {
122 type = addr_type ? addr_type : ha->type;
123 err = __hw_addr_add(to_list, ha->addr, addr_len, type);
130 list_for_each_entry(ha2, &from_list->list, list) {
133 type = addr_type ? addr_type : ha2->type;
134 __hw_addr_del(to_list, ha2->addr, addr_len, type);
138 EXPORT_SYMBOL(__hw_addr_add_multiple);
140 void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
141 struct netdev_hw_addr_list *from_list,
142 int addr_len, unsigned char addr_type)
144 struct netdev_hw_addr *ha;
147 list_for_each_entry(ha, &from_list->list, list) {
148 type = addr_type ? addr_type : ha->type;
149 __hw_addr_del(to_list, ha->addr, addr_len, type);
152 EXPORT_SYMBOL(__hw_addr_del_multiple);
154 int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
155 struct netdev_hw_addr_list *from_list,
159 struct netdev_hw_addr *ha, *tmp;
161 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
163 err = __hw_addr_add(to_list, ha->addr,
169 } else if (ha->refcount == 1) {
170 __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
171 __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
176 EXPORT_SYMBOL(__hw_addr_sync);
178 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
179 struct netdev_hw_addr_list *from_list,
182 struct netdev_hw_addr *ha, *tmp;
184 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
186 __hw_addr_del(to_list, ha->addr,
189 __hw_addr_del(from_list, ha->addr,
194 EXPORT_SYMBOL(__hw_addr_unsync);
196 void __hw_addr_flush(struct netdev_hw_addr_list *list)
198 struct netdev_hw_addr *ha, *tmp;
200 list_for_each_entry_safe(ha, tmp, &list->list, list) {
201 list_del_rcu(&ha->list);
202 kfree_rcu(ha, rcu_head);
206 EXPORT_SYMBOL(__hw_addr_flush);
208 void __hw_addr_init(struct netdev_hw_addr_list *list)
210 INIT_LIST_HEAD(&list->list);
213 EXPORT_SYMBOL(__hw_addr_init);
216 * Device addresses handling functions
220 * dev_addr_flush - Flush device address list
223 * Flush device address list and reset ->dev_addr.
225 * The caller must hold the rtnl_mutex.
227 void dev_addr_flush(struct net_device *dev)
229 /* rtnl_mutex must be held here */
231 __hw_addr_flush(&dev->dev_addrs);
232 dev->dev_addr = NULL;
234 EXPORT_SYMBOL(dev_addr_flush);
237 * dev_addr_init - Init device address list
240 * Init device address list and create the first element,
241 * used by ->dev_addr.
243 * The caller must hold the rtnl_mutex.
245 int dev_addr_init(struct net_device *dev)
247 unsigned char addr[MAX_ADDR_LEN];
248 struct netdev_hw_addr *ha;
251 /* rtnl_mutex must be held here */
253 __hw_addr_init(&dev->dev_addrs);
254 memset(addr, 0, sizeof(addr));
255 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
256 NETDEV_HW_ADDR_T_LAN);
259 * Get the first (previously created) address from the list
260 * and set dev_addr pointer to this location.
262 ha = list_first_entry(&dev->dev_addrs.list,
263 struct netdev_hw_addr, list);
264 dev->dev_addr = ha->addr;
268 EXPORT_SYMBOL(dev_addr_init);
271 * dev_addr_add - Add a device address
273 * @addr: address to add
274 * @addr_type: address type
276 * Add a device address to the device or increase the reference count if
279 * The caller must hold the rtnl_mutex.
281 int dev_addr_add(struct net_device *dev, unsigned char *addr,
282 unsigned char addr_type)
288 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
290 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
293 EXPORT_SYMBOL(dev_addr_add);
296 * dev_addr_del - Release a device address.
298 * @addr: address to delete
299 * @addr_type: address type
301 * Release reference to a device address and remove it from the device
302 * if the reference count drops to zero.
304 * The caller must hold the rtnl_mutex.
306 int dev_addr_del(struct net_device *dev, unsigned char *addr,
307 unsigned char addr_type)
310 struct netdev_hw_addr *ha;
315 * We can not remove the first address from the list because
316 * dev->dev_addr points to that.
318 ha = list_first_entry(&dev->dev_addrs.list,
319 struct netdev_hw_addr, list);
320 if (ha->addr == dev->dev_addr && ha->refcount == 1)
323 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
326 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
329 EXPORT_SYMBOL(dev_addr_del);
332 * dev_addr_add_multiple - Add device addresses from another device
333 * @to_dev: device to which addresses will be added
334 * @from_dev: device from which addresses will be added
335 * @addr_type: address type - 0 means type will be used from from_dev
337 * Add device addresses of the one device to another.
339 * The caller must hold the rtnl_mutex.
341 int dev_addr_add_multiple(struct net_device *to_dev,
342 struct net_device *from_dev,
343 unsigned char addr_type)
349 if (from_dev->addr_len != to_dev->addr_len)
351 err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
352 to_dev->addr_len, addr_type);
354 call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
357 EXPORT_SYMBOL(dev_addr_add_multiple);
360 * dev_addr_del_multiple - Delete device addresses by another device
361 * @to_dev: device where the addresses will be deleted
362 * @from_dev: device supplying the addresses to be deleted
363 * @addr_type: address type - 0 means type will be used from from_dev
365 * Deletes addresses in to device by the list of addresses in from device.
367 * The caller must hold the rtnl_mutex.
369 int dev_addr_del_multiple(struct net_device *to_dev,
370 struct net_device *from_dev,
371 unsigned char addr_type)
375 if (from_dev->addr_len != to_dev->addr_len)
377 __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
378 to_dev->addr_len, addr_type);
379 call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
382 EXPORT_SYMBOL(dev_addr_del_multiple);
385 * Unicast list handling functions
389 * dev_uc_add_excl - Add a global secondary unicast address
391 * @addr: address to add
393 int dev_uc_add_excl(struct net_device *dev, unsigned char *addr)
395 struct netdev_hw_addr *ha;
398 netif_addr_lock_bh(dev);
399 list_for_each_entry(ha, &dev->uc.list, list) {
400 if (!memcmp(ha->addr, addr, dev->addr_len) &&
401 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
406 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
407 NETDEV_HW_ADDR_T_UNICAST, true);
409 __dev_set_rx_mode(dev);
411 netif_addr_unlock_bh(dev);
414 EXPORT_SYMBOL(dev_uc_add_excl);
417 * dev_uc_add - Add a secondary unicast address
419 * @addr: address to add
421 * Add a secondary unicast address to the device or increase
422 * the reference count if it already exists.
424 int dev_uc_add(struct net_device *dev, unsigned char *addr)
428 netif_addr_lock_bh(dev);
429 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
430 NETDEV_HW_ADDR_T_UNICAST);
432 __dev_set_rx_mode(dev);
433 netif_addr_unlock_bh(dev);
436 EXPORT_SYMBOL(dev_uc_add);
439 * dev_uc_del - Release secondary unicast address.
441 * @addr: address to delete
443 * Release reference to a secondary unicast address and remove it
444 * from the device if the reference count drops to zero.
446 int dev_uc_del(struct net_device *dev, unsigned char *addr)
450 netif_addr_lock_bh(dev);
451 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
452 NETDEV_HW_ADDR_T_UNICAST);
454 __dev_set_rx_mode(dev);
455 netif_addr_unlock_bh(dev);
458 EXPORT_SYMBOL(dev_uc_del);
461 * dev_uc_sync - Synchronize device's unicast list to another device
462 * @to: destination device
463 * @from: source device
465 * Add newly added addresses to the destination device and release
466 * addresses that have no users left. The source device must be
467 * locked by netif_addr_lock_bh.
469 * This function is intended to be called from the dev->set_rx_mode
470 * function of layered software devices.
472 int dev_uc_sync(struct net_device *to, struct net_device *from)
476 if (to->addr_len != from->addr_len)
479 netif_addr_lock_nested(to);
480 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
482 __dev_set_rx_mode(to);
483 netif_addr_unlock(to);
486 EXPORT_SYMBOL(dev_uc_sync);
489 * dev_uc_unsync - Remove synchronized addresses from the destination device
490 * @to: destination device
491 * @from: source device
493 * Remove all addresses that were added to the destination device by
494 * dev_uc_sync(). This function is intended to be called from the
495 * dev->stop function of layered software devices.
497 void dev_uc_unsync(struct net_device *to, struct net_device *from)
499 if (to->addr_len != from->addr_len)
502 netif_addr_lock_bh(from);
503 netif_addr_lock_nested(to);
504 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
505 __dev_set_rx_mode(to);
506 netif_addr_unlock(to);
507 netif_addr_unlock_bh(from);
509 EXPORT_SYMBOL(dev_uc_unsync);
512 * dev_uc_flush - Flush unicast addresses
515 * Flush unicast addresses.
517 void dev_uc_flush(struct net_device *dev)
519 netif_addr_lock_bh(dev);
520 __hw_addr_flush(&dev->uc);
521 netif_addr_unlock_bh(dev);
523 EXPORT_SYMBOL(dev_uc_flush);
526 * dev_uc_flush - Init unicast address list
529 * Init unicast address list.
531 void dev_uc_init(struct net_device *dev)
533 __hw_addr_init(&dev->uc);
535 EXPORT_SYMBOL(dev_uc_init);
538 * Multicast list handling functions
542 * dev_mc_add_excl - Add a global secondary multicast address
544 * @addr: address to add
546 int dev_mc_add_excl(struct net_device *dev, unsigned char *addr)
548 struct netdev_hw_addr *ha;
551 netif_addr_lock_bh(dev);
552 list_for_each_entry(ha, &dev->mc.list, list) {
553 if (!memcmp(ha->addr, addr, dev->addr_len) &&
554 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
559 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
560 NETDEV_HW_ADDR_T_MULTICAST, true);
562 __dev_set_rx_mode(dev);
564 netif_addr_unlock_bh(dev);
567 EXPORT_SYMBOL(dev_mc_add_excl);
569 static int __dev_mc_add(struct net_device *dev, unsigned char *addr,
574 netif_addr_lock_bh(dev);
575 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
576 NETDEV_HW_ADDR_T_MULTICAST, global);
578 __dev_set_rx_mode(dev);
579 netif_addr_unlock_bh(dev);
583 * dev_mc_add - Add a multicast address
585 * @addr: address to add
587 * Add a multicast address to the device or increase
588 * the reference count if it already exists.
590 int dev_mc_add(struct net_device *dev, unsigned char *addr)
592 return __dev_mc_add(dev, addr, false);
594 EXPORT_SYMBOL(dev_mc_add);
597 * dev_mc_add_global - Add a global multicast address
599 * @addr: address to add
601 * Add a global multicast address to the device.
603 int dev_mc_add_global(struct net_device *dev, unsigned char *addr)
605 return __dev_mc_add(dev, addr, true);
607 EXPORT_SYMBOL(dev_mc_add_global);
609 static int __dev_mc_del(struct net_device *dev, unsigned char *addr,
614 netif_addr_lock_bh(dev);
615 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
616 NETDEV_HW_ADDR_T_MULTICAST, global);
618 __dev_set_rx_mode(dev);
619 netif_addr_unlock_bh(dev);
624 * dev_mc_del - Delete a multicast address.
626 * @addr: address to delete
628 * Release reference to a multicast address and remove it
629 * from the device if the reference count drops to zero.
631 int dev_mc_del(struct net_device *dev, unsigned char *addr)
633 return __dev_mc_del(dev, addr, false);
635 EXPORT_SYMBOL(dev_mc_del);
638 * dev_mc_del_global - Delete a global multicast address.
640 * @addr: address to delete
642 * Release reference to a multicast address and remove it
643 * from the device if the reference count drops to zero.
645 int dev_mc_del_global(struct net_device *dev, unsigned char *addr)
647 return __dev_mc_del(dev, addr, true);
649 EXPORT_SYMBOL(dev_mc_del_global);
652 * dev_mc_sync - Synchronize device's unicast list to another device
653 * @to: destination device
654 * @from: source device
656 * Add newly added addresses to the destination device and release
657 * addresses that have no users left. The source device must be
658 * locked by netif_addr_lock_bh.
660 * This function is intended to be called from the ndo_set_rx_mode
661 * function of layered software devices.
663 int dev_mc_sync(struct net_device *to, struct net_device *from)
667 if (to->addr_len != from->addr_len)
670 netif_addr_lock_nested(to);
671 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
673 __dev_set_rx_mode(to);
674 netif_addr_unlock(to);
677 EXPORT_SYMBOL(dev_mc_sync);
680 * dev_mc_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_mc_sync(). This function is intended to be called from the
686 * dev->stop function of layered software devices.
688 void dev_mc_unsync(struct net_device *to, struct net_device *from)
690 if (to->addr_len != from->addr_len)
693 netif_addr_lock_bh(from);
694 netif_addr_lock_nested(to);
695 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
696 __dev_set_rx_mode(to);
697 netif_addr_unlock(to);
698 netif_addr_unlock_bh(from);
700 EXPORT_SYMBOL(dev_mc_unsync);
703 * dev_mc_flush - Flush multicast addresses
706 * Flush multicast addresses.
708 void dev_mc_flush(struct net_device *dev)
710 netif_addr_lock_bh(dev);
711 __hw_addr_flush(&dev->mc);
712 netif_addr_unlock_bh(dev);
714 EXPORT_SYMBOL(dev_mc_flush);
717 * dev_mc_flush - Init multicast address list
720 * Init multicast address list.
722 void dev_mc_init(struct net_device *dev)
724 __hw_addr_init(&dev->mc);
726 EXPORT_SYMBOL(dev_mc_init);
728 #ifdef CONFIG_PROC_FS
729 #include <linux/seq_file.h>
731 static int dev_mc_seq_show(struct seq_file *seq, void *v)
733 struct netdev_hw_addr *ha;
734 struct net_device *dev = v;
736 if (v == SEQ_START_TOKEN)
739 netif_addr_lock_bh(dev);
740 netdev_for_each_mc_addr(ha, dev) {
743 seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
744 dev->name, ha->refcount, ha->global_use);
746 for (i = 0; i < dev->addr_len; i++)
747 seq_printf(seq, "%02x", ha->addr[i]);
751 netif_addr_unlock_bh(dev);
755 static const struct seq_operations dev_mc_seq_ops = {
756 .start = dev_seq_start,
757 .next = dev_seq_next,
758 .stop = dev_seq_stop,
759 .show = dev_mc_seq_show,
762 static int dev_mc_seq_open(struct inode *inode, struct file *file)
764 return seq_open_net(inode, file, &dev_mc_seq_ops,
765 sizeof(struct seq_net_private));
768 static const struct file_operations dev_mc_seq_fops = {
769 .owner = THIS_MODULE,
770 .open = dev_mc_seq_open,
773 .release = seq_release_net,
778 static int __net_init dev_mc_net_init(struct net *net)
780 if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
785 static void __net_exit dev_mc_net_exit(struct net *net)
787 proc_net_remove(net, "dev_mcast");
790 static struct pernet_operations __net_initdata dev_mc_net_ops = {
791 .init = dev_mc_net_init,
792 .exit = dev_mc_net_exit,
795 void __init dev_mcast_init(void)
797 register_pernet_subsys(&dev_mc_net_ops);