Loading...
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
19/*
20 * General list handling functions
21 */
22
23static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
24 const unsigned char *addr, int addr_len,
25 unsigned char addr_type, bool global,
26 bool sync)
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 = sync ? 1 : 0;
42 ha->sync_cnt = 0;
43 list_add_tail_rcu(&ha->list, &list->list);
44 list->count++;
45
46 return 0;
47}
48
49static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
50 const unsigned char *addr, int addr_len,
51 unsigned char addr_type, bool global, bool sync,
52 int sync_count)
53{
54 struct netdev_hw_addr *ha;
55
56 if (addr_len > MAX_ADDR_LEN)
57 return -EINVAL;
58
59 list_for_each_entry(ha, &list->list, list) {
60 if (!memcmp(ha->addr, addr, addr_len) &&
61 ha->type == addr_type) {
62 if (global) {
63 /* check if addr is already used as global */
64 if (ha->global_use)
65 return 0;
66 else
67 ha->global_use = true;
68 }
69 if (sync) {
70 if (ha->synced && sync_count)
71 return -EEXIST;
72 else
73 ha->synced++;
74 }
75 ha->refcount++;
76 return 0;
77 }
78 }
79
80 return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
81 sync);
82}
83
84static int __hw_addr_add(struct netdev_hw_addr_list *list,
85 const unsigned char *addr, int addr_len,
86 unsigned char addr_type)
87{
88 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
89 0);
90}
91
92static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
93 struct netdev_hw_addr *ha, bool global,
94 bool sync)
95{
96 if (global && !ha->global_use)
97 return -ENOENT;
98
99 if (sync && !ha->synced)
100 return -ENOENT;
101
102 if (global)
103 ha->global_use = false;
104
105 if (sync)
106 ha->synced--;
107
108 if (--ha->refcount)
109 return 0;
110 list_del_rcu(&ha->list);
111 kfree_rcu(ha, rcu_head);
112 list->count--;
113 return 0;
114}
115
116static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
117 const unsigned char *addr, int addr_len,
118 unsigned char addr_type, bool global, bool sync)
119{
120 struct netdev_hw_addr *ha;
121
122 list_for_each_entry(ha, &list->list, list) {
123 if (!memcmp(ha->addr, addr, addr_len) &&
124 (ha->type == addr_type || !addr_type))
125 return __hw_addr_del_entry(list, ha, global, sync);
126 }
127 return -ENOENT;
128}
129
130static int __hw_addr_del(struct netdev_hw_addr_list *list,
131 const unsigned char *addr, int addr_len,
132 unsigned char addr_type)
133{
134 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
135}
136
137static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
138 struct netdev_hw_addr *ha,
139 int addr_len)
140{
141 int err;
142
143 err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
144 false, true, ha->sync_cnt);
145 if (err && err != -EEXIST)
146 return err;
147
148 if (!err) {
149 ha->sync_cnt++;
150 ha->refcount++;
151 }
152
153 return 0;
154}
155
156static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
157 struct netdev_hw_addr_list *from_list,
158 struct netdev_hw_addr *ha,
159 int addr_len)
160{
161 int err;
162
163 err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
164 false, true);
165 if (err)
166 return;
167 ha->sync_cnt--;
168 /* address on from list is not marked synced */
169 __hw_addr_del_entry(from_list, ha, false, false);
170}
171
172static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
173 struct netdev_hw_addr_list *from_list,
174 int addr_len)
175{
176 int err = 0;
177 struct netdev_hw_addr *ha, *tmp;
178
179 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
180 if (ha->sync_cnt == ha->refcount) {
181 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
182 } else {
183 err = __hw_addr_sync_one(to_list, ha, addr_len);
184 if (err)
185 break;
186 }
187 }
188 return err;
189}
190
191/* This function only works where there is a strict 1-1 relationship
192 * between source and destionation of they synch. If you ever need to
193 * sync addresses to more then 1 destination, you need to use
194 * __hw_addr_sync_multiple().
195 */
196int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
197 struct netdev_hw_addr_list *from_list,
198 int addr_len)
199{
200 int err = 0;
201 struct netdev_hw_addr *ha, *tmp;
202
203 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
204 if (!ha->sync_cnt) {
205 err = __hw_addr_sync_one(to_list, ha, addr_len);
206 if (err)
207 break;
208 } else if (ha->refcount == 1)
209 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
210 }
211 return err;
212}
213EXPORT_SYMBOL(__hw_addr_sync);
214
215void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
216 struct netdev_hw_addr_list *from_list,
217 int addr_len)
218{
219 struct netdev_hw_addr *ha, *tmp;
220
221 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
222 if (ha->sync_cnt)
223 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
224 }
225}
226EXPORT_SYMBOL(__hw_addr_unsync);
227
228static void __hw_addr_flush(struct netdev_hw_addr_list *list)
229{
230 struct netdev_hw_addr *ha, *tmp;
231
232 list_for_each_entry_safe(ha, tmp, &list->list, list) {
233 list_del_rcu(&ha->list);
234 kfree_rcu(ha, rcu_head);
235 }
236 list->count = 0;
237}
238
239void __hw_addr_init(struct netdev_hw_addr_list *list)
240{
241 INIT_LIST_HEAD(&list->list);
242 list->count = 0;
243}
244EXPORT_SYMBOL(__hw_addr_init);
245
246/*
247 * Device addresses handling functions
248 */
249
250/**
251 * dev_addr_flush - Flush device address list
252 * @dev: device
253 *
254 * Flush device address list and reset ->dev_addr.
255 *
256 * The caller must hold the rtnl_mutex.
257 */
258void dev_addr_flush(struct net_device *dev)
259{
260 /* rtnl_mutex must be held here */
261
262 __hw_addr_flush(&dev->dev_addrs);
263 dev->dev_addr = NULL;
264}
265EXPORT_SYMBOL(dev_addr_flush);
266
267/**
268 * dev_addr_init - Init device address list
269 * @dev: device
270 *
271 * Init device address list and create the first element,
272 * used by ->dev_addr.
273 *
274 * The caller must hold the rtnl_mutex.
275 */
276int dev_addr_init(struct net_device *dev)
277{
278 unsigned char addr[MAX_ADDR_LEN];
279 struct netdev_hw_addr *ha;
280 int err;
281
282 /* rtnl_mutex must be held here */
283
284 __hw_addr_init(&dev->dev_addrs);
285 memset(addr, 0, sizeof(addr));
286 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
287 NETDEV_HW_ADDR_T_LAN);
288 if (!err) {
289 /*
290 * Get the first (previously created) address from the list
291 * and set dev_addr pointer to this location.
292 */
293 ha = list_first_entry(&dev->dev_addrs.list,
294 struct netdev_hw_addr, list);
295 dev->dev_addr = ha->addr;
296 }
297 return err;
298}
299EXPORT_SYMBOL(dev_addr_init);
300
301/**
302 * dev_addr_add - Add a device address
303 * @dev: device
304 * @addr: address to add
305 * @addr_type: address type
306 *
307 * Add a device address to the device or increase the reference count if
308 * it already exists.
309 *
310 * The caller must hold the rtnl_mutex.
311 */
312int dev_addr_add(struct net_device *dev, const unsigned char *addr,
313 unsigned char addr_type)
314{
315 int err;
316
317 ASSERT_RTNL();
318
319 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
320 if (!err)
321 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
322 return err;
323}
324EXPORT_SYMBOL(dev_addr_add);
325
326/**
327 * dev_addr_del - Release a device address.
328 * @dev: device
329 * @addr: address to delete
330 * @addr_type: address type
331 *
332 * Release reference to a device address and remove it from the device
333 * if the reference count drops to zero.
334 *
335 * The caller must hold the rtnl_mutex.
336 */
337int dev_addr_del(struct net_device *dev, const unsigned char *addr,
338 unsigned char addr_type)
339{
340 int err;
341 struct netdev_hw_addr *ha;
342
343 ASSERT_RTNL();
344
345 /*
346 * We can not remove the first address from the list because
347 * dev->dev_addr points to that.
348 */
349 ha = list_first_entry(&dev->dev_addrs.list,
350 struct netdev_hw_addr, list);
351 if (!memcmp(ha->addr, addr, dev->addr_len) &&
352 ha->type == addr_type && ha->refcount == 1)
353 return -ENOENT;
354
355 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
356 addr_type);
357 if (!err)
358 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
359 return err;
360}
361EXPORT_SYMBOL(dev_addr_del);
362
363/*
364 * Unicast list handling functions
365 */
366
367/**
368 * dev_uc_add_excl - Add a global secondary unicast address
369 * @dev: device
370 * @addr: address to add
371 */
372int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
373{
374 struct netdev_hw_addr *ha;
375 int err;
376
377 netif_addr_lock_bh(dev);
378 list_for_each_entry(ha, &dev->uc.list, list) {
379 if (!memcmp(ha->addr, addr, dev->addr_len) &&
380 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
381 err = -EEXIST;
382 goto out;
383 }
384 }
385 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
386 NETDEV_HW_ADDR_T_UNICAST, true, false);
387 if (!err)
388 __dev_set_rx_mode(dev);
389out:
390 netif_addr_unlock_bh(dev);
391 return err;
392}
393EXPORT_SYMBOL(dev_uc_add_excl);
394
395/**
396 * dev_uc_add - Add a secondary unicast address
397 * @dev: device
398 * @addr: address to add
399 *
400 * Add a secondary unicast address to the device or increase
401 * the reference count if it already exists.
402 */
403int dev_uc_add(struct net_device *dev, const unsigned char *addr)
404{
405 int err;
406
407 netif_addr_lock_bh(dev);
408 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
409 NETDEV_HW_ADDR_T_UNICAST);
410 if (!err)
411 __dev_set_rx_mode(dev);
412 netif_addr_unlock_bh(dev);
413 return err;
414}
415EXPORT_SYMBOL(dev_uc_add);
416
417/**
418 * dev_uc_del - Release secondary unicast address.
419 * @dev: device
420 * @addr: address to delete
421 *
422 * Release reference to a secondary unicast address and remove it
423 * from the device if the reference count drops to zero.
424 */
425int dev_uc_del(struct net_device *dev, const unsigned char *addr)
426{
427 int err;
428
429 netif_addr_lock_bh(dev);
430 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
431 NETDEV_HW_ADDR_T_UNICAST);
432 if (!err)
433 __dev_set_rx_mode(dev);
434 netif_addr_unlock_bh(dev);
435 return err;
436}
437EXPORT_SYMBOL(dev_uc_del);
438
439/**
440 * dev_uc_sync - Synchronize device's unicast list to another device
441 * @to: destination device
442 * @from: source device
443 *
444 * Add newly added addresses to the destination device and release
445 * addresses that have no users left. The source device must be
446 * locked by netif_addr_lock_bh.
447 *
448 * This function is intended to be called from the dev->set_rx_mode
449 * function of layered software devices. This function assumes that
450 * addresses will only ever be synced to the @to devices and no other.
451 */
452int dev_uc_sync(struct net_device *to, struct net_device *from)
453{
454 int err = 0;
455
456 if (to->addr_len != from->addr_len)
457 return -EINVAL;
458
459 netif_addr_lock_nested(to);
460 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
461 if (!err)
462 __dev_set_rx_mode(to);
463 netif_addr_unlock(to);
464 return err;
465}
466EXPORT_SYMBOL(dev_uc_sync);
467
468/**
469 * dev_uc_sync_multiple - Synchronize device's unicast list to another
470 * device, but allow for multiple calls to sync to multiple devices.
471 * @to: destination device
472 * @from: source device
473 *
474 * Add newly added addresses to the destination device and release
475 * addresses that have been deleted from the source. The source device
476 * must be locked by netif_addr_lock_bh.
477 *
478 * This function is intended to be called from the dev->set_rx_mode
479 * function of layered software devices. It allows for a single source
480 * device to be synced to multiple destination devices.
481 */
482int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
483{
484 int err = 0;
485
486 if (to->addr_len != from->addr_len)
487 return -EINVAL;
488
489 netif_addr_lock_nested(to);
490 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
491 if (!err)
492 __dev_set_rx_mode(to);
493 netif_addr_unlock(to);
494 return err;
495}
496EXPORT_SYMBOL(dev_uc_sync_multiple);
497
498/**
499 * dev_uc_unsync - Remove synchronized addresses from the destination device
500 * @to: destination device
501 * @from: source device
502 *
503 * Remove all addresses that were added to the destination device by
504 * dev_uc_sync(). This function is intended to be called from the
505 * dev->stop function of layered software devices.
506 */
507void dev_uc_unsync(struct net_device *to, struct net_device *from)
508{
509 if (to->addr_len != from->addr_len)
510 return;
511
512 netif_addr_lock_bh(from);
513 netif_addr_lock_nested(to);
514 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
515 __dev_set_rx_mode(to);
516 netif_addr_unlock(to);
517 netif_addr_unlock_bh(from);
518}
519EXPORT_SYMBOL(dev_uc_unsync);
520
521/**
522 * dev_uc_flush - Flush unicast addresses
523 * @dev: device
524 *
525 * Flush unicast addresses.
526 */
527void dev_uc_flush(struct net_device *dev)
528{
529 netif_addr_lock_bh(dev);
530 __hw_addr_flush(&dev->uc);
531 netif_addr_unlock_bh(dev);
532}
533EXPORT_SYMBOL(dev_uc_flush);
534
535/**
536 * dev_uc_flush - Init unicast address list
537 * @dev: device
538 *
539 * Init unicast address list.
540 */
541void dev_uc_init(struct net_device *dev)
542{
543 __hw_addr_init(&dev->uc);
544}
545EXPORT_SYMBOL(dev_uc_init);
546
547/*
548 * Multicast list handling functions
549 */
550
551/**
552 * dev_mc_add_excl - Add a global secondary multicast address
553 * @dev: device
554 * @addr: address to add
555 */
556int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
557{
558 struct netdev_hw_addr *ha;
559 int err;
560
561 netif_addr_lock_bh(dev);
562 list_for_each_entry(ha, &dev->mc.list, list) {
563 if (!memcmp(ha->addr, addr, dev->addr_len) &&
564 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
565 err = -EEXIST;
566 goto out;
567 }
568 }
569 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
570 NETDEV_HW_ADDR_T_MULTICAST, true, false);
571 if (!err)
572 __dev_set_rx_mode(dev);
573out:
574 netif_addr_unlock_bh(dev);
575 return err;
576}
577EXPORT_SYMBOL(dev_mc_add_excl);
578
579static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
580 bool global)
581{
582 int err;
583
584 netif_addr_lock_bh(dev);
585 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
586 NETDEV_HW_ADDR_T_MULTICAST, global, false, 0);
587 if (!err)
588 __dev_set_rx_mode(dev);
589 netif_addr_unlock_bh(dev);
590 return err;
591}
592/**
593 * dev_mc_add - Add a multicast address
594 * @dev: device
595 * @addr: address to add
596 *
597 * Add a multicast address to the device or increase
598 * the reference count if it already exists.
599 */
600int dev_mc_add(struct net_device *dev, const unsigned char *addr)
601{
602 return __dev_mc_add(dev, addr, false);
603}
604EXPORT_SYMBOL(dev_mc_add);
605
606/**
607 * dev_mc_add_global - Add a global multicast address
608 * @dev: device
609 * @addr: address to add
610 *
611 * Add a global multicast address to the device.
612 */
613int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
614{
615 return __dev_mc_add(dev, addr, true);
616}
617EXPORT_SYMBOL(dev_mc_add_global);
618
619static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
620 bool global)
621{
622 int err;
623
624 netif_addr_lock_bh(dev);
625 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
626 NETDEV_HW_ADDR_T_MULTICAST, global, false);
627 if (!err)
628 __dev_set_rx_mode(dev);
629 netif_addr_unlock_bh(dev);
630 return err;
631}
632
633/**
634 * dev_mc_del - Delete a multicast address.
635 * @dev: device
636 * @addr: address to delete
637 *
638 * Release reference to a multicast address and remove it
639 * from the device if the reference count drops to zero.
640 */
641int dev_mc_del(struct net_device *dev, const unsigned char *addr)
642{
643 return __dev_mc_del(dev, addr, false);
644}
645EXPORT_SYMBOL(dev_mc_del);
646
647/**
648 * dev_mc_del_global - Delete a global multicast address.
649 * @dev: device
650 * @addr: address to delete
651 *
652 * Release reference to a multicast address and remove it
653 * from the device if the reference count drops to zero.
654 */
655int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
656{
657 return __dev_mc_del(dev, addr, true);
658}
659EXPORT_SYMBOL(dev_mc_del_global);
660
661/**
662 * dev_mc_sync - Synchronize device's multicast list to another device
663 * @to: destination device
664 * @from: source device
665 *
666 * Add newly added addresses to the destination device and release
667 * addresses that have no users left. The source device must be
668 * locked by netif_addr_lock_bh.
669 *
670 * This function is intended to be called from the ndo_set_rx_mode
671 * function of layered software devices.
672 */
673int dev_mc_sync(struct net_device *to, struct net_device *from)
674{
675 int err = 0;
676
677 if (to->addr_len != from->addr_len)
678 return -EINVAL;
679
680 netif_addr_lock_nested(to);
681 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
682 if (!err)
683 __dev_set_rx_mode(to);
684 netif_addr_unlock(to);
685 return err;
686}
687EXPORT_SYMBOL(dev_mc_sync);
688
689/**
690 * dev_mc_sync_multiple - Synchronize device's multicast list to another
691 * device, but allow for multiple calls to sync to multiple devices.
692 * @to: destination device
693 * @from: source device
694 *
695 * Add newly added addresses to the destination device and release
696 * addresses that have no users left. The source device must be
697 * locked by netif_addr_lock_bh.
698 *
699 * This function is intended to be called from the ndo_set_rx_mode
700 * function of layered software devices. It allows for a single
701 * source device to be synced to multiple destination devices.
702 */
703int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
704{
705 int err = 0;
706
707 if (to->addr_len != from->addr_len)
708 return -EINVAL;
709
710 netif_addr_lock_nested(to);
711 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
712 if (!err)
713 __dev_set_rx_mode(to);
714 netif_addr_unlock(to);
715 return err;
716}
717EXPORT_SYMBOL(dev_mc_sync_multiple);
718
719/**
720 * dev_mc_unsync - Remove synchronized addresses from the destination device
721 * @to: destination device
722 * @from: source device
723 *
724 * Remove all addresses that were added to the destination device by
725 * dev_mc_sync(). This function is intended to be called from the
726 * dev->stop function of layered software devices.
727 */
728void dev_mc_unsync(struct net_device *to, struct net_device *from)
729{
730 if (to->addr_len != from->addr_len)
731 return;
732
733 netif_addr_lock_bh(from);
734 netif_addr_lock_nested(to);
735 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
736 __dev_set_rx_mode(to);
737 netif_addr_unlock(to);
738 netif_addr_unlock_bh(from);
739}
740EXPORT_SYMBOL(dev_mc_unsync);
741
742/**
743 * dev_mc_flush - Flush multicast addresses
744 * @dev: device
745 *
746 * Flush multicast addresses.
747 */
748void dev_mc_flush(struct net_device *dev)
749{
750 netif_addr_lock_bh(dev);
751 __hw_addr_flush(&dev->mc);
752 netif_addr_unlock_bh(dev);
753}
754EXPORT_SYMBOL(dev_mc_flush);
755
756/**
757 * dev_mc_flush - Init multicast address list
758 * @dev: device
759 *
760 * Init multicast address list.
761 */
762void dev_mc_init(struct net_device *dev)
763{
764 __hw_addr_init(&dev->mc);
765}
766EXPORT_SYMBOL(dev_mc_init);
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
19/*
20 * General list handling functions
21 */
22
23static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
24 const unsigned char *addr, int addr_len,
25 unsigned char addr_type, bool global,
26 bool sync)
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 = sync ? 1 : 0;
42 ha->sync_cnt = 0;
43 list_add_tail_rcu(&ha->list, &list->list);
44 list->count++;
45
46 return 0;
47}
48
49static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
50 const unsigned char *addr, int addr_len,
51 unsigned char addr_type, bool global, bool sync,
52 int sync_count)
53{
54 struct netdev_hw_addr *ha;
55
56 if (addr_len > MAX_ADDR_LEN)
57 return -EINVAL;
58
59 list_for_each_entry(ha, &list->list, list) {
60 if (ha->type == addr_type &&
61 !memcmp(ha->addr, addr, addr_len)) {
62 if (global) {
63 /* check if addr is already used as global */
64 if (ha->global_use)
65 return 0;
66 else
67 ha->global_use = true;
68 }
69 if (sync) {
70 if (ha->synced && sync_count)
71 return -EEXIST;
72 else
73 ha->synced++;
74 }
75 ha->refcount++;
76 return 0;
77 }
78 }
79
80 return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
81 sync);
82}
83
84static int __hw_addr_add(struct netdev_hw_addr_list *list,
85 const unsigned char *addr, int addr_len,
86 unsigned char addr_type)
87{
88 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
89 0);
90}
91
92static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
93 struct netdev_hw_addr *ha, bool global,
94 bool sync)
95{
96 if (global && !ha->global_use)
97 return -ENOENT;
98
99 if (sync && !ha->synced)
100 return -ENOENT;
101
102 if (global)
103 ha->global_use = false;
104
105 if (sync)
106 ha->synced--;
107
108 if (--ha->refcount)
109 return 0;
110 list_del_rcu(&ha->list);
111 kfree_rcu(ha, rcu_head);
112 list->count--;
113 return 0;
114}
115
116static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
117 const unsigned char *addr, int addr_len,
118 unsigned char addr_type, bool global, bool sync)
119{
120 struct netdev_hw_addr *ha;
121
122 list_for_each_entry(ha, &list->list, list) {
123 if (!memcmp(ha->addr, addr, addr_len) &&
124 (ha->type == addr_type || !addr_type))
125 return __hw_addr_del_entry(list, ha, global, sync);
126 }
127 return -ENOENT;
128}
129
130static int __hw_addr_del(struct netdev_hw_addr_list *list,
131 const unsigned char *addr, int addr_len,
132 unsigned char addr_type)
133{
134 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
135}
136
137static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
138 struct netdev_hw_addr *ha,
139 int addr_len)
140{
141 int err;
142
143 err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
144 false, true, ha->sync_cnt);
145 if (err && err != -EEXIST)
146 return err;
147
148 if (!err) {
149 ha->sync_cnt++;
150 ha->refcount++;
151 }
152
153 return 0;
154}
155
156static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
157 struct netdev_hw_addr_list *from_list,
158 struct netdev_hw_addr *ha,
159 int addr_len)
160{
161 int err;
162
163 err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
164 false, true);
165 if (err)
166 return;
167 ha->sync_cnt--;
168 /* address on from list is not marked synced */
169 __hw_addr_del_entry(from_list, ha, false, false);
170}
171
172static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
173 struct netdev_hw_addr_list *from_list,
174 int addr_len)
175{
176 int err = 0;
177 struct netdev_hw_addr *ha, *tmp;
178
179 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
180 if (ha->sync_cnt == ha->refcount) {
181 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
182 } else {
183 err = __hw_addr_sync_one(to_list, ha, addr_len);
184 if (err)
185 break;
186 }
187 }
188 return err;
189}
190
191/* This function only works where there is a strict 1-1 relationship
192 * between source and destionation of they synch. If you ever need to
193 * sync addresses to more then 1 destination, you need to use
194 * __hw_addr_sync_multiple().
195 */
196int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
197 struct netdev_hw_addr_list *from_list,
198 int addr_len)
199{
200 int err = 0;
201 struct netdev_hw_addr *ha, *tmp;
202
203 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
204 if (!ha->sync_cnt) {
205 err = __hw_addr_sync_one(to_list, ha, addr_len);
206 if (err)
207 break;
208 } else if (ha->refcount == 1)
209 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
210 }
211 return err;
212}
213EXPORT_SYMBOL(__hw_addr_sync);
214
215void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
216 struct netdev_hw_addr_list *from_list,
217 int addr_len)
218{
219 struct netdev_hw_addr *ha, *tmp;
220
221 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
222 if (ha->sync_cnt)
223 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
224 }
225}
226EXPORT_SYMBOL(__hw_addr_unsync);
227
228/**
229 * __hw_addr_sync_dev - Synchonize device's multicast list
230 * @list: address list to syncronize
231 * @dev: device to sync
232 * @sync: function to call if address should be added
233 * @unsync: function to call if address should be removed
234 *
235 * This funciton is intended to be called from the ndo_set_rx_mode
236 * function of devices that require explicit address add/remove
237 * notifications. The unsync function may be NULL in which case
238 * the addresses requiring removal will simply be removed without
239 * any notification to the device.
240 **/
241int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
242 struct net_device *dev,
243 int (*sync)(struct net_device *, const unsigned char *),
244 int (*unsync)(struct net_device *,
245 const unsigned char *))
246{
247 struct netdev_hw_addr *ha, *tmp;
248 int err;
249
250 /* first go through and flush out any stale entries */
251 list_for_each_entry_safe(ha, tmp, &list->list, list) {
252 if (!ha->sync_cnt || ha->refcount != 1)
253 continue;
254
255 /* if unsync is defined and fails defer unsyncing address */
256 if (unsync && unsync(dev, ha->addr))
257 continue;
258
259 ha->sync_cnt--;
260 __hw_addr_del_entry(list, ha, false, false);
261 }
262
263 /* go through and sync new entries to the list */
264 list_for_each_entry_safe(ha, tmp, &list->list, list) {
265 if (ha->sync_cnt)
266 continue;
267
268 err = sync(dev, ha->addr);
269 if (err)
270 return err;
271
272 ha->sync_cnt++;
273 ha->refcount++;
274 }
275
276 return 0;
277}
278EXPORT_SYMBOL(__hw_addr_sync_dev);
279
280/**
281 * __hw_addr_unsync_dev - Remove synchronized addresses from device
282 * @list: address list to remove synchronized addresses from
283 * @dev: device to sync
284 * @unsync: function to call if address should be removed
285 *
286 * Remove all addresses that were added to the device by __hw_addr_sync_dev().
287 * This function is intended to be called from the ndo_stop or ndo_open
288 * functions on devices that require explicit address add/remove
289 * notifications. If the unsync function pointer is NULL then this function
290 * can be used to just reset the sync_cnt for the addresses in the list.
291 **/
292void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
293 struct net_device *dev,
294 int (*unsync)(struct net_device *,
295 const unsigned char *))
296{
297 struct netdev_hw_addr *ha, *tmp;
298
299 list_for_each_entry_safe(ha, tmp, &list->list, list) {
300 if (!ha->sync_cnt)
301 continue;
302
303 /* if unsync is defined and fails defer unsyncing address */
304 if (unsync && unsync(dev, ha->addr))
305 continue;
306
307 ha->sync_cnt--;
308 __hw_addr_del_entry(list, ha, false, false);
309 }
310}
311EXPORT_SYMBOL(__hw_addr_unsync_dev);
312
313static void __hw_addr_flush(struct netdev_hw_addr_list *list)
314{
315 struct netdev_hw_addr *ha, *tmp;
316
317 list_for_each_entry_safe(ha, tmp, &list->list, list) {
318 list_del_rcu(&ha->list);
319 kfree_rcu(ha, rcu_head);
320 }
321 list->count = 0;
322}
323
324void __hw_addr_init(struct netdev_hw_addr_list *list)
325{
326 INIT_LIST_HEAD(&list->list);
327 list->count = 0;
328}
329EXPORT_SYMBOL(__hw_addr_init);
330
331/*
332 * Device addresses handling functions
333 */
334
335/**
336 * dev_addr_flush - Flush device address list
337 * @dev: device
338 *
339 * Flush device address list and reset ->dev_addr.
340 *
341 * The caller must hold the rtnl_mutex.
342 */
343void dev_addr_flush(struct net_device *dev)
344{
345 /* rtnl_mutex must be held here */
346
347 __hw_addr_flush(&dev->dev_addrs);
348 dev->dev_addr = NULL;
349}
350EXPORT_SYMBOL(dev_addr_flush);
351
352/**
353 * dev_addr_init - Init device address list
354 * @dev: device
355 *
356 * Init device address list and create the first element,
357 * used by ->dev_addr.
358 *
359 * The caller must hold the rtnl_mutex.
360 */
361int dev_addr_init(struct net_device *dev)
362{
363 unsigned char addr[MAX_ADDR_LEN];
364 struct netdev_hw_addr *ha;
365 int err;
366
367 /* rtnl_mutex must be held here */
368
369 __hw_addr_init(&dev->dev_addrs);
370 memset(addr, 0, sizeof(addr));
371 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
372 NETDEV_HW_ADDR_T_LAN);
373 if (!err) {
374 /*
375 * Get the first (previously created) address from the list
376 * and set dev_addr pointer to this location.
377 */
378 ha = list_first_entry(&dev->dev_addrs.list,
379 struct netdev_hw_addr, list);
380 dev->dev_addr = ha->addr;
381 }
382 return err;
383}
384EXPORT_SYMBOL(dev_addr_init);
385
386/**
387 * dev_addr_add - Add a device address
388 * @dev: device
389 * @addr: address to add
390 * @addr_type: address type
391 *
392 * Add a device address to the device or increase the reference count if
393 * it already exists.
394 *
395 * The caller must hold the rtnl_mutex.
396 */
397int dev_addr_add(struct net_device *dev, const unsigned char *addr,
398 unsigned char addr_type)
399{
400 int err;
401
402 ASSERT_RTNL();
403
404 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
405 if (!err)
406 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
407 return err;
408}
409EXPORT_SYMBOL(dev_addr_add);
410
411/**
412 * dev_addr_del - Release a device address.
413 * @dev: device
414 * @addr: address to delete
415 * @addr_type: address type
416 *
417 * Release reference to a device address and remove it from the device
418 * if the reference count drops to zero.
419 *
420 * The caller must hold the rtnl_mutex.
421 */
422int dev_addr_del(struct net_device *dev, const unsigned char *addr,
423 unsigned char addr_type)
424{
425 int err;
426 struct netdev_hw_addr *ha;
427
428 ASSERT_RTNL();
429
430 /*
431 * We can not remove the first address from the list because
432 * dev->dev_addr points to that.
433 */
434 ha = list_first_entry(&dev->dev_addrs.list,
435 struct netdev_hw_addr, list);
436 if (!memcmp(ha->addr, addr, dev->addr_len) &&
437 ha->type == addr_type && ha->refcount == 1)
438 return -ENOENT;
439
440 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
441 addr_type);
442 if (!err)
443 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
444 return err;
445}
446EXPORT_SYMBOL(dev_addr_del);
447
448/*
449 * Unicast list handling functions
450 */
451
452/**
453 * dev_uc_add_excl - Add a global secondary unicast address
454 * @dev: device
455 * @addr: address to add
456 */
457int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
458{
459 struct netdev_hw_addr *ha;
460 int err;
461
462 netif_addr_lock_bh(dev);
463 list_for_each_entry(ha, &dev->uc.list, list) {
464 if (!memcmp(ha->addr, addr, dev->addr_len) &&
465 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
466 err = -EEXIST;
467 goto out;
468 }
469 }
470 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
471 NETDEV_HW_ADDR_T_UNICAST, true, false);
472 if (!err)
473 __dev_set_rx_mode(dev);
474out:
475 netif_addr_unlock_bh(dev);
476 return err;
477}
478EXPORT_SYMBOL(dev_uc_add_excl);
479
480/**
481 * dev_uc_add - Add a secondary unicast address
482 * @dev: device
483 * @addr: address to add
484 *
485 * Add a secondary unicast address to the device or increase
486 * the reference count if it already exists.
487 */
488int dev_uc_add(struct net_device *dev, const unsigned char *addr)
489{
490 int err;
491
492 netif_addr_lock_bh(dev);
493 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
494 NETDEV_HW_ADDR_T_UNICAST);
495 if (!err)
496 __dev_set_rx_mode(dev);
497 netif_addr_unlock_bh(dev);
498 return err;
499}
500EXPORT_SYMBOL(dev_uc_add);
501
502/**
503 * dev_uc_del - Release secondary unicast address.
504 * @dev: device
505 * @addr: address to delete
506 *
507 * Release reference to a secondary unicast address and remove it
508 * from the device if the reference count drops to zero.
509 */
510int dev_uc_del(struct net_device *dev, const unsigned char *addr)
511{
512 int err;
513
514 netif_addr_lock_bh(dev);
515 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
516 NETDEV_HW_ADDR_T_UNICAST);
517 if (!err)
518 __dev_set_rx_mode(dev);
519 netif_addr_unlock_bh(dev);
520 return err;
521}
522EXPORT_SYMBOL(dev_uc_del);
523
524/**
525 * dev_uc_sync - Synchronize device's unicast list to another device
526 * @to: destination device
527 * @from: source device
528 *
529 * Add newly added addresses to the destination device and release
530 * addresses that have no users left. The source device must be
531 * locked by netif_addr_lock_bh.
532 *
533 * This function is intended to be called from the dev->set_rx_mode
534 * function of layered software devices. This function assumes that
535 * addresses will only ever be synced to the @to devices and no other.
536 */
537int dev_uc_sync(struct net_device *to, struct net_device *from)
538{
539 int err = 0;
540
541 if (to->addr_len != from->addr_len)
542 return -EINVAL;
543
544 netif_addr_lock_nested(to);
545 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
546 if (!err)
547 __dev_set_rx_mode(to);
548 netif_addr_unlock(to);
549 return err;
550}
551EXPORT_SYMBOL(dev_uc_sync);
552
553/**
554 * dev_uc_sync_multiple - Synchronize device's unicast list to another
555 * device, but allow for multiple calls to sync to multiple devices.
556 * @to: destination device
557 * @from: source device
558 *
559 * Add newly added addresses to the destination device and release
560 * addresses that have been deleted from the source. The source device
561 * must be locked by netif_addr_lock_bh.
562 *
563 * This function is intended to be called from the dev->set_rx_mode
564 * function of layered software devices. It allows for a single source
565 * device to be synced to multiple destination devices.
566 */
567int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
568{
569 int err = 0;
570
571 if (to->addr_len != from->addr_len)
572 return -EINVAL;
573
574 netif_addr_lock_nested(to);
575 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
576 if (!err)
577 __dev_set_rx_mode(to);
578 netif_addr_unlock(to);
579 return err;
580}
581EXPORT_SYMBOL(dev_uc_sync_multiple);
582
583/**
584 * dev_uc_unsync - Remove synchronized addresses from the destination device
585 * @to: destination device
586 * @from: source device
587 *
588 * Remove all addresses that were added to the destination device by
589 * dev_uc_sync(). This function is intended to be called from the
590 * dev->stop function of layered software devices.
591 */
592void dev_uc_unsync(struct net_device *to, struct net_device *from)
593{
594 if (to->addr_len != from->addr_len)
595 return;
596
597 netif_addr_lock_bh(from);
598 netif_addr_lock_nested(to);
599 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
600 __dev_set_rx_mode(to);
601 netif_addr_unlock(to);
602 netif_addr_unlock_bh(from);
603}
604EXPORT_SYMBOL(dev_uc_unsync);
605
606/**
607 * dev_uc_flush - Flush unicast addresses
608 * @dev: device
609 *
610 * Flush unicast addresses.
611 */
612void dev_uc_flush(struct net_device *dev)
613{
614 netif_addr_lock_bh(dev);
615 __hw_addr_flush(&dev->uc);
616 netif_addr_unlock_bh(dev);
617}
618EXPORT_SYMBOL(dev_uc_flush);
619
620/**
621 * dev_uc_flush - Init unicast address list
622 * @dev: device
623 *
624 * Init unicast address list.
625 */
626void dev_uc_init(struct net_device *dev)
627{
628 __hw_addr_init(&dev->uc);
629}
630EXPORT_SYMBOL(dev_uc_init);
631
632/*
633 * Multicast list handling functions
634 */
635
636/**
637 * dev_mc_add_excl - Add a global secondary multicast address
638 * @dev: device
639 * @addr: address to add
640 */
641int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
642{
643 struct netdev_hw_addr *ha;
644 int err;
645
646 netif_addr_lock_bh(dev);
647 list_for_each_entry(ha, &dev->mc.list, list) {
648 if (!memcmp(ha->addr, addr, dev->addr_len) &&
649 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
650 err = -EEXIST;
651 goto out;
652 }
653 }
654 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
655 NETDEV_HW_ADDR_T_MULTICAST, true, false);
656 if (!err)
657 __dev_set_rx_mode(dev);
658out:
659 netif_addr_unlock_bh(dev);
660 return err;
661}
662EXPORT_SYMBOL(dev_mc_add_excl);
663
664static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
665 bool global)
666{
667 int err;
668
669 netif_addr_lock_bh(dev);
670 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
671 NETDEV_HW_ADDR_T_MULTICAST, global, false, 0);
672 if (!err)
673 __dev_set_rx_mode(dev);
674 netif_addr_unlock_bh(dev);
675 return err;
676}
677/**
678 * dev_mc_add - Add a multicast address
679 * @dev: device
680 * @addr: address to add
681 *
682 * Add a multicast address to the device or increase
683 * the reference count if it already exists.
684 */
685int dev_mc_add(struct net_device *dev, const unsigned char *addr)
686{
687 return __dev_mc_add(dev, addr, false);
688}
689EXPORT_SYMBOL(dev_mc_add);
690
691/**
692 * dev_mc_add_global - Add a global multicast address
693 * @dev: device
694 * @addr: address to add
695 *
696 * Add a global multicast address to the device.
697 */
698int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
699{
700 return __dev_mc_add(dev, addr, true);
701}
702EXPORT_SYMBOL(dev_mc_add_global);
703
704static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
705 bool global)
706{
707 int err;
708
709 netif_addr_lock_bh(dev);
710 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
711 NETDEV_HW_ADDR_T_MULTICAST, global, false);
712 if (!err)
713 __dev_set_rx_mode(dev);
714 netif_addr_unlock_bh(dev);
715 return err;
716}
717
718/**
719 * dev_mc_del - Delete a multicast address.
720 * @dev: device
721 * @addr: address to delete
722 *
723 * Release reference to a multicast address and remove it
724 * from the device if the reference count drops to zero.
725 */
726int dev_mc_del(struct net_device *dev, const unsigned char *addr)
727{
728 return __dev_mc_del(dev, addr, false);
729}
730EXPORT_SYMBOL(dev_mc_del);
731
732/**
733 * dev_mc_del_global - Delete a global multicast address.
734 * @dev: device
735 * @addr: address to delete
736 *
737 * Release reference to a multicast address and remove it
738 * from the device if the reference count drops to zero.
739 */
740int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
741{
742 return __dev_mc_del(dev, addr, true);
743}
744EXPORT_SYMBOL(dev_mc_del_global);
745
746/**
747 * dev_mc_sync - Synchronize device's multicast list to another device
748 * @to: destination device
749 * @from: source device
750 *
751 * Add newly added addresses to the destination device and release
752 * addresses that have no users left. The source device must be
753 * locked by netif_addr_lock_bh.
754 *
755 * This function is intended to be called from the ndo_set_rx_mode
756 * function of layered software devices.
757 */
758int dev_mc_sync(struct net_device *to, struct net_device *from)
759{
760 int err = 0;
761
762 if (to->addr_len != from->addr_len)
763 return -EINVAL;
764
765 netif_addr_lock_nested(to);
766 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
767 if (!err)
768 __dev_set_rx_mode(to);
769 netif_addr_unlock(to);
770 return err;
771}
772EXPORT_SYMBOL(dev_mc_sync);
773
774/**
775 * dev_mc_sync_multiple - Synchronize device's multicast list to another
776 * device, but allow for multiple calls to sync to multiple devices.
777 * @to: destination device
778 * @from: source device
779 *
780 * Add newly added addresses to the destination device and release
781 * addresses that have no users left. The source device must be
782 * locked by netif_addr_lock_bh.
783 *
784 * This function is intended to be called from the ndo_set_rx_mode
785 * function of layered software devices. It allows for a single
786 * source device to be synced to multiple destination devices.
787 */
788int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
789{
790 int err = 0;
791
792 if (to->addr_len != from->addr_len)
793 return -EINVAL;
794
795 netif_addr_lock_nested(to);
796 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
797 if (!err)
798 __dev_set_rx_mode(to);
799 netif_addr_unlock(to);
800 return err;
801}
802EXPORT_SYMBOL(dev_mc_sync_multiple);
803
804/**
805 * dev_mc_unsync - Remove synchronized addresses from the destination device
806 * @to: destination device
807 * @from: source device
808 *
809 * Remove all addresses that were added to the destination device by
810 * dev_mc_sync(). This function is intended to be called from the
811 * dev->stop function of layered software devices.
812 */
813void dev_mc_unsync(struct net_device *to, struct net_device *from)
814{
815 if (to->addr_len != from->addr_len)
816 return;
817
818 netif_addr_lock_bh(from);
819 netif_addr_lock_nested(to);
820 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
821 __dev_set_rx_mode(to);
822 netif_addr_unlock(to);
823 netif_addr_unlock_bh(from);
824}
825EXPORT_SYMBOL(dev_mc_unsync);
826
827/**
828 * dev_mc_flush - Flush multicast addresses
829 * @dev: device
830 *
831 * Flush multicast addresses.
832 */
833void dev_mc_flush(struct net_device *dev)
834{
835 netif_addr_lock_bh(dev);
836 __hw_addr_flush(&dev->mc);
837 netif_addr_unlock_bh(dev);
838}
839EXPORT_SYMBOL(dev_mc_flush);
840
841/**
842 * dev_mc_init - Init multicast address list
843 * @dev: device
844 *
845 * Init multicast address list.
846 */
847void dev_mc_init(struct net_device *dev)
848{
849 __hw_addr_init(&dev->mc);
850}
851EXPORT_SYMBOL(dev_mc_init);