1
2
3
4
5
6
7
8
9
10#include <linux/netdevice.h>
11#include <linux/rtnetlink.h>
12#include <linux/export.h>
13#include <linux/list.h>
14
15
16
17
18
19static struct netdev_hw_addr*
20__hw_addr_create(const unsigned char *addr, int addr_len,
21 unsigned char addr_type, bool global, bool sync)
22{
23 struct netdev_hw_addr *ha;
24 int alloc_size;
25
26 alloc_size = sizeof(*ha);
27 if (alloc_size < L1_CACHE_BYTES)
28 alloc_size = L1_CACHE_BYTES;
29 ha = kmalloc(alloc_size, GFP_ATOMIC);
30 if (!ha)
31 return NULL;
32 memcpy(ha->addr, addr, addr_len);
33 ha->type = addr_type;
34 ha->refcount = 1;
35 ha->global_use = global;
36 ha->synced = sync ? 1 : 0;
37 ha->sync_cnt = 0;
38
39 return ha;
40}
41
42static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
43 const unsigned char *addr, int addr_len,
44 unsigned char addr_type, bool global, bool sync,
45 int sync_count, bool exclusive)
46{
47 struct rb_node **ins_point = &list->tree.rb_node, *parent = NULL;
48 struct netdev_hw_addr *ha;
49
50 if (addr_len > MAX_ADDR_LEN)
51 return -EINVAL;
52
53 ha = list_first_entry(&list->list, struct netdev_hw_addr, list);
54 if (ha && !memcmp(addr, ha->addr, addr_len) &&
55 (!addr_type || addr_type == ha->type))
56 goto found_it;
57
58 while (*ins_point) {
59 int diff;
60
61 ha = rb_entry(*ins_point, struct netdev_hw_addr, node);
62 diff = memcmp(addr, ha->addr, addr_len);
63 if (diff == 0)
64 diff = memcmp(&addr_type, &ha->type, sizeof(addr_type));
65
66 parent = *ins_point;
67 if (diff < 0) {
68 ins_point = &parent->rb_left;
69 } else if (diff > 0) {
70 ins_point = &parent->rb_right;
71 } else {
72found_it:
73 if (exclusive)
74 return -EEXIST;
75 if (global) {
76
77 if (ha->global_use)
78 return 0;
79 else
80 ha->global_use = true;
81 }
82 if (sync) {
83 if (ha->synced && sync_count)
84 return -EEXIST;
85 else
86 ha->synced++;
87 }
88 ha->refcount++;
89 return 0;
90 }
91 }
92
93 ha = __hw_addr_create(addr, addr_len, addr_type, global, sync);
94 if (!ha)
95 return -ENOMEM;
96
97
98
99
100
101 if (list->count > 0) {
102 rb_link_node(&ha->node, parent, ins_point);
103 rb_insert_color(&ha->node, &list->tree);
104 } else {
105 RB_CLEAR_NODE(&ha->node);
106 }
107
108 list_add_tail_rcu(&ha->list, &list->list);
109 list->count++;
110
111 return 0;
112}
113
114static int __hw_addr_add(struct netdev_hw_addr_list *list,
115 const unsigned char *addr, int addr_len,
116 unsigned char addr_type)
117{
118 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
119 0, false);
120}
121
122static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
123 struct netdev_hw_addr *ha, bool global,
124 bool sync)
125{
126 if (global && !ha->global_use)
127 return -ENOENT;
128
129 if (sync && !ha->synced)
130 return -ENOENT;
131
132 if (global)
133 ha->global_use = false;
134
135 if (sync)
136 ha->synced--;
137
138 if (--ha->refcount)
139 return 0;
140
141 if (!RB_EMPTY_NODE(&ha->node))
142 rb_erase(&ha->node, &list->tree);
143
144 list_del_rcu(&ha->list);
145 kfree_rcu(ha, rcu_head);
146 list->count--;
147 return 0;
148}
149
150static struct netdev_hw_addr *__hw_addr_lookup(struct netdev_hw_addr_list *list,
151 const unsigned char *addr, int addr_len,
152 unsigned char addr_type)
153{
154 struct netdev_hw_addr *ha;
155 struct rb_node *node;
156
157
158
159
160
161 ha = list_first_entry(&list->list, struct netdev_hw_addr, list);
162 if (ha && !memcmp(addr, ha->addr, addr_len) &&
163 (!addr_type || addr_type == ha->type))
164 return ha;
165
166 node = list->tree.rb_node;
167
168 while (node) {
169 struct netdev_hw_addr *ha = rb_entry(node, struct netdev_hw_addr, node);
170 int diff = memcmp(addr, ha->addr, addr_len);
171
172 if (diff == 0 && addr_type)
173 diff = memcmp(&addr_type, &ha->type, sizeof(addr_type));
174
175 if (diff < 0)
176 node = node->rb_left;
177 else if (diff > 0)
178 node = node->rb_right;
179 else
180 return ha;
181 }
182
183 return NULL;
184}
185
186static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
187 const unsigned char *addr, int addr_len,
188 unsigned char addr_type, bool global, bool sync)
189{
190 struct netdev_hw_addr *ha = __hw_addr_lookup(list, addr, addr_len, addr_type);
191
192 if (!ha)
193 return -ENOENT;
194 return __hw_addr_del_entry(list, ha, global, sync);
195}
196
197static int __hw_addr_del(struct netdev_hw_addr_list *list,
198 const unsigned char *addr, int addr_len,
199 unsigned char addr_type)
200{
201 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
202}
203
204static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
205 struct netdev_hw_addr *ha,
206 int addr_len)
207{
208 int err;
209
210 err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
211 false, true, ha->sync_cnt, false);
212 if (err && err != -EEXIST)
213 return err;
214
215 if (!err) {
216 ha->sync_cnt++;
217 ha->refcount++;
218 }
219
220 return 0;
221}
222
223static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
224 struct netdev_hw_addr_list *from_list,
225 struct netdev_hw_addr *ha,
226 int addr_len)
227{
228 int err;
229
230 err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
231 false, true);
232 if (err)
233 return;
234 ha->sync_cnt--;
235
236 __hw_addr_del_entry(from_list, ha, false, false);
237}
238
239static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
240 struct netdev_hw_addr_list *from_list,
241 int addr_len)
242{
243 int err = 0;
244 struct netdev_hw_addr *ha, *tmp;
245
246 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
247 if (ha->sync_cnt == ha->refcount) {
248 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
249 } else {
250 err = __hw_addr_sync_one(to_list, ha, addr_len);
251 if (err)
252 break;
253 }
254 }
255 return err;
256}
257
258
259
260
261
262
263int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
264 struct netdev_hw_addr_list *from_list,
265 int addr_len)
266{
267 int err = 0;
268 struct netdev_hw_addr *ha, *tmp;
269
270 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
271 if (!ha->sync_cnt) {
272 err = __hw_addr_sync_one(to_list, ha, addr_len);
273 if (err)
274 break;
275 } else if (ha->refcount == 1)
276 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
277 }
278 return err;
279}
280EXPORT_SYMBOL(__hw_addr_sync);
281
282void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
283 struct netdev_hw_addr_list *from_list,
284 int addr_len)
285{
286 struct netdev_hw_addr *ha, *tmp;
287
288 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
289 if (ha->sync_cnt)
290 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
291 }
292}
293EXPORT_SYMBOL(__hw_addr_unsync);
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
309 struct net_device *dev,
310 int (*sync)(struct net_device *, const unsigned char *),
311 int (*unsync)(struct net_device *,
312 const unsigned char *))
313{
314 struct netdev_hw_addr *ha, *tmp;
315 int err;
316
317
318 list_for_each_entry_safe(ha, tmp, &list->list, list) {
319 if (!ha->sync_cnt || ha->refcount != 1)
320 continue;
321
322
323 if (unsync && unsync(dev, ha->addr))
324 continue;
325
326 ha->sync_cnt--;
327 __hw_addr_del_entry(list, ha, false, false);
328 }
329
330
331 list_for_each_entry_safe(ha, tmp, &list->list, list) {
332 if (ha->sync_cnt)
333 continue;
334
335 err = sync(dev, ha->addr);
336 if (err)
337 return err;
338
339 ha->sync_cnt++;
340 ha->refcount++;
341 }
342
343 return 0;
344}
345EXPORT_SYMBOL(__hw_addr_sync_dev);
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
364 struct net_device *dev,
365 int (*sync)(struct net_device *,
366 const unsigned char *, int),
367 int (*unsync)(struct net_device *,
368 const unsigned char *, int))
369{
370 struct netdev_hw_addr *ha, *tmp;
371 int err, ref_cnt;
372
373
374 list_for_each_entry_safe(ha, tmp, &list->list, list) {
375
376 if ((ha->sync_cnt << 1) <= ha->refcount)
377 continue;
378
379
380 ref_cnt = ha->refcount - ha->sync_cnt;
381 if (unsync && unsync(dev, ha->addr, ref_cnt))
382 continue;
383
384 ha->refcount = (ref_cnt << 1) + 1;
385 ha->sync_cnt = ref_cnt;
386 __hw_addr_del_entry(list, ha, false, false);
387 }
388
389
390 list_for_each_entry_safe(ha, tmp, &list->list, list) {
391
392 if ((ha->sync_cnt << 1) >= ha->refcount)
393 continue;
394
395 ref_cnt = ha->refcount - ha->sync_cnt;
396 err = sync(dev, ha->addr, ref_cnt);
397 if (err)
398 return err;
399
400 ha->refcount = ref_cnt << 1;
401 ha->sync_cnt = ref_cnt;
402 }
403
404 return 0;
405}
406EXPORT_SYMBOL(__hw_addr_ref_sync_dev);
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
423 struct net_device *dev,
424 int (*unsync)(struct net_device *,
425 const unsigned char *, int))
426{
427 struct netdev_hw_addr *ha, *tmp;
428
429 list_for_each_entry_safe(ha, tmp, &list->list, list) {
430 if (!ha->sync_cnt)
431 continue;
432
433
434 if (unsync && unsync(dev, ha->addr, ha->sync_cnt))
435 continue;
436
437 ha->refcount -= ha->sync_cnt - 1;
438 ha->sync_cnt = 0;
439 __hw_addr_del_entry(list, ha, false, false);
440 }
441}
442EXPORT_SYMBOL(__hw_addr_ref_unsync_dev);
443
444
445
446
447
448
449
450
451
452
453
454
455
456void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
457 struct net_device *dev,
458 int (*unsync)(struct net_device *,
459 const unsigned char *))
460{
461 struct netdev_hw_addr *ha, *tmp;
462
463 list_for_each_entry_safe(ha, tmp, &list->list, list) {
464 if (!ha->sync_cnt)
465 continue;
466
467
468 if (unsync && unsync(dev, ha->addr))
469 continue;
470
471 ha->sync_cnt--;
472 __hw_addr_del_entry(list, ha, false, false);
473 }
474}
475EXPORT_SYMBOL(__hw_addr_unsync_dev);
476
477static void __hw_addr_flush(struct netdev_hw_addr_list *list)
478{
479 struct netdev_hw_addr *ha, *tmp;
480
481 list->tree = RB_ROOT;
482 list_for_each_entry_safe(ha, tmp, &list->list, list) {
483 list_del_rcu(&ha->list);
484 kfree_rcu(ha, rcu_head);
485 }
486 list->count = 0;
487}
488
489void __hw_addr_init(struct netdev_hw_addr_list *list)
490{
491 INIT_LIST_HEAD(&list->list);
492 list->count = 0;
493 list->tree = RB_ROOT;
494}
495EXPORT_SYMBOL(__hw_addr_init);
496
497
498
499
500
501
502
503
504
505
506
507
508
509void dev_addr_flush(struct net_device *dev)
510{
511
512
513 __hw_addr_flush(&dev->dev_addrs);
514 dev->dev_addr = NULL;
515}
516EXPORT_SYMBOL(dev_addr_flush);
517
518
519
520
521
522
523
524
525
526
527int dev_addr_init(struct net_device *dev)
528{
529 unsigned char addr[MAX_ADDR_LEN];
530 struct netdev_hw_addr *ha;
531 int err;
532
533
534
535 __hw_addr_init(&dev->dev_addrs);
536 memset(addr, 0, sizeof(addr));
537 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
538 NETDEV_HW_ADDR_T_LAN);
539 if (!err) {
540
541
542
543
544 ha = list_first_entry(&dev->dev_addrs.list,
545 struct netdev_hw_addr, list);
546 dev->dev_addr = ha->addr;
547 }
548 return err;
549}
550EXPORT_SYMBOL(dev_addr_init);
551
552
553
554
555
556
557
558
559
560
561
562
563int dev_addr_add(struct net_device *dev, const unsigned char *addr,
564 unsigned char addr_type)
565{
566 int err;
567
568 ASSERT_RTNL();
569
570 err = dev_pre_changeaddr_notify(dev, addr, NULL);
571 if (err)
572 return err;
573 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
574 if (!err)
575 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
576 return err;
577}
578EXPORT_SYMBOL(dev_addr_add);
579
580
581
582
583
584
585
586
587
588
589
590
591int dev_addr_del(struct net_device *dev, const unsigned char *addr,
592 unsigned char addr_type)
593{
594 int err;
595 struct netdev_hw_addr *ha;
596
597 ASSERT_RTNL();
598
599
600
601
602
603 ha = list_first_entry(&dev->dev_addrs.list,
604 struct netdev_hw_addr, list);
605 if (!memcmp(ha->addr, addr, dev->addr_len) &&
606 ha->type == addr_type && ha->refcount == 1)
607 return -ENOENT;
608
609 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
610 addr_type);
611 if (!err)
612 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
613 return err;
614}
615EXPORT_SYMBOL(dev_addr_del);
616
617
618
619
620
621
622
623
624
625
626int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
627{
628 int err;
629
630 netif_addr_lock_bh(dev);
631 err = __hw_addr_add_ex(&dev->uc, addr, dev->addr_len,
632 NETDEV_HW_ADDR_T_UNICAST, true, false,
633 0, true);
634 if (!err)
635 __dev_set_rx_mode(dev);
636 netif_addr_unlock_bh(dev);
637 return err;
638}
639EXPORT_SYMBOL(dev_uc_add_excl);
640
641
642
643
644
645
646
647
648
649int dev_uc_add(struct net_device *dev, const unsigned char *addr)
650{
651 int err;
652
653 netif_addr_lock_bh(dev);
654 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
655 NETDEV_HW_ADDR_T_UNICAST);
656 if (!err)
657 __dev_set_rx_mode(dev);
658 netif_addr_unlock_bh(dev);
659 return err;
660}
661EXPORT_SYMBOL(dev_uc_add);
662
663
664
665
666
667
668
669
670
671int dev_uc_del(struct net_device *dev, const unsigned char *addr)
672{
673 int err;
674
675 netif_addr_lock_bh(dev);
676 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
677 NETDEV_HW_ADDR_T_UNICAST);
678 if (!err)
679 __dev_set_rx_mode(dev);
680 netif_addr_unlock_bh(dev);
681 return err;
682}
683EXPORT_SYMBOL(dev_uc_del);
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698int dev_uc_sync(struct net_device *to, struct net_device *from)
699{
700 int err = 0;
701
702 if (to->addr_len != from->addr_len)
703 return -EINVAL;
704
705 netif_addr_lock(to);
706 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
707 if (!err)
708 __dev_set_rx_mode(to);
709 netif_addr_unlock(to);
710 return err;
711}
712EXPORT_SYMBOL(dev_uc_sync);
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
729{
730 int err = 0;
731
732 if (to->addr_len != from->addr_len)
733 return -EINVAL;
734
735 netif_addr_lock(to);
736 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
737 if (!err)
738 __dev_set_rx_mode(to);
739 netif_addr_unlock(to);
740 return err;
741}
742EXPORT_SYMBOL(dev_uc_sync_multiple);
743
744
745
746
747
748
749
750
751
752
753void dev_uc_unsync(struct net_device *to, struct net_device *from)
754{
755 if (to->addr_len != from->addr_len)
756 return;
757
758
759
760
761
762
763
764
765
766
767 netif_addr_lock_bh(from);
768 netif_addr_lock(to);
769 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
770 __dev_set_rx_mode(to);
771 netif_addr_unlock(to);
772 netif_addr_unlock_bh(from);
773}
774EXPORT_SYMBOL(dev_uc_unsync);
775
776
777
778
779
780
781
782void dev_uc_flush(struct net_device *dev)
783{
784 netif_addr_lock_bh(dev);
785 __hw_addr_flush(&dev->uc);
786 netif_addr_unlock_bh(dev);
787}
788EXPORT_SYMBOL(dev_uc_flush);
789
790
791
792
793
794
795
796void dev_uc_init(struct net_device *dev)
797{
798 __hw_addr_init(&dev->uc);
799}
800EXPORT_SYMBOL(dev_uc_init);
801
802
803
804
805
806
807
808
809
810
811int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
812{
813 int err;
814
815 netif_addr_lock_bh(dev);
816 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
817 NETDEV_HW_ADDR_T_MULTICAST, true, false,
818 0, true);
819 if (!err)
820 __dev_set_rx_mode(dev);
821 netif_addr_unlock_bh(dev);
822 return err;
823}
824EXPORT_SYMBOL(dev_mc_add_excl);
825
826static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
827 bool global)
828{
829 int err;
830
831 netif_addr_lock_bh(dev);
832 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
833 NETDEV_HW_ADDR_T_MULTICAST, global, false,
834 0, false);
835 if (!err)
836 __dev_set_rx_mode(dev);
837 netif_addr_unlock_bh(dev);
838 return err;
839}
840
841
842
843
844
845
846
847
848int dev_mc_add(struct net_device *dev, const unsigned char *addr)
849{
850 return __dev_mc_add(dev, addr, false);
851}
852EXPORT_SYMBOL(dev_mc_add);
853
854
855
856
857
858
859
860
861int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
862{
863 return __dev_mc_add(dev, addr, true);
864}
865EXPORT_SYMBOL(dev_mc_add_global);
866
867static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
868 bool global)
869{
870 int err;
871
872 netif_addr_lock_bh(dev);
873 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
874 NETDEV_HW_ADDR_T_MULTICAST, global, false);
875 if (!err)
876 __dev_set_rx_mode(dev);
877 netif_addr_unlock_bh(dev);
878 return err;
879}
880
881
882
883
884
885
886
887
888
889int dev_mc_del(struct net_device *dev, const unsigned char *addr)
890{
891 return __dev_mc_del(dev, addr, false);
892}
893EXPORT_SYMBOL(dev_mc_del);
894
895
896
897
898
899
900
901
902
903int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
904{
905 return __dev_mc_del(dev, addr, true);
906}
907EXPORT_SYMBOL(dev_mc_del_global);
908
909
910
911
912
913
914
915
916
917
918
919
920
921int dev_mc_sync(struct net_device *to, struct net_device *from)
922{
923 int err = 0;
924
925 if (to->addr_len != from->addr_len)
926 return -EINVAL;
927
928 netif_addr_lock(to);
929 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
930 if (!err)
931 __dev_set_rx_mode(to);
932 netif_addr_unlock(to);
933 return err;
934}
935EXPORT_SYMBOL(dev_mc_sync);
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
952{
953 int err = 0;
954
955 if (to->addr_len != from->addr_len)
956 return -EINVAL;
957
958 netif_addr_lock(to);
959 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
960 if (!err)
961 __dev_set_rx_mode(to);
962 netif_addr_unlock(to);
963 return err;
964}
965EXPORT_SYMBOL(dev_mc_sync_multiple);
966
967
968
969
970
971
972
973
974
975
976void dev_mc_unsync(struct net_device *to, struct net_device *from)
977{
978 if (to->addr_len != from->addr_len)
979 return;
980
981
982 netif_addr_lock_bh(from);
983 netif_addr_lock(to);
984 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
985 __dev_set_rx_mode(to);
986 netif_addr_unlock(to);
987 netif_addr_unlock_bh(from);
988}
989EXPORT_SYMBOL(dev_mc_unsync);
990
991
992
993
994
995
996
997void dev_mc_flush(struct net_device *dev)
998{
999 netif_addr_lock_bh(dev);
1000 __hw_addr_flush(&dev->mc);
1001 netif_addr_unlock_bh(dev);
1002}
1003EXPORT_SYMBOL(dev_mc_flush);
1004
1005
1006
1007
1008
1009
1010
1011void dev_mc_init(struct net_device *dev)
1012{
1013 __hw_addr_init(&dev->mc);
1014}
1015EXPORT_SYMBOL(dev_mc_init);
1016