Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * net/core/dev_addr_lists.c - Functions for handling net device lists
4 * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
5 *
6 * This file contains functions for working with unicast, multicast and device
7 * addresses lists.
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 * General list handling functions
17 */
18
19static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
20 const unsigned char *addr, int addr_len,
21 unsigned char addr_type, bool global,
22 bool sync)
23{
24 struct netdev_hw_addr *ha;
25 int alloc_size;
26
27 alloc_size = sizeof(*ha);
28 if (alloc_size < L1_CACHE_BYTES)
29 alloc_size = L1_CACHE_BYTES;
30 ha = kmalloc(alloc_size, GFP_ATOMIC);
31 if (!ha)
32 return -ENOMEM;
33 memcpy(ha->addr, addr, addr_len);
34 ha->type = addr_type;
35 ha->refcount = 1;
36 ha->global_use = global;
37 ha->synced = sync ? 1 : 0;
38 ha->sync_cnt = 0;
39 list_add_tail_rcu(&ha->list, &list->list);
40 list->count++;
41
42 return 0;
43}
44
45static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
46 const unsigned char *addr, int addr_len,
47 unsigned char addr_type, bool global, bool sync,
48 int sync_count)
49{
50 struct netdev_hw_addr *ha;
51
52 if (addr_len > MAX_ADDR_LEN)
53 return -EINVAL;
54
55 list_for_each_entry(ha, &list->list, list) {
56 if (ha->type == addr_type &&
57 !memcmp(ha->addr, addr, addr_len)) {
58 if (global) {
59 /* check if addr is already used as global */
60 if (ha->global_use)
61 return 0;
62 else
63 ha->global_use = true;
64 }
65 if (sync) {
66 if (ha->synced && sync_count)
67 return -EEXIST;
68 else
69 ha->synced++;
70 }
71 ha->refcount++;
72 return 0;
73 }
74 }
75
76 return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
77 sync);
78}
79
80static int __hw_addr_add(struct netdev_hw_addr_list *list,
81 const unsigned char *addr, int addr_len,
82 unsigned char addr_type)
83{
84 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
85 0);
86}
87
88static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
89 struct netdev_hw_addr *ha, bool global,
90 bool sync)
91{
92 if (global && !ha->global_use)
93 return -ENOENT;
94
95 if (sync && !ha->synced)
96 return -ENOENT;
97
98 if (global)
99 ha->global_use = false;
100
101 if (sync)
102 ha->synced--;
103
104 if (--ha->refcount)
105 return 0;
106 list_del_rcu(&ha->list);
107 kfree_rcu(ha, rcu_head);
108 list->count--;
109 return 0;
110}
111
112static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
113 const unsigned char *addr, int addr_len,
114 unsigned char addr_type, bool global, bool sync)
115{
116 struct netdev_hw_addr *ha;
117
118 list_for_each_entry(ha, &list->list, list) {
119 if (!memcmp(ha->addr, addr, addr_len) &&
120 (ha->type == addr_type || !addr_type))
121 return __hw_addr_del_entry(list, ha, global, sync);
122 }
123 return -ENOENT;
124}
125
126static int __hw_addr_del(struct netdev_hw_addr_list *list,
127 const unsigned char *addr, int addr_len,
128 unsigned char addr_type)
129{
130 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
131}
132
133static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
134 struct netdev_hw_addr *ha,
135 int addr_len)
136{
137 int err;
138
139 err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
140 false, true, ha->sync_cnt);
141 if (err && err != -EEXIST)
142 return err;
143
144 if (!err) {
145 ha->sync_cnt++;
146 ha->refcount++;
147 }
148
149 return 0;
150}
151
152static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
153 struct netdev_hw_addr_list *from_list,
154 struct netdev_hw_addr *ha,
155 int addr_len)
156{
157 int err;
158
159 err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
160 false, true);
161 if (err)
162 return;
163 ha->sync_cnt--;
164 /* address on from list is not marked synced */
165 __hw_addr_del_entry(from_list, ha, false, false);
166}
167
168static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
169 struct netdev_hw_addr_list *from_list,
170 int addr_len)
171{
172 int err = 0;
173 struct netdev_hw_addr *ha, *tmp;
174
175 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
176 if (ha->sync_cnt == ha->refcount) {
177 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
178 } else {
179 err = __hw_addr_sync_one(to_list, ha, addr_len);
180 if (err)
181 break;
182 }
183 }
184 return err;
185}
186
187/* This function only works where there is a strict 1-1 relationship
188 * between source and destionation of they synch. If you ever need to
189 * sync addresses to more then 1 destination, you need to use
190 * __hw_addr_sync_multiple().
191 */
192int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
193 struct netdev_hw_addr_list *from_list,
194 int addr_len)
195{
196 int err = 0;
197 struct netdev_hw_addr *ha, *tmp;
198
199 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
200 if (!ha->sync_cnt) {
201 err = __hw_addr_sync_one(to_list, ha, addr_len);
202 if (err)
203 break;
204 } else if (ha->refcount == 1)
205 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
206 }
207 return err;
208}
209EXPORT_SYMBOL(__hw_addr_sync);
210
211void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
212 struct netdev_hw_addr_list *from_list,
213 int addr_len)
214{
215 struct netdev_hw_addr *ha, *tmp;
216
217 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
218 if (ha->sync_cnt)
219 __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
220 }
221}
222EXPORT_SYMBOL(__hw_addr_unsync);
223
224/**
225 * __hw_addr_sync_dev - Synchonize device's multicast list
226 * @list: address list to syncronize
227 * @dev: device to sync
228 * @sync: function to call if address should be added
229 * @unsync: function to call if address should be removed
230 *
231 * This function is intended to be called from the ndo_set_rx_mode
232 * function of devices that require explicit address add/remove
233 * notifications. The unsync function may be NULL in which case
234 * the addresses requiring removal will simply be removed without
235 * any notification to the device.
236 **/
237int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
238 struct net_device *dev,
239 int (*sync)(struct net_device *, const unsigned char *),
240 int (*unsync)(struct net_device *,
241 const unsigned char *))
242{
243 struct netdev_hw_addr *ha, *tmp;
244 int err;
245
246 /* first go through and flush out any stale entries */
247 list_for_each_entry_safe(ha, tmp, &list->list, list) {
248 if (!ha->sync_cnt || ha->refcount != 1)
249 continue;
250
251 /* if unsync is defined and fails defer unsyncing address */
252 if (unsync && unsync(dev, ha->addr))
253 continue;
254
255 ha->sync_cnt--;
256 __hw_addr_del_entry(list, ha, false, false);
257 }
258
259 /* go through and sync new entries to the list */
260 list_for_each_entry_safe(ha, tmp, &list->list, list) {
261 if (ha->sync_cnt)
262 continue;
263
264 err = sync(dev, ha->addr);
265 if (err)
266 return err;
267
268 ha->sync_cnt++;
269 ha->refcount++;
270 }
271
272 return 0;
273}
274EXPORT_SYMBOL(__hw_addr_sync_dev);
275
276/**
277 * __hw_addr_ref_sync_dev - Synchronize device's multicast address list taking
278 * into account references
279 * @list: address list to synchronize
280 * @dev: device to sync
281 * @sync: function to call if address or reference on it should be added
282 * @unsync: function to call if address or some reference on it should removed
283 *
284 * This function is intended to be called from the ndo_set_rx_mode
285 * function of devices that require explicit address or references on it
286 * add/remove notifications. The unsync function may be NULL in which case
287 * the addresses or references on it requiring removal will simply be
288 * removed without any notification to the device. That is responsibility of
289 * the driver to identify and distribute address or references on it between
290 * internal address tables.
291 **/
292int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
293 struct net_device *dev,
294 int (*sync)(struct net_device *,
295 const unsigned char *, int),
296 int (*unsync)(struct net_device *,
297 const unsigned char *, int))
298{
299 struct netdev_hw_addr *ha, *tmp;
300 int err, ref_cnt;
301
302 /* first go through and flush out any unsynced/stale entries */
303 list_for_each_entry_safe(ha, tmp, &list->list, list) {
304 /* sync if address is not used */
305 if ((ha->sync_cnt << 1) <= ha->refcount)
306 continue;
307
308 /* if fails defer unsyncing address */
309 ref_cnt = ha->refcount - ha->sync_cnt;
310 if (unsync && unsync(dev, ha->addr, ref_cnt))
311 continue;
312
313 ha->refcount = (ref_cnt << 1) + 1;
314 ha->sync_cnt = ref_cnt;
315 __hw_addr_del_entry(list, ha, false, false);
316 }
317
318 /* go through and sync updated/new entries to the list */
319 list_for_each_entry_safe(ha, tmp, &list->list, list) {
320 /* sync if address added or reused */
321 if ((ha->sync_cnt << 1) >= ha->refcount)
322 continue;
323
324 ref_cnt = ha->refcount - ha->sync_cnt;
325 err = sync(dev, ha->addr, ref_cnt);
326 if (err)
327 return err;
328
329 ha->refcount = ref_cnt << 1;
330 ha->sync_cnt = ref_cnt;
331 }
332
333 return 0;
334}
335EXPORT_SYMBOL(__hw_addr_ref_sync_dev);
336
337/**
338 * __hw_addr_ref_unsync_dev - Remove synchronized addresses and references on
339 * it from device
340 * @list: address list to remove synchronized addresses (references on it) from
341 * @dev: device to sync
342 * @unsync: function to call if address and references on it should be removed
343 *
344 * Remove all addresses that were added to the device by
345 * __hw_addr_ref_sync_dev(). This function is intended to be called from the
346 * ndo_stop or ndo_open functions on devices that require explicit address (or
347 * references on it) add/remove notifications. If the unsync function pointer
348 * is NULL then this function can be used to just reset the sync_cnt for the
349 * addresses in the list.
350 **/
351void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
352 struct net_device *dev,
353 int (*unsync)(struct net_device *,
354 const unsigned char *, int))
355{
356 struct netdev_hw_addr *ha, *tmp;
357
358 list_for_each_entry_safe(ha, tmp, &list->list, list) {
359 if (!ha->sync_cnt)
360 continue;
361
362 /* if fails defer unsyncing address */
363 if (unsync && unsync(dev, ha->addr, ha->sync_cnt))
364 continue;
365
366 ha->refcount -= ha->sync_cnt - 1;
367 ha->sync_cnt = 0;
368 __hw_addr_del_entry(list, ha, false, false);
369 }
370}
371EXPORT_SYMBOL(__hw_addr_ref_unsync_dev);
372
373/**
374 * __hw_addr_unsync_dev - Remove synchronized addresses from device
375 * @list: address list to remove synchronized addresses from
376 * @dev: device to sync
377 * @unsync: function to call if address should be removed
378 *
379 * Remove all addresses that were added to the device by __hw_addr_sync_dev().
380 * This function is intended to be called from the ndo_stop or ndo_open
381 * functions on devices that require explicit address add/remove
382 * notifications. If the unsync function pointer is NULL then this function
383 * can be used to just reset the sync_cnt for the addresses in the list.
384 **/
385void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
386 struct net_device *dev,
387 int (*unsync)(struct net_device *,
388 const unsigned char *))
389{
390 struct netdev_hw_addr *ha, *tmp;
391
392 list_for_each_entry_safe(ha, tmp, &list->list, list) {
393 if (!ha->sync_cnt)
394 continue;
395
396 /* if unsync is defined and fails defer unsyncing address */
397 if (unsync && unsync(dev, ha->addr))
398 continue;
399
400 ha->sync_cnt--;
401 __hw_addr_del_entry(list, ha, false, false);
402 }
403}
404EXPORT_SYMBOL(__hw_addr_unsync_dev);
405
406static void __hw_addr_flush(struct netdev_hw_addr_list *list)
407{
408 struct netdev_hw_addr *ha, *tmp;
409
410 list_for_each_entry_safe(ha, tmp, &list->list, list) {
411 list_del_rcu(&ha->list);
412 kfree_rcu(ha, rcu_head);
413 }
414 list->count = 0;
415}
416
417void __hw_addr_init(struct netdev_hw_addr_list *list)
418{
419 INIT_LIST_HEAD(&list->list);
420 list->count = 0;
421}
422EXPORT_SYMBOL(__hw_addr_init);
423
424/*
425 * Device addresses handling functions
426 */
427
428/**
429 * dev_addr_flush - Flush device address list
430 * @dev: device
431 *
432 * Flush device address list and reset ->dev_addr.
433 *
434 * The caller must hold the rtnl_mutex.
435 */
436void dev_addr_flush(struct net_device *dev)
437{
438 /* rtnl_mutex must be held here */
439
440 __hw_addr_flush(&dev->dev_addrs);
441 dev->dev_addr = NULL;
442}
443EXPORT_SYMBOL(dev_addr_flush);
444
445/**
446 * dev_addr_init - Init device address list
447 * @dev: device
448 *
449 * Init device address list and create the first element,
450 * used by ->dev_addr.
451 *
452 * The caller must hold the rtnl_mutex.
453 */
454int dev_addr_init(struct net_device *dev)
455{
456 unsigned char addr[MAX_ADDR_LEN];
457 struct netdev_hw_addr *ha;
458 int err;
459
460 /* rtnl_mutex must be held here */
461
462 __hw_addr_init(&dev->dev_addrs);
463 memset(addr, 0, sizeof(addr));
464 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
465 NETDEV_HW_ADDR_T_LAN);
466 if (!err) {
467 /*
468 * Get the first (previously created) address from the list
469 * and set dev_addr pointer to this location.
470 */
471 ha = list_first_entry(&dev->dev_addrs.list,
472 struct netdev_hw_addr, list);
473 dev->dev_addr = ha->addr;
474 }
475 return err;
476}
477EXPORT_SYMBOL(dev_addr_init);
478
479/**
480 * dev_addr_add - Add a device address
481 * @dev: device
482 * @addr: address to add
483 * @addr_type: address type
484 *
485 * Add a device address to the device or increase the reference count if
486 * it already exists.
487 *
488 * The caller must hold the rtnl_mutex.
489 */
490int dev_addr_add(struct net_device *dev, const unsigned char *addr,
491 unsigned char addr_type)
492{
493 int err;
494
495 ASSERT_RTNL();
496
497 err = dev_pre_changeaddr_notify(dev, addr, NULL);
498 if (err)
499 return err;
500 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
501 if (!err)
502 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
503 return err;
504}
505EXPORT_SYMBOL(dev_addr_add);
506
507/**
508 * dev_addr_del - Release a device address.
509 * @dev: device
510 * @addr: address to delete
511 * @addr_type: address type
512 *
513 * Release reference to a device address and remove it from the device
514 * if the reference count drops to zero.
515 *
516 * The caller must hold the rtnl_mutex.
517 */
518int dev_addr_del(struct net_device *dev, const unsigned char *addr,
519 unsigned char addr_type)
520{
521 int err;
522 struct netdev_hw_addr *ha;
523
524 ASSERT_RTNL();
525
526 /*
527 * We can not remove the first address from the list because
528 * dev->dev_addr points to that.
529 */
530 ha = list_first_entry(&dev->dev_addrs.list,
531 struct netdev_hw_addr, list);
532 if (!memcmp(ha->addr, addr, dev->addr_len) &&
533 ha->type == addr_type && ha->refcount == 1)
534 return -ENOENT;
535
536 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
537 addr_type);
538 if (!err)
539 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
540 return err;
541}
542EXPORT_SYMBOL(dev_addr_del);
543
544/*
545 * Unicast list handling functions
546 */
547
548/**
549 * dev_uc_add_excl - Add a global secondary unicast address
550 * @dev: device
551 * @addr: address to add
552 */
553int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
554{
555 struct netdev_hw_addr *ha;
556 int err;
557
558 netif_addr_lock_bh(dev);
559 list_for_each_entry(ha, &dev->uc.list, list) {
560 if (!memcmp(ha->addr, addr, dev->addr_len) &&
561 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
562 err = -EEXIST;
563 goto out;
564 }
565 }
566 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
567 NETDEV_HW_ADDR_T_UNICAST, true, false);
568 if (!err)
569 __dev_set_rx_mode(dev);
570out:
571 netif_addr_unlock_bh(dev);
572 return err;
573}
574EXPORT_SYMBOL(dev_uc_add_excl);
575
576/**
577 * dev_uc_add - Add a secondary unicast address
578 * @dev: device
579 * @addr: address to add
580 *
581 * Add a secondary unicast address to the device or increase
582 * the reference count if it already exists.
583 */
584int dev_uc_add(struct net_device *dev, const unsigned char *addr)
585{
586 int err;
587
588 netif_addr_lock_bh(dev);
589 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
590 NETDEV_HW_ADDR_T_UNICAST);
591 if (!err)
592 __dev_set_rx_mode(dev);
593 netif_addr_unlock_bh(dev);
594 return err;
595}
596EXPORT_SYMBOL(dev_uc_add);
597
598/**
599 * dev_uc_del - Release secondary unicast address.
600 * @dev: device
601 * @addr: address to delete
602 *
603 * Release reference to a secondary unicast address and remove it
604 * from the device if the reference count drops to zero.
605 */
606int dev_uc_del(struct net_device *dev, const unsigned char *addr)
607{
608 int err;
609
610 netif_addr_lock_bh(dev);
611 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
612 NETDEV_HW_ADDR_T_UNICAST);
613 if (!err)
614 __dev_set_rx_mode(dev);
615 netif_addr_unlock_bh(dev);
616 return err;
617}
618EXPORT_SYMBOL(dev_uc_del);
619
620/**
621 * dev_uc_sync - Synchronize device's unicast list to another device
622 * @to: destination device
623 * @from: source device
624 *
625 * Add newly added addresses to the destination device and release
626 * addresses that have no users left. The source device must be
627 * locked by netif_addr_lock_bh.
628 *
629 * This function is intended to be called from the dev->set_rx_mode
630 * function of layered software devices. This function assumes that
631 * addresses will only ever be synced to the @to devices and no other.
632 */
633int dev_uc_sync(struct net_device *to, struct net_device *from)
634{
635 int err = 0;
636
637 if (to->addr_len != from->addr_len)
638 return -EINVAL;
639
640 netif_addr_lock(to);
641 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
642 if (!err)
643 __dev_set_rx_mode(to);
644 netif_addr_unlock(to);
645 return err;
646}
647EXPORT_SYMBOL(dev_uc_sync);
648
649/**
650 * dev_uc_sync_multiple - Synchronize device's unicast list to another
651 * device, but allow for multiple calls to sync to multiple devices.
652 * @to: destination device
653 * @from: source device
654 *
655 * Add newly added addresses to the destination device and release
656 * addresses that have been deleted from the source. The source device
657 * must be locked by netif_addr_lock_bh.
658 *
659 * This function is intended to be called from the dev->set_rx_mode
660 * function of layered software devices. It allows for a single source
661 * device to be synced to multiple destination devices.
662 */
663int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
664{
665 int err = 0;
666
667 if (to->addr_len != from->addr_len)
668 return -EINVAL;
669
670 netif_addr_lock(to);
671 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
672 if (!err)
673 __dev_set_rx_mode(to);
674 netif_addr_unlock(to);
675 return err;
676}
677EXPORT_SYMBOL(dev_uc_sync_multiple);
678
679/**
680 * dev_uc_unsync - Remove synchronized addresses from the destination device
681 * @to: destination device
682 * @from: source device
683 *
684 * Remove all addresses that were added to the destination device by
685 * dev_uc_sync(). This function is intended to be called from the
686 * dev->stop function of layered software devices.
687 */
688void dev_uc_unsync(struct net_device *to, struct net_device *from)
689{
690 if (to->addr_len != from->addr_len)
691 return;
692
693 /* netif_addr_lock_bh() uses lockdep subclass 0, this is okay for two
694 * reasons:
695 * 1) This is always called without any addr_list_lock, so as the
696 * outermost one here, it must be 0.
697 * 2) This is called by some callers after unlinking the upper device,
698 * so the dev->lower_level becomes 1 again.
699 * Therefore, the subclass for 'from' is 0, for 'to' is either 1 or
700 * larger.
701 */
702 netif_addr_lock_bh(from);
703 netif_addr_lock(to);
704 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
705 __dev_set_rx_mode(to);
706 netif_addr_unlock(to);
707 netif_addr_unlock_bh(from);
708}
709EXPORT_SYMBOL(dev_uc_unsync);
710
711/**
712 * dev_uc_flush - Flush unicast addresses
713 * @dev: device
714 *
715 * Flush unicast addresses.
716 */
717void dev_uc_flush(struct net_device *dev)
718{
719 netif_addr_lock_bh(dev);
720 __hw_addr_flush(&dev->uc);
721 netif_addr_unlock_bh(dev);
722}
723EXPORT_SYMBOL(dev_uc_flush);
724
725/**
726 * dev_uc_init - Init unicast address list
727 * @dev: device
728 *
729 * Init unicast address list.
730 */
731void dev_uc_init(struct net_device *dev)
732{
733 __hw_addr_init(&dev->uc);
734}
735EXPORT_SYMBOL(dev_uc_init);
736
737/*
738 * Multicast list handling functions
739 */
740
741/**
742 * dev_mc_add_excl - Add a global secondary multicast address
743 * @dev: device
744 * @addr: address to add
745 */
746int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
747{
748 struct netdev_hw_addr *ha;
749 int err;
750
751 netif_addr_lock_bh(dev);
752 list_for_each_entry(ha, &dev->mc.list, list) {
753 if (!memcmp(ha->addr, addr, dev->addr_len) &&
754 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
755 err = -EEXIST;
756 goto out;
757 }
758 }
759 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
760 NETDEV_HW_ADDR_T_MULTICAST, true, false);
761 if (!err)
762 __dev_set_rx_mode(dev);
763out:
764 netif_addr_unlock_bh(dev);
765 return err;
766}
767EXPORT_SYMBOL(dev_mc_add_excl);
768
769static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
770 bool global)
771{
772 int err;
773
774 netif_addr_lock_bh(dev);
775 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
776 NETDEV_HW_ADDR_T_MULTICAST, global, false, 0);
777 if (!err)
778 __dev_set_rx_mode(dev);
779 netif_addr_unlock_bh(dev);
780 return err;
781}
782/**
783 * dev_mc_add - Add a multicast address
784 * @dev: device
785 * @addr: address to add
786 *
787 * Add a multicast address to the device or increase
788 * the reference count if it already exists.
789 */
790int dev_mc_add(struct net_device *dev, const unsigned char *addr)
791{
792 return __dev_mc_add(dev, addr, false);
793}
794EXPORT_SYMBOL(dev_mc_add);
795
796/**
797 * dev_mc_add_global - Add a global multicast address
798 * @dev: device
799 * @addr: address to add
800 *
801 * Add a global multicast address to the device.
802 */
803int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
804{
805 return __dev_mc_add(dev, addr, true);
806}
807EXPORT_SYMBOL(dev_mc_add_global);
808
809static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
810 bool global)
811{
812 int err;
813
814 netif_addr_lock_bh(dev);
815 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
816 NETDEV_HW_ADDR_T_MULTICAST, global, false);
817 if (!err)
818 __dev_set_rx_mode(dev);
819 netif_addr_unlock_bh(dev);
820 return err;
821}
822
823/**
824 * dev_mc_del - Delete a multicast address.
825 * @dev: device
826 * @addr: address to delete
827 *
828 * Release reference to a multicast address and remove it
829 * from the device if the reference count drops to zero.
830 */
831int dev_mc_del(struct net_device *dev, const unsigned char *addr)
832{
833 return __dev_mc_del(dev, addr, false);
834}
835EXPORT_SYMBOL(dev_mc_del);
836
837/**
838 * dev_mc_del_global - Delete a global multicast address.
839 * @dev: device
840 * @addr: address to delete
841 *
842 * Release reference to a multicast address and remove it
843 * from the device if the reference count drops to zero.
844 */
845int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
846{
847 return __dev_mc_del(dev, addr, true);
848}
849EXPORT_SYMBOL(dev_mc_del_global);
850
851/**
852 * dev_mc_sync - Synchronize device's multicast list to another device
853 * @to: destination device
854 * @from: source device
855 *
856 * Add newly added addresses to the destination device and release
857 * addresses that have no users left. The source device must be
858 * locked by netif_addr_lock_bh.
859 *
860 * This function is intended to be called from the ndo_set_rx_mode
861 * function of layered software devices.
862 */
863int dev_mc_sync(struct net_device *to, struct net_device *from)
864{
865 int err = 0;
866
867 if (to->addr_len != from->addr_len)
868 return -EINVAL;
869
870 netif_addr_lock(to);
871 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
872 if (!err)
873 __dev_set_rx_mode(to);
874 netif_addr_unlock(to);
875 return err;
876}
877EXPORT_SYMBOL(dev_mc_sync);
878
879/**
880 * dev_mc_sync_multiple - Synchronize device's multicast list to another
881 * device, but allow for multiple calls to sync to multiple devices.
882 * @to: destination device
883 * @from: source device
884 *
885 * Add newly added addresses to the destination device and release
886 * addresses that have no users left. The source device must be
887 * locked by netif_addr_lock_bh.
888 *
889 * This function is intended to be called from the ndo_set_rx_mode
890 * function of layered software devices. It allows for a single
891 * source device to be synced to multiple destination devices.
892 */
893int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
894{
895 int err = 0;
896
897 if (to->addr_len != from->addr_len)
898 return -EINVAL;
899
900 netif_addr_lock(to);
901 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
902 if (!err)
903 __dev_set_rx_mode(to);
904 netif_addr_unlock(to);
905 return err;
906}
907EXPORT_SYMBOL(dev_mc_sync_multiple);
908
909/**
910 * dev_mc_unsync - Remove synchronized addresses from the destination device
911 * @to: destination device
912 * @from: source device
913 *
914 * Remove all addresses that were added to the destination device by
915 * dev_mc_sync(). This function is intended to be called from the
916 * dev->stop function of layered software devices.
917 */
918void dev_mc_unsync(struct net_device *to, struct net_device *from)
919{
920 if (to->addr_len != from->addr_len)
921 return;
922
923 /* See the above comments inside dev_uc_unsync(). */
924 netif_addr_lock_bh(from);
925 netif_addr_lock(to);
926 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
927 __dev_set_rx_mode(to);
928 netif_addr_unlock(to);
929 netif_addr_unlock_bh(from);
930}
931EXPORT_SYMBOL(dev_mc_unsync);
932
933/**
934 * dev_mc_flush - Flush multicast addresses
935 * @dev: device
936 *
937 * Flush multicast addresses.
938 */
939void dev_mc_flush(struct net_device *dev)
940{
941 netif_addr_lock_bh(dev);
942 __hw_addr_flush(&dev->mc);
943 netif_addr_unlock_bh(dev);
944}
945EXPORT_SYMBOL(dev_mc_flush);
946
947/**
948 * dev_mc_init - Init multicast address list
949 * @dev: device
950 *
951 * Init multicast address list.
952 */
953void dev_mc_init(struct net_device *dev)
954{
955 __hw_addr_init(&dev->mc);
956}
957EXPORT_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#include <linux/proc_fs.h>
19
20/*
21 * General list handling functions
22 */
23
24static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
25 unsigned char *addr, int addr_len,
26 unsigned char addr_type, bool global)
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
48static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
49 unsigned char *addr, int addr_len,
50 unsigned char addr_type, bool global)
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
75static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
76 int addr_len, unsigned char addr_type)
77{
78 return __hw_addr_add_ex(list, addr, addr_len, addr_type, false);
79}
80
81static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
82 unsigned char *addr, int addr_len,
83 unsigned char addr_type, bool global)
84{
85 struct netdev_hw_addr *ha;
86
87 list_for_each_entry(ha, &list->list, list) {
88 if (!memcmp(ha->addr, addr, addr_len) &&
89 (ha->type == addr_type || !addr_type)) {
90 if (global) {
91 if (!ha->global_use)
92 break;
93 else
94 ha->global_use = false;
95 }
96 if (--ha->refcount)
97 return 0;
98 list_del_rcu(&ha->list);
99 kfree_rcu(ha, rcu_head);
100 list->count--;
101 return 0;
102 }
103 }
104 return -ENOENT;
105}
106
107static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
108 int addr_len, unsigned char addr_type)
109{
110 return __hw_addr_del_ex(list, addr, addr_len, addr_type, false);
111}
112
113int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
114 struct netdev_hw_addr_list *from_list,
115 int addr_len, unsigned char addr_type)
116{
117 int err;
118 struct netdev_hw_addr *ha, *ha2;
119 unsigned char type;
120
121 list_for_each_entry(ha, &from_list->list, list) {
122 type = addr_type ? addr_type : ha->type;
123 err = __hw_addr_add(to_list, ha->addr, addr_len, type);
124 if (err)
125 goto unroll;
126 }
127 return 0;
128
129unroll:
130 list_for_each_entry(ha2, &from_list->list, list) {
131 if (ha2 == ha)
132 break;
133 type = addr_type ? addr_type : ha2->type;
134 __hw_addr_del(to_list, ha2->addr, addr_len, type);
135 }
136 return err;
137}
138EXPORT_SYMBOL(__hw_addr_add_multiple);
139
140void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
141 struct netdev_hw_addr_list *from_list,
142 int addr_len, unsigned char addr_type)
143{
144 struct netdev_hw_addr *ha;
145 unsigned char type;
146
147 list_for_each_entry(ha, &from_list->list, list) {
148 type = addr_type ? addr_type : ha->type;
149 __hw_addr_del(to_list, ha->addr, addr_len, type);
150 }
151}
152EXPORT_SYMBOL(__hw_addr_del_multiple);
153
154int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
155 struct netdev_hw_addr_list *from_list,
156 int addr_len)
157{
158 int err = 0;
159 struct netdev_hw_addr *ha, *tmp;
160
161 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
162 if (!ha->synced) {
163 err = __hw_addr_add(to_list, ha->addr,
164 addr_len, ha->type);
165 if (err)
166 break;
167 ha->synced = true;
168 ha->refcount++;
169 } else if (ha->refcount == 1) {
170 __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
171 __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
172 }
173 }
174 return err;
175}
176EXPORT_SYMBOL(__hw_addr_sync);
177
178void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
179 struct netdev_hw_addr_list *from_list,
180 int addr_len)
181{
182 struct netdev_hw_addr *ha, *tmp;
183
184 list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
185 if (ha->synced) {
186 __hw_addr_del(to_list, ha->addr,
187 addr_len, ha->type);
188 ha->synced = false;
189 __hw_addr_del(from_list, ha->addr,
190 addr_len, ha->type);
191 }
192 }
193}
194EXPORT_SYMBOL(__hw_addr_unsync);
195
196void __hw_addr_flush(struct netdev_hw_addr_list *list)
197{
198 struct netdev_hw_addr *ha, *tmp;
199
200 list_for_each_entry_safe(ha, tmp, &list->list, list) {
201 list_del_rcu(&ha->list);
202 kfree_rcu(ha, rcu_head);
203 }
204 list->count = 0;
205}
206EXPORT_SYMBOL(__hw_addr_flush);
207
208void __hw_addr_init(struct netdev_hw_addr_list *list)
209{
210 INIT_LIST_HEAD(&list->list);
211 list->count = 0;
212}
213EXPORT_SYMBOL(__hw_addr_init);
214
215/*
216 * Device addresses handling functions
217 */
218
219/**
220 * dev_addr_flush - Flush device address list
221 * @dev: device
222 *
223 * Flush device address list and reset ->dev_addr.
224 *
225 * The caller must hold the rtnl_mutex.
226 */
227void dev_addr_flush(struct net_device *dev)
228{
229 /* rtnl_mutex must be held here */
230
231 __hw_addr_flush(&dev->dev_addrs);
232 dev->dev_addr = NULL;
233}
234EXPORT_SYMBOL(dev_addr_flush);
235
236/**
237 * dev_addr_init - Init device address list
238 * @dev: device
239 *
240 * Init device address list and create the first element,
241 * used by ->dev_addr.
242 *
243 * The caller must hold the rtnl_mutex.
244 */
245int dev_addr_init(struct net_device *dev)
246{
247 unsigned char addr[MAX_ADDR_LEN];
248 struct netdev_hw_addr *ha;
249 int err;
250
251 /* rtnl_mutex must be held here */
252
253 __hw_addr_init(&dev->dev_addrs);
254 memset(addr, 0, sizeof(addr));
255 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
256 NETDEV_HW_ADDR_T_LAN);
257 if (!err) {
258 /*
259 * Get the first (previously created) address from the list
260 * and set dev_addr pointer to this location.
261 */
262 ha = list_first_entry(&dev->dev_addrs.list,
263 struct netdev_hw_addr, list);
264 dev->dev_addr = ha->addr;
265 }
266 return err;
267}
268EXPORT_SYMBOL(dev_addr_init);
269
270/**
271 * dev_addr_add - Add a device address
272 * @dev: device
273 * @addr: address to add
274 * @addr_type: address type
275 *
276 * Add a device address to the device or increase the reference count if
277 * it already exists.
278 *
279 * The caller must hold the rtnl_mutex.
280 */
281int dev_addr_add(struct net_device *dev, unsigned char *addr,
282 unsigned char addr_type)
283{
284 int err;
285
286 ASSERT_RTNL();
287
288 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
289 if (!err)
290 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
291 return err;
292}
293EXPORT_SYMBOL(dev_addr_add);
294
295/**
296 * dev_addr_del - Release a device address.
297 * @dev: device
298 * @addr: address to delete
299 * @addr_type: address type
300 *
301 * Release reference to a device address and remove it from the device
302 * if the reference count drops to zero.
303 *
304 * The caller must hold the rtnl_mutex.
305 */
306int dev_addr_del(struct net_device *dev, unsigned char *addr,
307 unsigned char addr_type)
308{
309 int err;
310 struct netdev_hw_addr *ha;
311
312 ASSERT_RTNL();
313
314 /*
315 * We can not remove the first address from the list because
316 * dev->dev_addr points to that.
317 */
318 ha = list_first_entry(&dev->dev_addrs.list,
319 struct netdev_hw_addr, list);
320 if (ha->addr == dev->dev_addr && ha->refcount == 1)
321 return -ENOENT;
322
323 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
324 addr_type);
325 if (!err)
326 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
327 return err;
328}
329EXPORT_SYMBOL(dev_addr_del);
330
331/**
332 * dev_addr_add_multiple - Add device addresses from another device
333 * @to_dev: device to which addresses will be added
334 * @from_dev: device from which addresses will be added
335 * @addr_type: address type - 0 means type will be used from from_dev
336 *
337 * Add device addresses of the one device to another.
338 **
339 * The caller must hold the rtnl_mutex.
340 */
341int dev_addr_add_multiple(struct net_device *to_dev,
342 struct net_device *from_dev,
343 unsigned char addr_type)
344{
345 int err;
346
347 ASSERT_RTNL();
348
349 if (from_dev->addr_len != to_dev->addr_len)
350 return -EINVAL;
351 err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
352 to_dev->addr_len, addr_type);
353 if (!err)
354 call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
355 return err;
356}
357EXPORT_SYMBOL(dev_addr_add_multiple);
358
359/**
360 * dev_addr_del_multiple - Delete device addresses by another device
361 * @to_dev: device where the addresses will be deleted
362 * @from_dev: device supplying the addresses to be deleted
363 * @addr_type: address type - 0 means type will be used from from_dev
364 *
365 * Deletes addresses in to device by the list of addresses in from device.
366 *
367 * The caller must hold the rtnl_mutex.
368 */
369int dev_addr_del_multiple(struct net_device *to_dev,
370 struct net_device *from_dev,
371 unsigned char addr_type)
372{
373 ASSERT_RTNL();
374
375 if (from_dev->addr_len != to_dev->addr_len)
376 return -EINVAL;
377 __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
378 to_dev->addr_len, addr_type);
379 call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
380 return 0;
381}
382EXPORT_SYMBOL(dev_addr_del_multiple);
383
384/*
385 * Unicast list handling functions
386 */
387
388/**
389 * dev_uc_add_excl - Add a global secondary unicast address
390 * @dev: device
391 * @addr: address to add
392 */
393int dev_uc_add_excl(struct net_device *dev, unsigned char *addr)
394{
395 struct netdev_hw_addr *ha;
396 int err;
397
398 netif_addr_lock_bh(dev);
399 list_for_each_entry(ha, &dev->uc.list, list) {
400 if (!memcmp(ha->addr, addr, dev->addr_len) &&
401 ha->type == NETDEV_HW_ADDR_T_UNICAST) {
402 err = -EEXIST;
403 goto out;
404 }
405 }
406 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
407 NETDEV_HW_ADDR_T_UNICAST, true);
408 if (!err)
409 __dev_set_rx_mode(dev);
410out:
411 netif_addr_unlock_bh(dev);
412 return err;
413}
414EXPORT_SYMBOL(dev_uc_add_excl);
415
416/**
417 * dev_uc_add - Add a secondary unicast address
418 * @dev: device
419 * @addr: address to add
420 *
421 * Add a secondary unicast address to the device or increase
422 * the reference count if it already exists.
423 */
424int dev_uc_add(struct net_device *dev, unsigned char *addr)
425{
426 int err;
427
428 netif_addr_lock_bh(dev);
429 err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
430 NETDEV_HW_ADDR_T_UNICAST);
431 if (!err)
432 __dev_set_rx_mode(dev);
433 netif_addr_unlock_bh(dev);
434 return err;
435}
436EXPORT_SYMBOL(dev_uc_add);
437
438/**
439 * dev_uc_del - Release secondary unicast address.
440 * @dev: device
441 * @addr: address to delete
442 *
443 * Release reference to a secondary unicast address and remove it
444 * from the device if the reference count drops to zero.
445 */
446int dev_uc_del(struct net_device *dev, unsigned char *addr)
447{
448 int err;
449
450 netif_addr_lock_bh(dev);
451 err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
452 NETDEV_HW_ADDR_T_UNICAST);
453 if (!err)
454 __dev_set_rx_mode(dev);
455 netif_addr_unlock_bh(dev);
456 return err;
457}
458EXPORT_SYMBOL(dev_uc_del);
459
460/**
461 * dev_uc_sync - Synchronize device's unicast list to another device
462 * @to: destination device
463 * @from: source device
464 *
465 * Add newly added addresses to the destination device and release
466 * addresses that have no users left. The source device must be
467 * locked by netif_addr_lock_bh.
468 *
469 * This function is intended to be called from the dev->set_rx_mode
470 * function of layered software devices.
471 */
472int dev_uc_sync(struct net_device *to, struct net_device *from)
473{
474 int err = 0;
475
476 if (to->addr_len != from->addr_len)
477 return -EINVAL;
478
479 netif_addr_lock_nested(to);
480 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
481 if (!err)
482 __dev_set_rx_mode(to);
483 netif_addr_unlock(to);
484 return err;
485}
486EXPORT_SYMBOL(dev_uc_sync);
487
488/**
489 * dev_uc_unsync - Remove synchronized addresses from the destination device
490 * @to: destination device
491 * @from: source device
492 *
493 * Remove all addresses that were added to the destination device by
494 * dev_uc_sync(). This function is intended to be called from the
495 * dev->stop function of layered software devices.
496 */
497void dev_uc_unsync(struct net_device *to, struct net_device *from)
498{
499 if (to->addr_len != from->addr_len)
500 return;
501
502 netif_addr_lock_bh(from);
503 netif_addr_lock_nested(to);
504 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
505 __dev_set_rx_mode(to);
506 netif_addr_unlock(to);
507 netif_addr_unlock_bh(from);
508}
509EXPORT_SYMBOL(dev_uc_unsync);
510
511/**
512 * dev_uc_flush - Flush unicast addresses
513 * @dev: device
514 *
515 * Flush unicast addresses.
516 */
517void dev_uc_flush(struct net_device *dev)
518{
519 netif_addr_lock_bh(dev);
520 __hw_addr_flush(&dev->uc);
521 netif_addr_unlock_bh(dev);
522}
523EXPORT_SYMBOL(dev_uc_flush);
524
525/**
526 * dev_uc_flush - Init unicast address list
527 * @dev: device
528 *
529 * Init unicast address list.
530 */
531void dev_uc_init(struct net_device *dev)
532{
533 __hw_addr_init(&dev->uc);
534}
535EXPORT_SYMBOL(dev_uc_init);
536
537/*
538 * Multicast list handling functions
539 */
540
541/**
542 * dev_mc_add_excl - Add a global secondary multicast address
543 * @dev: device
544 * @addr: address to add
545 */
546int dev_mc_add_excl(struct net_device *dev, unsigned char *addr)
547{
548 struct netdev_hw_addr *ha;
549 int err;
550
551 netif_addr_lock_bh(dev);
552 list_for_each_entry(ha, &dev->mc.list, list) {
553 if (!memcmp(ha->addr, addr, dev->addr_len) &&
554 ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
555 err = -EEXIST;
556 goto out;
557 }
558 }
559 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
560 NETDEV_HW_ADDR_T_MULTICAST, true);
561 if (!err)
562 __dev_set_rx_mode(dev);
563out:
564 netif_addr_unlock_bh(dev);
565 return err;
566}
567EXPORT_SYMBOL(dev_mc_add_excl);
568
569static int __dev_mc_add(struct net_device *dev, unsigned char *addr,
570 bool global)
571{
572 int err;
573
574 netif_addr_lock_bh(dev);
575 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
576 NETDEV_HW_ADDR_T_MULTICAST, global);
577 if (!err)
578 __dev_set_rx_mode(dev);
579 netif_addr_unlock_bh(dev);
580 return err;
581}
582/**
583 * dev_mc_add - Add a multicast address
584 * @dev: device
585 * @addr: address to add
586 *
587 * Add a multicast address to the device or increase
588 * the reference count if it already exists.
589 */
590int dev_mc_add(struct net_device *dev, unsigned char *addr)
591{
592 return __dev_mc_add(dev, addr, false);
593}
594EXPORT_SYMBOL(dev_mc_add);
595
596/**
597 * dev_mc_add_global - Add a global multicast address
598 * @dev: device
599 * @addr: address to add
600 *
601 * Add a global multicast address to the device.
602 */
603int dev_mc_add_global(struct net_device *dev, unsigned char *addr)
604{
605 return __dev_mc_add(dev, addr, true);
606}
607EXPORT_SYMBOL(dev_mc_add_global);
608
609static int __dev_mc_del(struct net_device *dev, unsigned char *addr,
610 bool global)
611{
612 int err;
613
614 netif_addr_lock_bh(dev);
615 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
616 NETDEV_HW_ADDR_T_MULTICAST, global);
617 if (!err)
618 __dev_set_rx_mode(dev);
619 netif_addr_unlock_bh(dev);
620 return err;
621}
622
623/**
624 * dev_mc_del - Delete a multicast address.
625 * @dev: device
626 * @addr: address to delete
627 *
628 * Release reference to a multicast address and remove it
629 * from the device if the reference count drops to zero.
630 */
631int dev_mc_del(struct net_device *dev, unsigned char *addr)
632{
633 return __dev_mc_del(dev, addr, false);
634}
635EXPORT_SYMBOL(dev_mc_del);
636
637/**
638 * dev_mc_del_global - Delete a global multicast address.
639 * @dev: device
640 * @addr: address to delete
641 *
642 * Release reference to a multicast address and remove it
643 * from the device if the reference count drops to zero.
644 */
645int dev_mc_del_global(struct net_device *dev, unsigned char *addr)
646{
647 return __dev_mc_del(dev, addr, true);
648}
649EXPORT_SYMBOL(dev_mc_del_global);
650
651/**
652 * dev_mc_sync - Synchronize device's unicast list to another device
653 * @to: destination device
654 * @from: source device
655 *
656 * Add newly added addresses to the destination device and release
657 * addresses that have no users left. The source device must be
658 * locked by netif_addr_lock_bh.
659 *
660 * This function is intended to be called from the ndo_set_rx_mode
661 * function of layered software devices.
662 */
663int dev_mc_sync(struct net_device *to, struct net_device *from)
664{
665 int err = 0;
666
667 if (to->addr_len != from->addr_len)
668 return -EINVAL;
669
670 netif_addr_lock_nested(to);
671 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
672 if (!err)
673 __dev_set_rx_mode(to);
674 netif_addr_unlock(to);
675 return err;
676}
677EXPORT_SYMBOL(dev_mc_sync);
678
679/**
680 * dev_mc_unsync - Remove synchronized addresses from the destination device
681 * @to: destination device
682 * @from: source device
683 *
684 * Remove all addresses that were added to the destination device by
685 * dev_mc_sync(). This function is intended to be called from the
686 * dev->stop function of layered software devices.
687 */
688void dev_mc_unsync(struct net_device *to, struct net_device *from)
689{
690 if (to->addr_len != from->addr_len)
691 return;
692
693 netif_addr_lock_bh(from);
694 netif_addr_lock_nested(to);
695 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
696 __dev_set_rx_mode(to);
697 netif_addr_unlock(to);
698 netif_addr_unlock_bh(from);
699}
700EXPORT_SYMBOL(dev_mc_unsync);
701
702/**
703 * dev_mc_flush - Flush multicast addresses
704 * @dev: device
705 *
706 * Flush multicast addresses.
707 */
708void dev_mc_flush(struct net_device *dev)
709{
710 netif_addr_lock_bh(dev);
711 __hw_addr_flush(&dev->mc);
712 netif_addr_unlock_bh(dev);
713}
714EXPORT_SYMBOL(dev_mc_flush);
715
716/**
717 * dev_mc_flush - Init multicast address list
718 * @dev: device
719 *
720 * Init multicast address list.
721 */
722void dev_mc_init(struct net_device *dev)
723{
724 __hw_addr_init(&dev->mc);
725}
726EXPORT_SYMBOL(dev_mc_init);
727
728#ifdef CONFIG_PROC_FS
729#include <linux/seq_file.h>
730
731static int dev_mc_seq_show(struct seq_file *seq, void *v)
732{
733 struct netdev_hw_addr *ha;
734 struct net_device *dev = v;
735
736 if (v == SEQ_START_TOKEN)
737 return 0;
738
739 netif_addr_lock_bh(dev);
740 netdev_for_each_mc_addr(ha, dev) {
741 int i;
742
743 seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
744 dev->name, ha->refcount, ha->global_use);
745
746 for (i = 0; i < dev->addr_len; i++)
747 seq_printf(seq, "%02x", ha->addr[i]);
748
749 seq_putc(seq, '\n');
750 }
751 netif_addr_unlock_bh(dev);
752 return 0;
753}
754
755static const struct seq_operations dev_mc_seq_ops = {
756 .start = dev_seq_start,
757 .next = dev_seq_next,
758 .stop = dev_seq_stop,
759 .show = dev_mc_seq_show,
760};
761
762static int dev_mc_seq_open(struct inode *inode, struct file *file)
763{
764 return seq_open_net(inode, file, &dev_mc_seq_ops,
765 sizeof(struct seq_net_private));
766}
767
768static const struct file_operations dev_mc_seq_fops = {
769 .owner = THIS_MODULE,
770 .open = dev_mc_seq_open,
771 .read = seq_read,
772 .llseek = seq_lseek,
773 .release = seq_release_net,
774};
775
776#endif
777
778static int __net_init dev_mc_net_init(struct net *net)
779{
780 if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
781 return -ENOMEM;
782 return 0;
783}
784
785static void __net_exit dev_mc_net_exit(struct net *net)
786{
787 proc_net_remove(net, "dev_mcast");
788}
789
790static struct pernet_operations __net_initdata dev_mc_net_ops = {
791 .init = dev_mc_net_init,
792 .exit = dev_mc_net_exit,
793};
794
795void __init dev_mcast_init(void)
796{
797 register_pernet_subsys(&dev_mc_net_ops);
798}
799