net/core/dev_addr_lists.c

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