Linux Audio

Check our new training course

Loading...
v3.15
  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);
v4.17
  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);