kernel/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 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  **/
 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);