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