Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 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

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 static 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 
239 void __hw_addr_init(struct netdev_hw_addr_list *list)
240 {
241         INIT_LIST_HEAD(&list->list);
242         list->count = 0;
243 }
244 EXPORT_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  */
258 void 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 }
265 EXPORT_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  */
276 int 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 }
299 EXPORT_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  */
312 int 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 }
324 EXPORT_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  */
337 int 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 }
361 EXPORT_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  */
372 int 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);
389 out:
390         netif_addr_unlock_bh(dev);
391         return err;
392 }
393 EXPORT_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  */
403 int 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 }
415 EXPORT_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  */
425 int 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 }
437 EXPORT_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  */
452 int 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 }
466 EXPORT_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  */
482 int 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 }
496 EXPORT_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  */
507 void 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 }
519 EXPORT_SYMBOL(dev_uc_unsync);
520 
521 /**
522  *      dev_uc_flush - Flush unicast addresses
523  *      @dev: device
524  *
525  *      Flush unicast addresses.
526  */
527 void 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 }
533 EXPORT_SYMBOL(dev_uc_flush);
534 
535 /**
536  *      dev_uc_flush - Init unicast address list
537  *      @dev: device
538  *
539  *      Init unicast address list.
540  */
541 void dev_uc_init(struct net_device *dev)
542 {
543         __hw_addr_init(&dev->uc);
544 }
545 EXPORT_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  */
556 int 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);
573 out:
574         netif_addr_unlock_bh(dev);
575         return err;
576 }
577 EXPORT_SYMBOL(dev_mc_add_excl);
578 
579 static 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  */
600 int dev_mc_add(struct net_device *dev, const unsigned char *addr)
601 {
602         return __dev_mc_add(dev, addr, false);
603 }
604 EXPORT_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  */
613 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
614 {
615         return __dev_mc_add(dev, addr, true);
616 }
617 EXPORT_SYMBOL(dev_mc_add_global);
618 
619 static 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  */
641 int dev_mc_del(struct net_device *dev, const unsigned char *addr)
642 {
643         return __dev_mc_del(dev, addr, false);
644 }
645 EXPORT_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  */
655 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
656 {
657         return __dev_mc_del(dev, addr, true);
658 }
659 EXPORT_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  */
673 int 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 }
687 EXPORT_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  */
703 int 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 }
717 EXPORT_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  */
728 void 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 }
740 EXPORT_SYMBOL(dev_mc_unsync);
741 
742 /**
743  *      dev_mc_flush - Flush multicast addresses
744  *      @dev: device
745  *
746  *      Flush multicast addresses.
747  */
748 void 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 }
754 EXPORT_SYMBOL(dev_mc_flush);
755 
756 /**
757  *      dev_mc_flush - Init multicast address list
758  *      @dev: device
759  *
760  *      Init multicast address list.
761  */
762 void dev_mc_init(struct net_device *dev)
763 {
764         __hw_addr_init(&dev->mc);
765 }
766 EXPORT_SYMBOL(dev_mc_init);
767 

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