Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/net/core/dev_addr_lists.c

  1 /*
  2  * net/core/dev_addr_lists.c - Functions for handling net device lists
  3  * Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
  4  *
  5  * This file contains functions for working with unicast, multicast and device
  6  * addresses lists.
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * (at your option) any later version.
 12  */
 13 
 14 #include <linux/netdevice.h>
 15 #include <linux/rtnetlink.h>
 16 #include <linux/export.h>
 17 #include <linux/list.h>
 18 
 19 /*
 20  * General list handling functions
 21  */
 22 
 23 static 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 
 49 static 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 
 84 static 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 
 92 static 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 
116 static 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 
130 static 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 
137 static 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 
156 static 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 
172 static 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  */
196 int __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 }
213 EXPORT_SYMBOL(__hw_addr_sync);
214 
215 void __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 }
226 EXPORT_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  **/
241 int __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 }
278 EXPORT_SYMBOL(__hw_addr_sync_dev);
279 
280 /**
281  *  __hw_addr_unsync_dev - Remove synchonized addresses from device
282  *  @list: address list to remove syncronized 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  **/
292 void __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 }
311 EXPORT_SYMBOL(__hw_addr_unsync_dev);
312 
313 static 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 
324 void __hw_addr_init(struct netdev_hw_addr_list *list)
325 {
326         INIT_LIST_HEAD(&list->list);
327         list->count = 0;
328 }
329 EXPORT_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  */
343 void 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 }
350 EXPORT_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  */
361 int 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 }
384 EXPORT_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  */
397 int 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 }
409 EXPORT_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  */
422 int 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 }
446 EXPORT_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  */
457 int 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);
474 out:
475         netif_addr_unlock_bh(dev);
476         return err;
477 }
478 EXPORT_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  */
488 int 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 }
500 EXPORT_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  */
510 int 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 }
522 EXPORT_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  */
537 int 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 }
551 EXPORT_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  */
567 int 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 }
581 EXPORT_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  */
592 void 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 }
604 EXPORT_SYMBOL(dev_uc_unsync);
605 
606 /**
607  *      dev_uc_flush - Flush unicast addresses
608  *      @dev: device
609  *
610  *      Flush unicast addresses.
611  */
612 void 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 }
618 EXPORT_SYMBOL(dev_uc_flush);
619 
620 /**
621  *      dev_uc_flush - Init unicast address list
622  *      @dev: device
623  *
624  *      Init unicast address list.
625  */
626 void dev_uc_init(struct net_device *dev)
627 {
628         __hw_addr_init(&dev->uc);
629 }
630 EXPORT_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  */
641 int 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);
658 out:
659         netif_addr_unlock_bh(dev);
660         return err;
661 }
662 EXPORT_SYMBOL(dev_mc_add_excl);
663 
664 static 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  */
685 int dev_mc_add(struct net_device *dev, const unsigned char *addr)
686 {
687         return __dev_mc_add(dev, addr, false);
688 }
689 EXPORT_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  */
698 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
699 {
700         return __dev_mc_add(dev, addr, true);
701 }
702 EXPORT_SYMBOL(dev_mc_add_global);
703 
704 static 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  */
726 int dev_mc_del(struct net_device *dev, const unsigned char *addr)
727 {
728         return __dev_mc_del(dev, addr, false);
729 }
730 EXPORT_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  */
740 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
741 {
742         return __dev_mc_del(dev, addr, true);
743 }
744 EXPORT_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  */
758 int 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 }
772 EXPORT_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  */
788 int 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 }
802 EXPORT_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  */
813 void 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 }
825 EXPORT_SYMBOL(dev_mc_unsync);
826 
827 /**
828  *      dev_mc_flush - Flush multicast addresses
829  *      @dev: device
830  *
831  *      Flush multicast addresses.
832  */
833 void 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 }
839 EXPORT_SYMBOL(dev_mc_flush);
840 
841 /**
842  *      dev_mc_flush - Init multicast address list
843  *      @dev: device
844  *
845  *      Init multicast address list.
846  */
847 void dev_mc_init(struct net_device *dev)
848 {
849         __hw_addr_init(&dev->mc);
850 }
851 EXPORT_SYMBOL(dev_mc_init);
852 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us