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