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_unsync_dev - Remove synchronized addresses from device 282 * @list: address list to remove synchronized addresses from 283 * @dev: device to sync 284 * @unsync: function to call if address should be removed 285 * 286 * Remove all addresses that were added to the device by __hw_addr_sync_dev(). 287 * This function is intended to be called from the ndo_stop or ndo_open 288 * functions on devices that require explicit address add/remove 289 * notifications. If the unsync function pointer is NULL then this function 290 * can be used to just reset the sync_cnt for the addresses in the list. 291 **/ 292 void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list, 293 struct net_device *dev, 294 int (*unsync)(struct net_device *, 295 const unsigned char *)) 296 { 297 struct netdev_hw_addr *ha, *tmp; 298 299 list_for_each_entry_safe(ha, tmp, &list->list, list) { 300 if (!ha->sync_cnt) 301 continue; 302 303 /* if unsync is defined and fails defer unsyncing address */ 304 if (unsync && unsync(dev, ha->addr)) 305 continue; 306 307 ha->sync_cnt--; 308 __hw_addr_del_entry(list, ha, false, false); 309 } 310 } 311 EXPORT_SYMBOL(__hw_addr_unsync_dev); 312 313 static void __hw_addr_flush(struct netdev_hw_addr_list *list) 314 { 315 struct netdev_hw_addr *ha, *tmp; 316 317 list_for_each_entry_safe(ha, tmp, &list->list, list) { 318 list_del_rcu(&ha->list); 319 kfree_rcu(ha, rcu_head); 320 } 321 list->count = 0; 322 } 323 324 void __hw_addr_init(struct netdev_hw_addr_list *list) 325 { 326 INIT_LIST_HEAD(&list->list); 327 list->count = 0; 328 } 329 EXPORT_SYMBOL(__hw_addr_init); 330 331 /* 332 * Device addresses handling functions 333 */ 334 335 /** 336 * dev_addr_flush - Flush device address list 337 * @dev: device 338 * 339 * Flush device address list and reset ->dev_addr. 340 * 341 * The caller must hold the rtnl_mutex. 342 */ 343 void dev_addr_flush(struct net_device *dev) 344 { 345 /* rtnl_mutex must be held here */ 346 347 __hw_addr_flush(&dev->dev_addrs); 348 dev->dev_addr = NULL; 349 } 350 EXPORT_SYMBOL(dev_addr_flush); 351 352 /** 353 * dev_addr_init - Init device address list 354 * @dev: device 355 * 356 * Init device address list and create the first element, 357 * used by ->dev_addr. 358 * 359 * The caller must hold the rtnl_mutex. 360 */ 361 int dev_addr_init(struct net_device *dev) 362 { 363 unsigned char addr[MAX_ADDR_LEN]; 364 struct netdev_hw_addr *ha; 365 int err; 366 367 /* rtnl_mutex must be held here */ 368 369 __hw_addr_init(&dev->dev_addrs); 370 memset(addr, 0, sizeof(addr)); 371 err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr), 372 NETDEV_HW_ADDR_T_LAN); 373 if (!err) { 374 /* 375 * Get the first (previously created) address from the list 376 * and set dev_addr pointer to this location. 377 */ 378 ha = list_first_entry(&dev->dev_addrs.list, 379 struct netdev_hw_addr, list); 380 dev->dev_addr = ha->addr; 381 } 382 return err; 383 } 384 EXPORT_SYMBOL(dev_addr_init); 385 386 /** 387 * dev_addr_add - Add a device address 388 * @dev: device 389 * @addr: address to add 390 * @addr_type: address type 391 * 392 * Add a device address to the device or increase the reference count if 393 * it already exists. 394 * 395 * The caller must hold the rtnl_mutex. 396 */ 397 int dev_addr_add(struct net_device *dev, const unsigned char *addr, 398 unsigned char addr_type) 399 { 400 int err; 401 402 ASSERT_RTNL(); 403 404 err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type); 405 if (!err) 406 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 407 return err; 408 } 409 EXPORT_SYMBOL(dev_addr_add); 410 411 /** 412 * dev_addr_del - Release a device address. 413 * @dev: device 414 * @addr: address to delete 415 * @addr_type: address type 416 * 417 * Release reference to a device address and remove it from the device 418 * if the reference count drops to zero. 419 * 420 * The caller must hold the rtnl_mutex. 421 */ 422 int dev_addr_del(struct net_device *dev, const unsigned char *addr, 423 unsigned char addr_type) 424 { 425 int err; 426 struct netdev_hw_addr *ha; 427 428 ASSERT_RTNL(); 429 430 /* 431 * We can not remove the first address from the list because 432 * dev->dev_addr points to that. 433 */ 434 ha = list_first_entry(&dev->dev_addrs.list, 435 struct netdev_hw_addr, list); 436 if (!memcmp(ha->addr, addr, dev->addr_len) && 437 ha->type == addr_type && ha->refcount == 1) 438 return -ENOENT; 439 440 err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len, 441 addr_type); 442 if (!err) 443 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 444 return err; 445 } 446 EXPORT_SYMBOL(dev_addr_del); 447 448 /* 449 * Unicast list handling functions 450 */ 451 452 /** 453 * dev_uc_add_excl - Add a global secondary unicast address 454 * @dev: device 455 * @addr: address to add 456 */ 457 int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr) 458 { 459 struct netdev_hw_addr *ha; 460 int err; 461 462 netif_addr_lock_bh(dev); 463 list_for_each_entry(ha, &dev->uc.list, list) { 464 if (!memcmp(ha->addr, addr, dev->addr_len) && 465 ha->type == NETDEV_HW_ADDR_T_UNICAST) { 466 err = -EEXIST; 467 goto out; 468 } 469 } 470 err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len, 471 NETDEV_HW_ADDR_T_UNICAST, true, false); 472 if (!err) 473 __dev_set_rx_mode(dev); 474 out: 475 netif_addr_unlock_bh(dev); 476 return err; 477 } 478 EXPORT_SYMBOL(dev_uc_add_excl); 479 480 /** 481 * dev_uc_add - Add a secondary unicast address 482 * @dev: device 483 * @addr: address to add 484 * 485 * Add a secondary unicast address to the device or increase 486 * the reference count if it already exists. 487 */ 488 int dev_uc_add(struct net_device *dev, const unsigned char *addr) 489 { 490 int err; 491 492 netif_addr_lock_bh(dev); 493 err = __hw_addr_add(&dev->uc, addr, dev->addr_len, 494 NETDEV_HW_ADDR_T_UNICAST); 495 if (!err) 496 __dev_set_rx_mode(dev); 497 netif_addr_unlock_bh(dev); 498 return err; 499 } 500 EXPORT_SYMBOL(dev_uc_add); 501 502 /** 503 * dev_uc_del - Release secondary unicast address. 504 * @dev: device 505 * @addr: address to delete 506 * 507 * Release reference to a secondary unicast address and remove it 508 * from the device if the reference count drops to zero. 509 */ 510 int dev_uc_del(struct net_device *dev, const unsigned char *addr) 511 { 512 int err; 513 514 netif_addr_lock_bh(dev); 515 err = __hw_addr_del(&dev->uc, addr, dev->addr_len, 516 NETDEV_HW_ADDR_T_UNICAST); 517 if (!err) 518 __dev_set_rx_mode(dev); 519 netif_addr_unlock_bh(dev); 520 return err; 521 } 522 EXPORT_SYMBOL(dev_uc_del); 523 524 /** 525 * dev_uc_sync - Synchronize device's unicast list to another device 526 * @to: destination device 527 * @from: source device 528 * 529 * Add newly added addresses to the destination device and release 530 * addresses that have no users left. The source device must be 531 * locked by netif_addr_lock_bh. 532 * 533 * This function is intended to be called from the dev->set_rx_mode 534 * function of layered software devices. This function assumes that 535 * addresses will only ever be synced to the @to devices and no other. 536 */ 537 int dev_uc_sync(struct net_device *to, struct net_device *from) 538 { 539 int err = 0; 540 541 if (to->addr_len != from->addr_len) 542 return -EINVAL; 543 544 netif_addr_lock_nested(to); 545 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len); 546 if (!err) 547 __dev_set_rx_mode(to); 548 netif_addr_unlock(to); 549 return err; 550 } 551 EXPORT_SYMBOL(dev_uc_sync); 552 553 /** 554 * dev_uc_sync_multiple - Synchronize device's unicast list to another 555 * device, but allow for multiple calls to sync to multiple devices. 556 * @to: destination device 557 * @from: source device 558 * 559 * Add newly added addresses to the destination device and release 560 * addresses that have been deleted from the source. The source device 561 * must be locked by netif_addr_lock_bh. 562 * 563 * This function is intended to be called from the dev->set_rx_mode 564 * function of layered software devices. It allows for a single source 565 * device to be synced to multiple destination devices. 566 */ 567 int dev_uc_sync_multiple(struct net_device *to, struct net_device *from) 568 { 569 int err = 0; 570 571 if (to->addr_len != from->addr_len) 572 return -EINVAL; 573 574 netif_addr_lock_nested(to); 575 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len); 576 if (!err) 577 __dev_set_rx_mode(to); 578 netif_addr_unlock(to); 579 return err; 580 } 581 EXPORT_SYMBOL(dev_uc_sync_multiple); 582 583 /** 584 * dev_uc_unsync - Remove synchronized addresses from the destination device 585 * @to: destination device 586 * @from: source device 587 * 588 * Remove all addresses that were added to the destination device by 589 * dev_uc_sync(). This function is intended to be called from the 590 * dev->stop function of layered software devices. 591 */ 592 void dev_uc_unsync(struct net_device *to, struct net_device *from) 593 { 594 if (to->addr_len != from->addr_len) 595 return; 596 597 netif_addr_lock_bh(from); 598 netif_addr_lock_nested(to); 599 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len); 600 __dev_set_rx_mode(to); 601 netif_addr_unlock(to); 602 netif_addr_unlock_bh(from); 603 } 604 EXPORT_SYMBOL(dev_uc_unsync); 605 606 /** 607 * dev_uc_flush - Flush unicast addresses 608 * @dev: device 609 * 610 * Flush unicast addresses. 611 */ 612 void dev_uc_flush(struct net_device *dev) 613 { 614 netif_addr_lock_bh(dev); 615 __hw_addr_flush(&dev->uc); 616 netif_addr_unlock_bh(dev); 617 } 618 EXPORT_SYMBOL(dev_uc_flush); 619 620 /** 621 * dev_uc_flush - Init unicast address list 622 * @dev: device 623 * 624 * Init unicast address list. 625 */ 626 void dev_uc_init(struct net_device *dev) 627 { 628 __hw_addr_init(&dev->uc); 629 } 630 EXPORT_SYMBOL(dev_uc_init); 631 632 /* 633 * Multicast list handling functions 634 */ 635 636 /** 637 * dev_mc_add_excl - Add a global secondary multicast address 638 * @dev: device 639 * @addr: address to add 640 */ 641 int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr) 642 { 643 struct netdev_hw_addr *ha; 644 int err; 645 646 netif_addr_lock_bh(dev); 647 list_for_each_entry(ha, &dev->mc.list, list) { 648 if (!memcmp(ha->addr, addr, dev->addr_len) && 649 ha->type == NETDEV_HW_ADDR_T_MULTICAST) { 650 err = -EEXIST; 651 goto out; 652 } 653 } 654 err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len, 655 NETDEV_HW_ADDR_T_MULTICAST, true, false); 656 if (!err) 657 __dev_set_rx_mode(dev); 658 out: 659 netif_addr_unlock_bh(dev); 660 return err; 661 } 662 EXPORT_SYMBOL(dev_mc_add_excl); 663 664 static int __dev_mc_add(struct net_device *dev, const unsigned char *addr, 665 bool global) 666 { 667 int err; 668 669 netif_addr_lock_bh(dev); 670 err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len, 671 NETDEV_HW_ADDR_T_MULTICAST, global, false, 0); 672 if (!err) 673 __dev_set_rx_mode(dev); 674 netif_addr_unlock_bh(dev); 675 return err; 676 } 677 /** 678 * dev_mc_add - Add a multicast address 679 * @dev: device 680 * @addr: address to add 681 * 682 * Add a multicast address to the device or increase 683 * the reference count if it already exists. 684 */ 685 int dev_mc_add(struct net_device *dev, const unsigned char *addr) 686 { 687 return __dev_mc_add(dev, addr, false); 688 } 689 EXPORT_SYMBOL(dev_mc_add); 690 691 /** 692 * dev_mc_add_global - Add a global multicast address 693 * @dev: device 694 * @addr: address to add 695 * 696 * Add a global multicast address to the device. 697 */ 698 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr) 699 { 700 return __dev_mc_add(dev, addr, true); 701 } 702 EXPORT_SYMBOL(dev_mc_add_global); 703 704 static int __dev_mc_del(struct net_device *dev, const unsigned char *addr, 705 bool global) 706 { 707 int err; 708 709 netif_addr_lock_bh(dev); 710 err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len, 711 NETDEV_HW_ADDR_T_MULTICAST, global, false); 712 if (!err) 713 __dev_set_rx_mode(dev); 714 netif_addr_unlock_bh(dev); 715 return err; 716 } 717 718 /** 719 * dev_mc_del - Delete a multicast address. 720 * @dev: device 721 * @addr: address to delete 722 * 723 * Release reference to a multicast address and remove it 724 * from the device if the reference count drops to zero. 725 */ 726 int dev_mc_del(struct net_device *dev, const unsigned char *addr) 727 { 728 return __dev_mc_del(dev, addr, false); 729 } 730 EXPORT_SYMBOL(dev_mc_del); 731 732 /** 733 * dev_mc_del_global - Delete a global multicast address. 734 * @dev: device 735 * @addr: address to delete 736 * 737 * Release reference to a multicast address and remove it 738 * from the device if the reference count drops to zero. 739 */ 740 int dev_mc_del_global(struct net_device *dev, const unsigned char *addr) 741 { 742 return __dev_mc_del(dev, addr, true); 743 } 744 EXPORT_SYMBOL(dev_mc_del_global); 745 746 /** 747 * dev_mc_sync - Synchronize device's multicast list to another device 748 * @to: destination device 749 * @from: source device 750 * 751 * Add newly added addresses to the destination device and release 752 * addresses that have no users left. The source device must be 753 * locked by netif_addr_lock_bh. 754 * 755 * This function is intended to be called from the ndo_set_rx_mode 756 * function of layered software devices. 757 */ 758 int dev_mc_sync(struct net_device *to, struct net_device *from) 759 { 760 int err = 0; 761 762 if (to->addr_len != from->addr_len) 763 return -EINVAL; 764 765 netif_addr_lock_nested(to); 766 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len); 767 if (!err) 768 __dev_set_rx_mode(to); 769 netif_addr_unlock(to); 770 return err; 771 } 772 EXPORT_SYMBOL(dev_mc_sync); 773 774 /** 775 * dev_mc_sync_multiple - Synchronize device's multicast list to another 776 * device, but allow for multiple calls to sync to multiple devices. 777 * @to: destination device 778 * @from: source device 779 * 780 * Add newly added addresses to the destination device and release 781 * addresses that have no users left. The source device must be 782 * locked by netif_addr_lock_bh. 783 * 784 * This function is intended to be called from the ndo_set_rx_mode 785 * function of layered software devices. It allows for a single 786 * source device to be synced to multiple destination devices. 787 */ 788 int dev_mc_sync_multiple(struct net_device *to, struct net_device *from) 789 { 790 int err = 0; 791 792 if (to->addr_len != from->addr_len) 793 return -EINVAL; 794 795 netif_addr_lock_nested(to); 796 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len); 797 if (!err) 798 __dev_set_rx_mode(to); 799 netif_addr_unlock(to); 800 return err; 801 } 802 EXPORT_SYMBOL(dev_mc_sync_multiple); 803 804 /** 805 * dev_mc_unsync - Remove synchronized addresses from the destination device 806 * @to: destination device 807 * @from: source device 808 * 809 * Remove all addresses that were added to the destination device by 810 * dev_mc_sync(). This function is intended to be called from the 811 * dev->stop function of layered software devices. 812 */ 813 void dev_mc_unsync(struct net_device *to, struct net_device *from) 814 { 815 if (to->addr_len != from->addr_len) 816 return; 817 818 netif_addr_lock_bh(from); 819 netif_addr_lock_nested(to); 820 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len); 821 __dev_set_rx_mode(to); 822 netif_addr_unlock(to); 823 netif_addr_unlock_bh(from); 824 } 825 EXPORT_SYMBOL(dev_mc_unsync); 826 827 /** 828 * dev_mc_flush - Flush multicast addresses 829 * @dev: device 830 * 831 * Flush multicast addresses. 832 */ 833 void dev_mc_flush(struct net_device *dev) 834 { 835 netif_addr_lock_bh(dev); 836 __hw_addr_flush(&dev->mc); 837 netif_addr_unlock_bh(dev); 838 } 839 EXPORT_SYMBOL(dev_mc_flush); 840 841 /** 842 * dev_mc_init - Init multicast address list 843 * @dev: device 844 * 845 * Init multicast address list. 846 */ 847 void dev_mc_init(struct net_device *dev) 848 { 849 __hw_addr_init(&dev->mc); 850 } 851 EXPORT_SYMBOL(dev_mc_init); 852