Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dev_addr_lists.c
Go to the documentation of this file.
1 /*
2  * net/core/dev_addr_lists.c - Functions for handling net device lists
3  * Copyright (c) 2010 Jiri Pirko <[email protected]>
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 #include <linux/proc_fs.h>
19 
20 /*
21  * General list handling functions
22  */
23 
24 static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
25  const unsigned char *addr, int addr_len,
26  unsigned char addr_type, bool global)
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 = false;
42  list_add_tail_rcu(&ha->list, &list->list);
43  list->count++;
44 
45  return 0;
46 }
47 
48 static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
49  const unsigned char *addr, int addr_len,
50  unsigned char addr_type, bool global)
51 {
52  struct netdev_hw_addr *ha;
53 
54  if (addr_len > MAX_ADDR_LEN)
55  return -EINVAL;
56 
57  list_for_each_entry(ha, &list->list, list) {
58  if (!memcmp(ha->addr, addr, addr_len) &&
59  ha->type == addr_type) {
60  if (global) {
61  /* check if addr is already used as global */
62  if (ha->global_use)
63  return 0;
64  else
65  ha->global_use = true;
66  }
67  ha->refcount++;
68  return 0;
69  }
70  }
71 
72  return __hw_addr_create_ex(list, addr, addr_len, addr_type, global);
73 }
74 
75 static int __hw_addr_add(struct netdev_hw_addr_list *list,
76  const unsigned char *addr, int addr_len,
77  unsigned char addr_type)
78 {
79  return __hw_addr_add_ex(list, addr, addr_len, addr_type, false);
80 }
81 
82 static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
83  const unsigned char *addr, int addr_len,
84  unsigned char addr_type, bool global)
85 {
86  struct netdev_hw_addr *ha;
87 
88  list_for_each_entry(ha, &list->list, list) {
89  if (!memcmp(ha->addr, addr, addr_len) &&
90  (ha->type == addr_type || !addr_type)) {
91  if (global) {
92  if (!ha->global_use)
93  break;
94  else
95  ha->global_use = false;
96  }
97  if (--ha->refcount)
98  return 0;
99  list_del_rcu(&ha->list);
100  kfree_rcu(ha, rcu_head);
101  list->count--;
102  return 0;
103  }
104  }
105  return -ENOENT;
106 }
107 
108 static int __hw_addr_del(struct netdev_hw_addr_list *list,
109  const unsigned char *addr, int addr_len,
110  unsigned char addr_type)
111 {
112  return __hw_addr_del_ex(list, addr, addr_len, addr_type, false);
113 }
114 
116  struct netdev_hw_addr_list *from_list,
117  int addr_len, unsigned char addr_type)
118 {
119  int err;
120  struct netdev_hw_addr *ha, *ha2;
121  unsigned char type;
122 
123  list_for_each_entry(ha, &from_list->list, list) {
124  type = addr_type ? addr_type : ha->type;
125  err = __hw_addr_add(to_list, ha->addr, addr_len, type);
126  if (err)
127  goto unroll;
128  }
129  return 0;
130 
131 unroll:
132  list_for_each_entry(ha2, &from_list->list, list) {
133  if (ha2 == ha)
134  break;
135  type = addr_type ? addr_type : ha2->type;
136  __hw_addr_del(to_list, ha2->addr, addr_len, type);
137  }
138  return err;
139 }
141 
143  struct netdev_hw_addr_list *from_list,
144  int addr_len, unsigned char addr_type)
145 {
146  struct netdev_hw_addr *ha;
147  unsigned char type;
148 
149  list_for_each_entry(ha, &from_list->list, list) {
150  type = addr_type ? addr_type : ha->type;
151  __hw_addr_del(to_list, ha->addr, addr_len, type);
152  }
153 }
155 
157  struct netdev_hw_addr_list *from_list,
158  int addr_len)
159 {
160  int err = 0;
161  struct netdev_hw_addr *ha, *tmp;
162 
163  list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
164  if (!ha->synced) {
165  err = __hw_addr_add(to_list, ha->addr,
166  addr_len, ha->type);
167  if (err)
168  break;
169  ha->synced = true;
170  ha->refcount++;
171  } else if (ha->refcount == 1) {
172  __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
173  __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
174  }
175  }
176  return err;
177 }
179 
181  struct netdev_hw_addr_list *from_list,
182  int addr_len)
183 {
184  struct netdev_hw_addr *ha, *tmp;
185 
186  list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
187  if (ha->synced) {
188  __hw_addr_del(to_list, ha->addr,
189  addr_len, ha->type);
190  ha->synced = false;
191  __hw_addr_del(from_list, ha->addr,
192  addr_len, ha->type);
193  }
194  }
195 }
197 
199 {
200  struct netdev_hw_addr *ha, *tmp;
201 
202  list_for_each_entry_safe(ha, tmp, &list->list, list) {
203  list_del_rcu(&ha->list);
204  kfree_rcu(ha, rcu_head);
205  }
206  list->count = 0;
207 }
209 
211 {
212  INIT_LIST_HEAD(&list->list);
213  list->count = 0;
214 }
216 
217 /*
218  * Device addresses handling functions
219  */
220 
230 {
231  /* rtnl_mutex must be held here */
232 
233  __hw_addr_flush(&dev->dev_addrs);
234  dev->dev_addr = NULL;
235 }
237 
248 {
249  unsigned char addr[MAX_ADDR_LEN];
250  struct netdev_hw_addr *ha;
251  int err;
252 
253  /* rtnl_mutex must be held here */
254 
255  __hw_addr_init(&dev->dev_addrs);
256  memset(addr, 0, sizeof(addr));
257  err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
259  if (!err) {
260  /*
261  * Get the first (previously created) address from the list
262  * and set dev_addr pointer to this location.
263  */
264  ha = list_first_entry(&dev->dev_addrs.list,
265  struct netdev_hw_addr, list);
266  dev->dev_addr = ha->addr;
267  }
268  return err;
269 }
271 
283 int dev_addr_add(struct net_device *dev, const unsigned char *addr,
284  unsigned char addr_type)
285 {
286  int err;
287 
288  ASSERT_RTNL();
289 
290  err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
291  if (!err)
293  return err;
294 }
296 
308 int dev_addr_del(struct net_device *dev, const unsigned char *addr,
309  unsigned char addr_type)
310 {
311  int err;
312  struct netdev_hw_addr *ha;
313 
314  ASSERT_RTNL();
315 
316  /*
317  * We can not remove the first address from the list because
318  * dev->dev_addr points to that.
319  */
320  ha = list_first_entry(&dev->dev_addrs.list,
321  struct netdev_hw_addr, list);
322  if (!memcmp(ha->addr, addr, dev->addr_len) &&
323  ha->type == addr_type && ha->refcount == 1)
324  return -ENOENT;
325 
326  err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
327  addr_type);
328  if (!err)
330  return err;
331 }
333 
345  struct net_device *from_dev,
346  unsigned char addr_type)
347 {
348  int err;
349 
350  ASSERT_RTNL();
351 
352  if (from_dev->addr_len != to_dev->addr_len)
353  return -EINVAL;
354  err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
355  to_dev->addr_len, addr_type);
356  if (!err)
358  return err;
359 }
361 
373  struct net_device *from_dev,
374  unsigned char addr_type)
375 {
376  ASSERT_RTNL();
377 
378  if (from_dev->addr_len != to_dev->addr_len)
379  return -EINVAL;
380  __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
381  to_dev->addr_len, addr_type);
383  return 0;
384 }
386 
387 /*
388  * Unicast list handling functions
389  */
390 
396 int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
397 {
398  struct netdev_hw_addr *ha;
399  int err;
400 
401  netif_addr_lock_bh(dev);
402  list_for_each_entry(ha, &dev->uc.list, list) {
403  if (!memcmp(ha->addr, addr, dev->addr_len) &&
405  err = -EEXIST;
406  goto out;
407  }
408  }
409  err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
411  if (!err)
412  __dev_set_rx_mode(dev);
413 out:
414  netif_addr_unlock_bh(dev);
415  return err;
416 }
418 
427 int dev_uc_add(struct net_device *dev, const unsigned char *addr)
428 {
429  int err;
430 
431  netif_addr_lock_bh(dev);
432  err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
434  if (!err)
435  __dev_set_rx_mode(dev);
436  netif_addr_unlock_bh(dev);
437  return err;
438 }
440 
449 int dev_uc_del(struct net_device *dev, const unsigned char *addr)
450 {
451  int err;
452 
453  netif_addr_lock_bh(dev);
454  err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
456  if (!err)
457  __dev_set_rx_mode(dev);
458  netif_addr_unlock_bh(dev);
459  return err;
460 }
462 
475 int dev_uc_sync(struct net_device *to, struct net_device *from)
476 {
477  int err = 0;
478 
479  if (to->addr_len != from->addr_len)
480  return -EINVAL;
481 
482  netif_addr_lock_nested(to);
483  err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
484  if (!err)
485  __dev_set_rx_mode(to);
486  netif_addr_unlock(to);
487  return err;
488 }
490 
500 void dev_uc_unsync(struct net_device *to, struct net_device *from)
501 {
502  if (to->addr_len != from->addr_len)
503  return;
504 
505  netif_addr_lock_bh(from);
506  netif_addr_lock_nested(to);
507  __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
508  __dev_set_rx_mode(to);
509  netif_addr_unlock(to);
510  netif_addr_unlock_bh(from);
511 }
513 
521 {
522  netif_addr_lock_bh(dev);
523  __hw_addr_flush(&dev->uc);
524  netif_addr_unlock_bh(dev);
525 }
527 
535 {
536  __hw_addr_init(&dev->uc);
537 }
539 
540 /*
541  * Multicast list handling functions
542  */
543 
549 int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
550 {
551  struct netdev_hw_addr *ha;
552  int err;
553 
554  netif_addr_lock_bh(dev);
555  list_for_each_entry(ha, &dev->mc.list, list) {
556  if (!memcmp(ha->addr, addr, dev->addr_len) &&
558  err = -EEXIST;
559  goto out;
560  }
561  }
562  err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
564  if (!err)
565  __dev_set_rx_mode(dev);
566 out:
567  netif_addr_unlock_bh(dev);
568  return err;
569 }
571 
572 static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
573  bool global)
574 {
575  int err;
576 
577  netif_addr_lock_bh(dev);
578  err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
580  if (!err)
581  __dev_set_rx_mode(dev);
582  netif_addr_unlock_bh(dev);
583  return err;
584 }
593 int dev_mc_add(struct net_device *dev, const unsigned char *addr)
594 {
595  return __dev_mc_add(dev, addr, false);
596 }
598 
606 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
607 {
608  return __dev_mc_add(dev, addr, true);
609 }
611 
612 static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
613  bool global)
614 {
615  int err;
616 
617  netif_addr_lock_bh(dev);
618  err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
620  if (!err)
621  __dev_set_rx_mode(dev);
622  netif_addr_unlock_bh(dev);
623  return err;
624 }
625 
634 int dev_mc_del(struct net_device *dev, const unsigned char *addr)
635 {
636  return __dev_mc_del(dev, addr, false);
637 }
639 
648 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
649 {
650  return __dev_mc_del(dev, addr, true);
651 }
653 
666 int dev_mc_sync(struct net_device *to, struct net_device *from)
667 {
668  int err = 0;
669 
670  if (to->addr_len != from->addr_len)
671  return -EINVAL;
672 
673  netif_addr_lock_nested(to);
674  err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
675  if (!err)
676  __dev_set_rx_mode(to);
677  netif_addr_unlock(to);
678  return err;
679 }
681 
691 void dev_mc_unsync(struct net_device *to, struct net_device *from)
692 {
693  if (to->addr_len != from->addr_len)
694  return;
695 
696  netif_addr_lock_bh(from);
697  netif_addr_lock_nested(to);
698  __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
699  __dev_set_rx_mode(to);
700  netif_addr_unlock(to);
701  netif_addr_unlock_bh(from);
702 }
704 
711 void dev_mc_flush(struct net_device *dev)
712 {
713  netif_addr_lock_bh(dev);
714  __hw_addr_flush(&dev->mc);
715  netif_addr_unlock_bh(dev);
716 }
718 
725 void dev_mc_init(struct net_device *dev)
726 {
727  __hw_addr_init(&dev->mc);
728 }
730 
731 #ifdef CONFIG_PROC_FS
732 #include <linux/seq_file.h>
733 
734 static int dev_mc_seq_show(struct seq_file *seq, void *v)
735 {
736  struct netdev_hw_addr *ha;
737  struct net_device *dev = v;
738 
739  if (v == SEQ_START_TOKEN)
740  return 0;
741 
742  netif_addr_lock_bh(dev);
743  netdev_for_each_mc_addr(ha, dev) {
744  int i;
745 
746  seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
747  dev->name, ha->refcount, ha->global_use);
748 
749  for (i = 0; i < dev->addr_len; i++)
750  seq_printf(seq, "%02x", ha->addr[i]);
751 
752  seq_putc(seq, '\n');
753  }
754  netif_addr_unlock_bh(dev);
755  return 0;
756 }
757 
758 static const struct seq_operations dev_mc_seq_ops = {
759  .start = dev_seq_start,
760  .next = dev_seq_next,
761  .stop = dev_seq_stop,
762  .show = dev_mc_seq_show,
763 };
764 
765 static int dev_mc_seq_open(struct inode *inode, struct file *file)
766 {
767  return seq_open_net(inode, file, &dev_mc_seq_ops,
768  sizeof(struct seq_net_private));
769 }
770 
771 static const struct file_operations dev_mc_seq_fops = {
772  .owner = THIS_MODULE,
773  .open = dev_mc_seq_open,
774  .read = seq_read,
775  .llseek = seq_lseek,
776  .release = seq_release_net,
777 };
778 
779 #endif
780 
781 static int __net_init dev_mc_net_init(struct net *net)
782 {
783  if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
784  return -ENOMEM;
785  return 0;
786 }
787 
788 static void __net_exit dev_mc_net_exit(struct net *net)
789 {
790  proc_net_remove(net, "dev_mcast");
791 }
792 
793 static struct pernet_operations __net_initdata dev_mc_net_ops = {
794  .init = dev_mc_net_init,
795  .exit = dev_mc_net_exit,
796 };
797 
799 {
800  register_pernet_subsys(&dev_mc_net_ops);
801 }
802