net/core/dev_addr_lists.c

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