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