Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / net / core / dev_addr_lists.c
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 #include <linux/proc_fs.h>
19
20 /*
21  * General list handling functions
22  */
23
24 static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
25                             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         if (addr_len > MAX_ADDR_LEN)
32                 return -EINVAL;
33
34         list_for_each_entry(ha, &list->list, list) {
35                 if (!memcmp(ha->addr, addr, addr_len) &&
36                     ha->type == addr_type) {
37                         if (global) {
38                                 /* check if addr is already used as global */
39                                 if (ha->global_use)
40                                         return 0;
41                                 else
42                                         ha->global_use = true;
43                         }
44                         ha->refcount++;
45                         return 0;
46                 }
47         }
48
49
50         alloc_size = sizeof(*ha);
51         if (alloc_size < L1_CACHE_BYTES)
52                 alloc_size = L1_CACHE_BYTES;
53         ha = kmalloc(alloc_size, GFP_ATOMIC);
54         if (!ha)
55                 return -ENOMEM;
56         memcpy(ha->addr, addr, addr_len);
57         ha->type = addr_type;
58         ha->refcount = 1;
59         ha->global_use = global;
60         ha->synced = false;
61         list_add_tail_rcu(&ha->list, &list->list);
62         list->count++;
63         return 0;
64 }
65
66 static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
67                          int addr_len, unsigned char addr_type)
68 {
69         return __hw_addr_add_ex(list, addr, addr_len, addr_type, false);
70 }
71
72 static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
73                             unsigned char *addr, int addr_len,
74                             unsigned char addr_type, bool global)
75 {
76         struct netdev_hw_addr *ha;
77
78         list_for_each_entry(ha, &list->list, list) {
79                 if (!memcmp(ha->addr, addr, addr_len) &&
80                     (ha->type == addr_type || !addr_type)) {
81                         if (global) {
82                                 if (!ha->global_use)
83                                         break;
84                                 else
85                                         ha->global_use = false;
86                         }
87                         if (--ha->refcount)
88                                 return 0;
89                         list_del_rcu(&ha->list);
90                         kfree_rcu(ha, rcu_head);
91                         list->count--;
92                         return 0;
93                 }
94         }
95         return -ENOENT;
96 }
97
98 static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
99                          int addr_len, unsigned char addr_type)
100 {
101         return __hw_addr_del_ex(list, addr, addr_len, addr_type, false);
102 }
103
104 int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
105                            struct netdev_hw_addr_list *from_list,
106                            int addr_len, unsigned char addr_type)
107 {
108         int err;
109         struct netdev_hw_addr *ha, *ha2;
110         unsigned char type;
111
112         list_for_each_entry(ha, &from_list->list, list) {
113                 type = addr_type ? addr_type : ha->type;
114                 err = __hw_addr_add(to_list, ha->addr, addr_len, type);
115                 if (err)
116                         goto unroll;
117         }
118         return 0;
119
120 unroll:
121         list_for_each_entry(ha2, &from_list->list, list) {
122                 if (ha2 == ha)
123                         break;
124                 type = addr_type ? addr_type : ha2->type;
125                 __hw_addr_del(to_list, ha2->addr, addr_len, type);
126         }
127         return err;
128 }
129 EXPORT_SYMBOL(__hw_addr_add_multiple);
130
131 void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
132                             struct netdev_hw_addr_list *from_list,
133                             int addr_len, unsigned char addr_type)
134 {
135         struct netdev_hw_addr *ha;
136         unsigned char type;
137
138         list_for_each_entry(ha, &from_list->list, list) {
139                 type = addr_type ? addr_type : ha->type;
140                 __hw_addr_del(to_list, ha->addr, addr_len, type);
141         }
142 }
143 EXPORT_SYMBOL(__hw_addr_del_multiple);
144
145 int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
146                    struct netdev_hw_addr_list *from_list,
147                    int addr_len)
148 {
149         int err = 0;
150         struct netdev_hw_addr *ha, *tmp;
151
152         list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
153                 if (!ha->synced) {
154                         err = __hw_addr_add(to_list, ha->addr,
155                                             addr_len, ha->type);
156                         if (err)
157                                 break;
158                         ha->synced = true;
159                         ha->refcount++;
160                 } else if (ha->refcount == 1) {
161                         __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
162                         __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
163                 }
164         }
165         return err;
166 }
167 EXPORT_SYMBOL(__hw_addr_sync);
168
169 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
170                       struct netdev_hw_addr_list *from_list,
171                       int addr_len)
172 {
173         struct netdev_hw_addr *ha, *tmp;
174
175         list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
176                 if (ha->synced) {
177                         __hw_addr_del(to_list, ha->addr,
178                                       addr_len, ha->type);
179                         ha->synced = false;
180                         __hw_addr_del(from_list, ha->addr,
181                                       addr_len, ha->type);
182                 }
183         }
184 }
185 EXPORT_SYMBOL(__hw_addr_unsync);
186
187 void __hw_addr_flush(struct netdev_hw_addr_list *list)
188 {
189         struct netdev_hw_addr *ha, *tmp;
190
191         list_for_each_entry_safe(ha, tmp, &list->list, list) {
192                 list_del_rcu(&ha->list);
193                 kfree_rcu(ha, rcu_head);
194         }
195         list->count = 0;
196 }
197 EXPORT_SYMBOL(__hw_addr_flush);
198
199 void __hw_addr_init(struct netdev_hw_addr_list *list)
200 {
201         INIT_LIST_HEAD(&list->list);
202         list->count = 0;
203 }
204 EXPORT_SYMBOL(__hw_addr_init);
205
206 /*
207  * Device addresses handling functions
208  */
209
210 /**
211  *      dev_addr_flush - Flush device address list
212  *      @dev: device
213  *
214  *      Flush device address list and reset ->dev_addr.
215  *
216  *      The caller must hold the rtnl_mutex.
217  */
218 void dev_addr_flush(struct net_device *dev)
219 {
220         /* rtnl_mutex must be held here */
221
222         __hw_addr_flush(&dev->dev_addrs);
223         dev->dev_addr = NULL;
224 }
225 EXPORT_SYMBOL(dev_addr_flush);
226
227 /**
228  *      dev_addr_init - Init device address list
229  *      @dev: device
230  *
231  *      Init device address list and create the first element,
232  *      used by ->dev_addr.
233  *
234  *      The caller must hold the rtnl_mutex.
235  */
236 int dev_addr_init(struct net_device *dev)
237 {
238         unsigned char addr[MAX_ADDR_LEN];
239         struct netdev_hw_addr *ha;
240         int err;
241
242         /* rtnl_mutex must be held here */
243
244         __hw_addr_init(&dev->dev_addrs);
245         memset(addr, 0, sizeof(addr));
246         err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
247                             NETDEV_HW_ADDR_T_LAN);
248         if (!err) {
249                 /*
250                  * Get the first (previously created) address from the list
251                  * and set dev_addr pointer to this location.
252                  */
253                 ha = list_first_entry(&dev->dev_addrs.list,
254                                       struct netdev_hw_addr, list);
255                 dev->dev_addr = ha->addr;
256         }
257         return err;
258 }
259 EXPORT_SYMBOL(dev_addr_init);
260
261 /**
262  *      dev_addr_add - Add a device address
263  *      @dev: device
264  *      @addr: address to add
265  *      @addr_type: address type
266  *
267  *      Add a device address to the device or increase the reference count if
268  *      it already exists.
269  *
270  *      The caller must hold the rtnl_mutex.
271  */
272 int dev_addr_add(struct net_device *dev, unsigned char *addr,
273                  unsigned char addr_type)
274 {
275         int err;
276
277         ASSERT_RTNL();
278
279         err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
280         if (!err)
281                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
282         return err;
283 }
284 EXPORT_SYMBOL(dev_addr_add);
285
286 /**
287  *      dev_addr_del - Release a device address.
288  *      @dev: device
289  *      @addr: address to delete
290  *      @addr_type: address type
291  *
292  *      Release reference to a device address and remove it from the device
293  *      if the reference count drops to zero.
294  *
295  *      The caller must hold the rtnl_mutex.
296  */
297 int dev_addr_del(struct net_device *dev, unsigned char *addr,
298                  unsigned char addr_type)
299 {
300         int err;
301         struct netdev_hw_addr *ha;
302
303         ASSERT_RTNL();
304
305         /*
306          * We can not remove the first address from the list because
307          * dev->dev_addr points to that.
308          */
309         ha = list_first_entry(&dev->dev_addrs.list,
310                               struct netdev_hw_addr, list);
311         if (ha->addr == dev->dev_addr && ha->refcount == 1)
312                 return -ENOENT;
313
314         err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
315                             addr_type);
316         if (!err)
317                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
318         return err;
319 }
320 EXPORT_SYMBOL(dev_addr_del);
321
322 /**
323  *      dev_addr_add_multiple - Add device addresses from another device
324  *      @to_dev: device to which addresses will be added
325  *      @from_dev: device from which addresses will be added
326  *      @addr_type: address type - 0 means type will be used from from_dev
327  *
328  *      Add device addresses of the one device to another.
329  **
330  *      The caller must hold the rtnl_mutex.
331  */
332 int dev_addr_add_multiple(struct net_device *to_dev,
333                           struct net_device *from_dev,
334                           unsigned char addr_type)
335 {
336         int err;
337
338         ASSERT_RTNL();
339
340         if (from_dev->addr_len != to_dev->addr_len)
341                 return -EINVAL;
342         err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
343                                      to_dev->addr_len, addr_type);
344         if (!err)
345                 call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
346         return err;
347 }
348 EXPORT_SYMBOL(dev_addr_add_multiple);
349
350 /**
351  *      dev_addr_del_multiple - Delete device addresses by another device
352  *      @to_dev: device where the addresses will be deleted
353  *      @from_dev: device supplying the addresses to be deleted
354  *      @addr_type: address type - 0 means type will be used from from_dev
355  *
356  *      Deletes addresses in to device by the list of addresses in from device.
357  *
358  *      The caller must hold the rtnl_mutex.
359  */
360 int dev_addr_del_multiple(struct net_device *to_dev,
361                           struct net_device *from_dev,
362                           unsigned char addr_type)
363 {
364         ASSERT_RTNL();
365
366         if (from_dev->addr_len != to_dev->addr_len)
367                 return -EINVAL;
368         __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
369                                to_dev->addr_len, addr_type);
370         call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
371         return 0;
372 }
373 EXPORT_SYMBOL(dev_addr_del_multiple);
374
375 /*
376  * Unicast list handling functions
377  */
378
379 /**
380  *      dev_uc_add - Add a secondary unicast address
381  *      @dev: device
382  *      @addr: address to add
383  *
384  *      Add a secondary unicast address to the device or increase
385  *      the reference count if it already exists.
386  */
387 int dev_uc_add(struct net_device *dev, unsigned char *addr)
388 {
389         int err;
390
391         netif_addr_lock_bh(dev);
392         err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
393                             NETDEV_HW_ADDR_T_UNICAST);
394         if (!err)
395                 __dev_set_rx_mode(dev);
396         netif_addr_unlock_bh(dev);
397         return err;
398 }
399 EXPORT_SYMBOL(dev_uc_add);
400
401 /**
402  *      dev_uc_del - Release secondary unicast address.
403  *      @dev: device
404  *      @addr: address to delete
405  *
406  *      Release reference to a secondary unicast address and remove it
407  *      from the device if the reference count drops to zero.
408  */
409 int dev_uc_del(struct net_device *dev, unsigned char *addr)
410 {
411         int err;
412
413         netif_addr_lock_bh(dev);
414         err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
415                             NETDEV_HW_ADDR_T_UNICAST);
416         if (!err)
417                 __dev_set_rx_mode(dev);
418         netif_addr_unlock_bh(dev);
419         return err;
420 }
421 EXPORT_SYMBOL(dev_uc_del);
422
423 /**
424  *      dev_uc_sync - Synchronize device's unicast list to another device
425  *      @to: destination device
426  *      @from: source device
427  *
428  *      Add newly added addresses to the destination device and release
429  *      addresses that have no users left. The source device must be
430  *      locked by netif_tx_lock_bh.
431  *
432  *      This function is intended to be called from the dev->set_rx_mode
433  *      function of layered software devices.
434  */
435 int dev_uc_sync(struct net_device *to, struct net_device *from)
436 {
437         int err = 0;
438
439         if (to->addr_len != from->addr_len)
440                 return -EINVAL;
441
442         netif_addr_lock_bh(to);
443         err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
444         if (!err)
445                 __dev_set_rx_mode(to);
446         netif_addr_unlock_bh(to);
447         return err;
448 }
449 EXPORT_SYMBOL(dev_uc_sync);
450
451 /**
452  *      dev_uc_unsync - Remove synchronized addresses from the destination device
453  *      @to: destination device
454  *      @from: source device
455  *
456  *      Remove all addresses that were added to the destination device by
457  *      dev_uc_sync(). This function is intended to be called from the
458  *      dev->stop function of layered software devices.
459  */
460 void dev_uc_unsync(struct net_device *to, struct net_device *from)
461 {
462         if (to->addr_len != from->addr_len)
463                 return;
464
465         netif_addr_lock_bh(from);
466         netif_addr_lock(to);
467         __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
468         __dev_set_rx_mode(to);
469         netif_addr_unlock(to);
470         netif_addr_unlock_bh(from);
471 }
472 EXPORT_SYMBOL(dev_uc_unsync);
473
474 /**
475  *      dev_uc_flush - Flush unicast addresses
476  *      @dev: device
477  *
478  *      Flush unicast addresses.
479  */
480 void dev_uc_flush(struct net_device *dev)
481 {
482         netif_addr_lock_bh(dev);
483         __hw_addr_flush(&dev->uc);
484         netif_addr_unlock_bh(dev);
485 }
486 EXPORT_SYMBOL(dev_uc_flush);
487
488 /**
489  *      dev_uc_flush - Init unicast address list
490  *      @dev: device
491  *
492  *      Init unicast address list.
493  */
494 void dev_uc_init(struct net_device *dev)
495 {
496         __hw_addr_init(&dev->uc);
497 }
498 EXPORT_SYMBOL(dev_uc_init);
499
500 /*
501  * Multicast list handling functions
502  */
503
504 static int __dev_mc_add(struct net_device *dev, unsigned char *addr,
505                         bool global)
506 {
507         int err;
508
509         netif_addr_lock_bh(dev);
510         err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
511                                NETDEV_HW_ADDR_T_MULTICAST, global);
512         if (!err)
513                 __dev_set_rx_mode(dev);
514         netif_addr_unlock_bh(dev);
515         return err;
516 }
517 /**
518  *      dev_mc_add - Add a multicast address
519  *      @dev: device
520  *      @addr: address to add
521  *
522  *      Add a multicast address to the device or increase
523  *      the reference count if it already exists.
524  */
525 int dev_mc_add(struct net_device *dev, unsigned char *addr)
526 {
527         return __dev_mc_add(dev, addr, false);
528 }
529 EXPORT_SYMBOL(dev_mc_add);
530
531 /**
532  *      dev_mc_add_global - Add a global multicast address
533  *      @dev: device
534  *      @addr: address to add
535  *
536  *      Add a global multicast address to the device.
537  */
538 int dev_mc_add_global(struct net_device *dev, unsigned char *addr)
539 {
540         return __dev_mc_add(dev, addr, true);
541 }
542 EXPORT_SYMBOL(dev_mc_add_global);
543
544 static int __dev_mc_del(struct net_device *dev, unsigned char *addr,
545                         bool global)
546 {
547         int err;
548
549         netif_addr_lock_bh(dev);
550         err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
551                                NETDEV_HW_ADDR_T_MULTICAST, global);
552         if (!err)
553                 __dev_set_rx_mode(dev);
554         netif_addr_unlock_bh(dev);
555         return err;
556 }
557
558 /**
559  *      dev_mc_del - Delete a multicast address.
560  *      @dev: device
561  *      @addr: address to delete
562  *
563  *      Release reference to a multicast address and remove it
564  *      from the device if the reference count drops to zero.
565  */
566 int dev_mc_del(struct net_device *dev, unsigned char *addr)
567 {
568         return __dev_mc_del(dev, addr, false);
569 }
570 EXPORT_SYMBOL(dev_mc_del);
571
572 /**
573  *      dev_mc_del_global - Delete a global multicast address.
574  *      @dev: device
575  *      @addr: address to delete
576  *
577  *      Release reference to a multicast address and remove it
578  *      from the device if the reference count drops to zero.
579  */
580 int dev_mc_del_global(struct net_device *dev, unsigned char *addr)
581 {
582         return __dev_mc_del(dev, addr, true);
583 }
584 EXPORT_SYMBOL(dev_mc_del_global);
585
586 /**
587  *      dev_mc_sync - Synchronize device's unicast list to another device
588  *      @to: destination device
589  *      @from: source device
590  *
591  *      Add newly added addresses to the destination device and release
592  *      addresses that have no users left. The source device must be
593  *      locked by netif_tx_lock_bh.
594  *
595  *      This function is intended to be called from the ndo_set_rx_mode
596  *      function of layered software devices.
597  */
598 int dev_mc_sync(struct net_device *to, struct net_device *from)
599 {
600         int err = 0;
601
602         if (to->addr_len != from->addr_len)
603                 return -EINVAL;
604
605         netif_addr_lock_bh(to);
606         err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
607         if (!err)
608                 __dev_set_rx_mode(to);
609         netif_addr_unlock_bh(to);
610         return err;
611 }
612 EXPORT_SYMBOL(dev_mc_sync);
613
614 /**
615  *      dev_mc_unsync - Remove synchronized addresses from the destination device
616  *      @to: destination device
617  *      @from: source device
618  *
619  *      Remove all addresses that were added to the destination device by
620  *      dev_mc_sync(). This function is intended to be called from the
621  *      dev->stop function of layered software devices.
622  */
623 void dev_mc_unsync(struct net_device *to, struct net_device *from)
624 {
625         if (to->addr_len != from->addr_len)
626                 return;
627
628         netif_addr_lock_bh(from);
629         netif_addr_lock(to);
630         __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
631         __dev_set_rx_mode(to);
632         netif_addr_unlock(to);
633         netif_addr_unlock_bh(from);
634 }
635 EXPORT_SYMBOL(dev_mc_unsync);
636
637 /**
638  *      dev_mc_flush - Flush multicast addresses
639  *      @dev: device
640  *
641  *      Flush multicast addresses.
642  */
643 void dev_mc_flush(struct net_device *dev)
644 {
645         netif_addr_lock_bh(dev);
646         __hw_addr_flush(&dev->mc);
647         netif_addr_unlock_bh(dev);
648 }
649 EXPORT_SYMBOL(dev_mc_flush);
650
651 /**
652  *      dev_mc_flush - Init multicast address list
653  *      @dev: device
654  *
655  *      Init multicast address list.
656  */
657 void dev_mc_init(struct net_device *dev)
658 {
659         __hw_addr_init(&dev->mc);
660 }
661 EXPORT_SYMBOL(dev_mc_init);
662
663 #ifdef CONFIG_PROC_FS
664 #include <linux/seq_file.h>
665
666 static int dev_mc_seq_show(struct seq_file *seq, void *v)
667 {
668         struct netdev_hw_addr *ha;
669         struct net_device *dev = v;
670
671         if (v == SEQ_START_TOKEN)
672                 return 0;
673
674         netif_addr_lock_bh(dev);
675         netdev_for_each_mc_addr(ha, dev) {
676                 int i;
677
678                 seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
679                            dev->name, ha->refcount, ha->global_use);
680
681                 for (i = 0; i < dev->addr_len; i++)
682                         seq_printf(seq, "%02x", ha->addr[i]);
683
684                 seq_putc(seq, '\n');
685         }
686         netif_addr_unlock_bh(dev);
687         return 0;
688 }
689
690 static const struct seq_operations dev_mc_seq_ops = {
691         .start = dev_seq_start,
692         .next  = dev_seq_next,
693         .stop  = dev_seq_stop,
694         .show  = dev_mc_seq_show,
695 };
696
697 static int dev_mc_seq_open(struct inode *inode, struct file *file)
698 {
699         return seq_open_net(inode, file, &dev_mc_seq_ops,
700                             sizeof(struct seq_net_private));
701 }
702
703 static const struct file_operations dev_mc_seq_fops = {
704         .owner   = THIS_MODULE,
705         .open    = dev_mc_seq_open,
706         .read    = seq_read,
707         .llseek  = seq_lseek,
708         .release = seq_release_net,
709 };
710
711 #endif
712
713 static int __net_init dev_mc_net_init(struct net *net)
714 {
715         if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
716                 return -ENOMEM;
717         return 0;
718 }
719
720 static void __net_exit dev_mc_net_exit(struct net *net)
721 {
722         proc_net_remove(net, "dev_mcast");
723 }
724
725 static struct pernet_operations __net_initdata dev_mc_net_ops = {
726         .init = dev_mc_net_init,
727         .exit = dev_mc_net_exit,
728 };
729
730 void __init dev_mcast_init(void)
731 {
732         register_pernet_subsys(&dev_mc_net_ops);
733 }
734