1 /* 2 * originally based on the dummy device. 3 * 4 * Copyright 1999, Thomas Davis, tadavis@lbl.gov. 5 * Licensed under the GPL. Based on dummy.c, and eql.c devices. 6 * 7 * bonding.c: an Ethernet Bonding driver 8 * 9 * This is useful to talk to a Cisco EtherChannel compatible equipment: 10 * Cisco 5500 11 * Sun Trunking (Solaris) 12 * Alteon AceDirector Trunks 13 * Linux Bonding 14 * and probably many L2 switches ... 15 * 16 * How it works: 17 * ifconfig bond0 ipaddress netmask up 18 * will setup a network device, with an ip address. No mac address 19 * will be assigned at this time. The hw mac address will come from 20 * the first slave bonded to the channel. All slaves will then use 21 * this hw mac address. 22 * 23 * ifconfig bond0 down 24 * will release all slaves, marking them as down. 25 * 26 * ifenslave bond0 eth0 27 * will attach eth0 to bond0 as a slave. eth0 hw mac address will either 28 * a: be used as initial mac address 29 * b: if a hw mac address already is there, eth0's hw mac address 30 * will then be set from bond0. 31 * 32 */ 33 34 #include <linux/kernel.h> 35 #include <linux/module.h> 36 #include <linux/types.h> 37 #include <linux/fcntl.h> 38 #include <linux/interrupt.h> 39 #include <linux/ptrace.h> 40 #include <linux/ioport.h> 41 #include <linux/in.h> 42 #include <net/ip.h> 43 #include <linux/ip.h> 44 #include <linux/tcp.h> 45 #include <linux/udp.h> 46 #include <linux/slab.h> 47 #include <linux/string.h> 48 #include <linux/init.h> 49 #include <linux/timer.h> 50 #include <linux/socket.h> 51 #include <linux/ctype.h> 52 #include <linux/inet.h> 53 #include <linux/bitops.h> 54 #include <linux/io.h> 55 #include <asm/dma.h> 56 #include <linux/uaccess.h> 57 #include <linux/errno.h> 58 #include <linux/netdevice.h> 59 #include <linux/inetdevice.h> 60 #include <linux/igmp.h> 61 #include <linux/etherdevice.h> 62 #include <linux/skbuff.h> 63 #include <net/sock.h> 64 #include <linux/rtnetlink.h> 65 #include <linux/smp.h> 66 #include <linux/if_ether.h> 67 #include <net/arp.h> 68 #include <linux/mii.h> 69 #include <linux/ethtool.h> 70 #include <linux/if_vlan.h> 71 #include <linux/if_bonding.h> 72 #include <linux/jiffies.h> 73 #include <linux/preempt.h> 74 #include <net/route.h> 75 #include <net/net_namespace.h> 76 #include <net/netns/generic.h> 77 #include <net/pkt_sched.h> 78 #include <linux/rculist.h> 79 #include <net/flow_dissector.h> 80 #include <net/switchdev.h> 81 #include <net/bonding.h> 82 #include <net/bond_3ad.h> 83 #include <net/bond_alb.h> 84 85 #include "bonding_priv.h" 86 87 /*---------------------------- Module parameters ----------------------------*/ 88 89 /* monitor all links that often (in milliseconds). <=0 disables monitoring */ 90 91 static int max_bonds = BOND_DEFAULT_MAX_BONDS; 92 static int tx_queues = BOND_DEFAULT_TX_QUEUES; 93 static int num_peer_notif = 1; 94 static int miimon; 95 static int updelay; 96 static int downdelay; 97 static int use_carrier = 1; 98 static char *mode; 99 static char *primary; 100 static char *primary_reselect; 101 static char *lacp_rate; 102 static int min_links; 103 static char *ad_select; 104 static char *xmit_hash_policy; 105 static int arp_interval; 106 static char *arp_ip_target[BOND_MAX_ARP_TARGETS]; 107 static char *arp_validate; 108 static char *arp_all_targets; 109 static char *fail_over_mac; 110 static int all_slaves_active; 111 static struct bond_params bonding_defaults; 112 static int resend_igmp = BOND_DEFAULT_RESEND_IGMP; 113 static int packets_per_slave = 1; 114 static int lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL; 115 116 module_param(max_bonds, int, 0); 117 MODULE_PARM_DESC(max_bonds, "Max number of bonded devices"); 118 module_param(tx_queues, int, 0); 119 MODULE_PARM_DESC(tx_queues, "Max number of transmit queues (default = 16)"); 120 module_param_named(num_grat_arp, num_peer_notif, int, 0644); 121 MODULE_PARM_DESC(num_grat_arp, "Number of peer notifications to send on " 122 "failover event (alias of num_unsol_na)"); 123 module_param_named(num_unsol_na, num_peer_notif, int, 0644); 124 MODULE_PARM_DESC(num_unsol_na, "Number of peer notifications to send on " 125 "failover event (alias of num_grat_arp)"); 126 module_param(miimon, int, 0); 127 MODULE_PARM_DESC(miimon, "Link check interval in milliseconds"); 128 module_param(updelay, int, 0); 129 MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds"); 130 module_param(downdelay, int, 0); 131 MODULE_PARM_DESC(downdelay, "Delay before considering link down, " 132 "in milliseconds"); 133 module_param(use_carrier, int, 0); 134 MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; " 135 "0 for off, 1 for on (default)"); 136 module_param(mode, charp, 0); 137 MODULE_PARM_DESC(mode, "Mode of operation; 0 for balance-rr, " 138 "1 for active-backup, 2 for balance-xor, " 139 "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, " 140 "6 for balance-alb"); 141 module_param(primary, charp, 0); 142 MODULE_PARM_DESC(primary, "Primary network device to use"); 143 module_param(primary_reselect, charp, 0); 144 MODULE_PARM_DESC(primary_reselect, "Reselect primary slave " 145 "once it comes up; " 146 "0 for always (default), " 147 "1 for only if speed of primary is " 148 "better, " 149 "2 for only on active slave " 150 "failure"); 151 module_param(lacp_rate, charp, 0); 152 MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner; " 153 "0 for slow, 1 for fast"); 154 module_param(ad_select, charp, 0); 155 MODULE_PARM_DESC(ad_select, "802.3ad aggregation selection logic; " 156 "0 for stable (default), 1 for bandwidth, " 157 "2 for count"); 158 module_param(min_links, int, 0); 159 MODULE_PARM_DESC(min_links, "Minimum number of available links before turning on carrier"); 160 161 module_param(xmit_hash_policy, charp, 0); 162 MODULE_PARM_DESC(xmit_hash_policy, "balance-alb, balance-tlb, balance-xor, 802.3ad hashing method; " 163 "0 for layer 2 (default), 1 for layer 3+4, " 164 "2 for layer 2+3, 3 for encap layer 2+3, " 165 "4 for encap layer 3+4"); 166 module_param(arp_interval, int, 0); 167 MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds"); 168 module_param_array(arp_ip_target, charp, NULL, 0); 169 MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form"); 170 module_param(arp_validate, charp, 0); 171 MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes; " 172 "0 for none (default), 1 for active, " 173 "2 for backup, 3 for all"); 174 module_param(arp_all_targets, charp, 0); 175 MODULE_PARM_DESC(arp_all_targets, "fail on any/all arp targets timeout; 0 for any (default), 1 for all"); 176 module_param(fail_over_mac, charp, 0); 177 MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to " 178 "the same MAC; 0 for none (default), " 179 "1 for active, 2 for follow"); 180 module_param(all_slaves_active, int, 0); 181 MODULE_PARM_DESC(all_slaves_active, "Keep all frames received on an interface " 182 "by setting active flag for all slaves; " 183 "0 for never (default), 1 for always."); 184 module_param(resend_igmp, int, 0); 185 MODULE_PARM_DESC(resend_igmp, "Number of IGMP membership reports to send on " 186 "link failure"); 187 module_param(packets_per_slave, int, 0); 188 MODULE_PARM_DESC(packets_per_slave, "Packets to send per slave in balance-rr " 189 "mode; 0 for a random slave, 1 packet per " 190 "slave (default), >1 packets per slave."); 191 module_param(lp_interval, uint, 0); 192 MODULE_PARM_DESC(lp_interval, "The number of seconds between instances where " 193 "the bonding driver sends learning packets to " 194 "each slaves peer switch. The default is 1."); 195 196 /*----------------------------- Global variables ----------------------------*/ 197 198 #ifdef CONFIG_NET_POLL_CONTROLLER 199 atomic_t netpoll_block_tx = ATOMIC_INIT(0); 200 #endif 201 202 unsigned int bond_net_id __read_mostly; 203 204 /*-------------------------- Forward declarations ---------------------------*/ 205 206 static int bond_init(struct net_device *bond_dev); 207 static void bond_uninit(struct net_device *bond_dev); 208 static void bond_get_stats(struct net_device *bond_dev, 209 struct rtnl_link_stats64 *stats); 210 static void bond_slave_arr_handler(struct work_struct *work); 211 static bool bond_time_in_interval(struct bonding *bond, unsigned long last_act, 212 int mod); 213 static void bond_netdev_notify_work(struct work_struct *work); 214 215 /*---------------------------- General routines -----------------------------*/ 216 217 const char *bond_mode_name(int mode) 218 { 219 static const char *names[] = { 220 [BOND_MODE_ROUNDROBIN] = "load balancing (round-robin)", 221 [BOND_MODE_ACTIVEBACKUP] = "fault-tolerance (active-backup)", 222 [BOND_MODE_XOR] = "load balancing (xor)", 223 [BOND_MODE_BROADCAST] = "fault-tolerance (broadcast)", 224 [BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation", 225 [BOND_MODE_TLB] = "transmit load balancing", 226 [BOND_MODE_ALB] = "adaptive load balancing", 227 }; 228 229 if (mode < BOND_MODE_ROUNDROBIN || mode > BOND_MODE_ALB) 230 return "unknown"; 231 232 return names[mode]; 233 } 234 235 /*---------------------------------- VLAN -----------------------------------*/ 236 237 /** 238 * bond_dev_queue_xmit - Prepare skb for xmit. 239 * 240 * @bond: bond device that got this skb for tx. 241 * @skb: hw accel VLAN tagged skb to transmit 242 * @slave_dev: slave that is supposed to xmit this skbuff 243 */ 244 void bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, 245 struct net_device *slave_dev) 246 { 247 skb->dev = slave_dev; 248 249 BUILD_BUG_ON(sizeof(skb->queue_mapping) != 250 sizeof(qdisc_skb_cb(skb)->slave_dev_queue_mapping)); 251 skb_set_queue_mapping(skb, qdisc_skb_cb(skb)->slave_dev_queue_mapping); 252 253 if (unlikely(netpoll_tx_running(bond->dev))) 254 bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb); 255 else 256 dev_queue_xmit(skb); 257 } 258 259 /* In the following 2 functions, bond_vlan_rx_add_vid and bond_vlan_rx_kill_vid, 260 * We don't protect the slave list iteration with a lock because: 261 * a. This operation is performed in IOCTL context, 262 * b. The operation is protected by the RTNL semaphore in the 8021q code, 263 * c. Holding a lock with BH disabled while directly calling a base driver 264 * entry point is generally a BAD idea. 265 * 266 * The design of synchronization/protection for this operation in the 8021q 267 * module is good for one or more VLAN devices over a single physical device 268 * and cannot be extended for a teaming solution like bonding, so there is a 269 * potential race condition here where a net device from the vlan group might 270 * be referenced (either by a base driver or the 8021q code) while it is being 271 * removed from the system. However, it turns out we're not making matters 272 * worse, and if it works for regular VLAN usage it will work here too. 273 */ 274 275 /** 276 * bond_vlan_rx_add_vid - Propagates adding an id to slaves 277 * @bond_dev: bonding net device that got called 278 * @vid: vlan id being added 279 */ 280 static int bond_vlan_rx_add_vid(struct net_device *bond_dev, 281 __be16 proto, u16 vid) 282 { 283 struct bonding *bond = netdev_priv(bond_dev); 284 struct slave *slave, *rollback_slave; 285 struct list_head *iter; 286 int res; 287 288 bond_for_each_slave(bond, slave, iter) { 289 res = vlan_vid_add(slave->dev, proto, vid); 290 if (res) 291 goto unwind; 292 } 293 294 return 0; 295 296 unwind: 297 /* unwind to the slave that failed */ 298 bond_for_each_slave(bond, rollback_slave, iter) { 299 if (rollback_slave == slave) 300 break; 301 302 vlan_vid_del(rollback_slave->dev, proto, vid); 303 } 304 305 return res; 306 } 307 308 /** 309 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves 310 * @bond_dev: bonding net device that got called 311 * @vid: vlan id being removed 312 */ 313 static int bond_vlan_rx_kill_vid(struct net_device *bond_dev, 314 __be16 proto, u16 vid) 315 { 316 struct bonding *bond = netdev_priv(bond_dev); 317 struct list_head *iter; 318 struct slave *slave; 319 320 bond_for_each_slave(bond, slave, iter) 321 vlan_vid_del(slave->dev, proto, vid); 322 323 if (bond_is_lb(bond)) 324 bond_alb_clear_vlan(bond, vid); 325 326 return 0; 327 } 328 329 /*------------------------------- Link status -------------------------------*/ 330 331 /* Set the carrier state for the master according to the state of its 332 * slaves. If any slaves are up, the master is up. In 802.3ad mode, 333 * do special 802.3ad magic. 334 * 335 * Returns zero if carrier state does not change, nonzero if it does. 336 */ 337 int bond_set_carrier(struct bonding *bond) 338 { 339 struct list_head *iter; 340 struct slave *slave; 341 342 if (!bond_has_slaves(bond)) 343 goto down; 344 345 if (BOND_MODE(bond) == BOND_MODE_8023AD) 346 return bond_3ad_set_carrier(bond); 347 348 bond_for_each_slave(bond, slave, iter) { 349 if (slave->link == BOND_LINK_UP) { 350 if (!netif_carrier_ok(bond->dev)) { 351 netif_carrier_on(bond->dev); 352 return 1; 353 } 354 return 0; 355 } 356 } 357 358 down: 359 if (netif_carrier_ok(bond->dev)) { 360 netif_carrier_off(bond->dev); 361 return 1; 362 } 363 return 0; 364 } 365 366 /* Get link speed and duplex from the slave's base driver 367 * using ethtool. If for some reason the call fails or the 368 * values are invalid, set speed and duplex to -1, 369 * and return. Return 1 if speed or duplex settings are 370 * UNKNOWN; 0 otherwise. 371 */ 372 static int bond_update_speed_duplex(struct slave *slave) 373 { 374 struct net_device *slave_dev = slave->dev; 375 struct ethtool_link_ksettings ecmd; 376 int res; 377 378 slave->speed = SPEED_UNKNOWN; 379 slave->duplex = DUPLEX_UNKNOWN; 380 381 res = __ethtool_get_link_ksettings(slave_dev, &ecmd); 382 if (res < 0) 383 return 1; 384 if (ecmd.base.speed == 0 || ecmd.base.speed == ((__u32)-1)) 385 return 1; 386 switch (ecmd.base.duplex) { 387 case DUPLEX_FULL: 388 case DUPLEX_HALF: 389 break; 390 default: 391 return 1; 392 } 393 394 slave->speed = ecmd.base.speed; 395 slave->duplex = ecmd.base.duplex; 396 397 return 0; 398 } 399 400 const char *bond_slave_link_status(s8 link) 401 { 402 switch (link) { 403 case BOND_LINK_UP: 404 return "up"; 405 case BOND_LINK_FAIL: 406 return "going down"; 407 case BOND_LINK_DOWN: 408 return "down"; 409 case BOND_LINK_BACK: 410 return "going back"; 411 default: 412 return "unknown"; 413 } 414 } 415 416 /* if <dev> supports MII link status reporting, check its link status. 417 * 418 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(), 419 * depending upon the setting of the use_carrier parameter. 420 * 421 * Return either BMSR_LSTATUS, meaning that the link is up (or we 422 * can't tell and just pretend it is), or 0, meaning that the link is 423 * down. 424 * 425 * If reporting is non-zero, instead of faking link up, return -1 if 426 * both ETHTOOL and MII ioctls fail (meaning the device does not 427 * support them). If use_carrier is set, return whatever it says. 428 * It'd be nice if there was a good way to tell if a driver supports 429 * netif_carrier, but there really isn't. 430 */ 431 static int bond_check_dev_link(struct bonding *bond, 432 struct net_device *slave_dev, int reporting) 433 { 434 const struct net_device_ops *slave_ops = slave_dev->netdev_ops; 435 int (*ioctl)(struct net_device *, struct ifreq *, int); 436 struct ifreq ifr; 437 struct mii_ioctl_data *mii; 438 439 if (!reporting && !netif_running(slave_dev)) 440 return 0; 441 442 if (bond->params.use_carrier) 443 return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0; 444 445 /* Try to get link status using Ethtool first. */ 446 if (slave_dev->ethtool_ops->get_link) 447 return slave_dev->ethtool_ops->get_link(slave_dev) ? 448 BMSR_LSTATUS : 0; 449 450 /* Ethtool can't be used, fallback to MII ioctls. */ 451 ioctl = slave_ops->ndo_do_ioctl; 452 if (ioctl) { 453 /* TODO: set pointer to correct ioctl on a per team member 454 * bases to make this more efficient. that is, once 455 * we determine the correct ioctl, we will always 456 * call it and not the others for that team 457 * member. 458 */ 459 460 /* We cannot assume that SIOCGMIIPHY will also read a 461 * register; not all network drivers (e.g., e100) 462 * support that. 463 */ 464 465 /* Yes, the mii is overlaid on the ifreq.ifr_ifru */ 466 strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ); 467 mii = if_mii(&ifr); 468 if (ioctl(slave_dev, &ifr, SIOCGMIIPHY) == 0) { 469 mii->reg_num = MII_BMSR; 470 if (ioctl(slave_dev, &ifr, SIOCGMIIREG) == 0) 471 return mii->val_out & BMSR_LSTATUS; 472 } 473 } 474 475 /* If reporting, report that either there's no dev->do_ioctl, 476 * or both SIOCGMIIREG and get_link failed (meaning that we 477 * cannot report link status). If not reporting, pretend 478 * we're ok. 479 */ 480 return reporting ? -1 : BMSR_LSTATUS; 481 } 482 483 /*----------------------------- Multicast list ------------------------------*/ 484 485 /* Push the promiscuity flag down to appropriate slaves */ 486 static int bond_set_promiscuity(struct bonding *bond, int inc) 487 { 488 struct list_head *iter; 489 int err = 0; 490 491 if (bond_uses_primary(bond)) { 492 struct slave *curr_active = rtnl_dereference(bond->curr_active_slave); 493 494 if (curr_active) 495 err = dev_set_promiscuity(curr_active->dev, inc); 496 } else { 497 struct slave *slave; 498 499 bond_for_each_slave(bond, slave, iter) { 500 err = dev_set_promiscuity(slave->dev, inc); 501 if (err) 502 return err; 503 } 504 } 505 return err; 506 } 507 508 /* Push the allmulti flag down to all slaves */ 509 static int bond_set_allmulti(struct bonding *bond, int inc) 510 { 511 struct list_head *iter; 512 int err = 0; 513 514 if (bond_uses_primary(bond)) { 515 struct slave *curr_active = rtnl_dereference(bond->curr_active_slave); 516 517 if (curr_active) 518 err = dev_set_allmulti(curr_active->dev, inc); 519 } else { 520 struct slave *slave; 521 522 bond_for_each_slave(bond, slave, iter) { 523 err = dev_set_allmulti(slave->dev, inc); 524 if (err) 525 return err; 526 } 527 } 528 return err; 529 } 530 531 /* Retrieve the list of registered multicast addresses for the bonding 532 * device and retransmit an IGMP JOIN request to the current active 533 * slave. 534 */ 535 static void bond_resend_igmp_join_requests_delayed(struct work_struct *work) 536 { 537 struct bonding *bond = container_of(work, struct bonding, 538 mcast_work.work); 539 540 if (!rtnl_trylock()) { 541 queue_delayed_work(bond->wq, &bond->mcast_work, 1); 542 return; 543 } 544 call_netdevice_notifiers(NETDEV_RESEND_IGMP, bond->dev); 545 546 if (bond->igmp_retrans > 1) { 547 bond->igmp_retrans--; 548 queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5); 549 } 550 rtnl_unlock(); 551 } 552 553 /* Flush bond's hardware addresses from slave */ 554 static void bond_hw_addr_flush(struct net_device *bond_dev, 555 struct net_device *slave_dev) 556 { 557 struct bonding *bond = netdev_priv(bond_dev); 558 559 dev_uc_unsync(slave_dev, bond_dev); 560 dev_mc_unsync(slave_dev, bond_dev); 561 562 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 563 /* del lacpdu mc addr from mc list */ 564 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR; 565 566 dev_mc_del(slave_dev, lacpdu_multicast); 567 } 568 } 569 570 /*--------------------------- Active slave change ---------------------------*/ 571 572 /* Update the hardware address list and promisc/allmulti for the new and 573 * old active slaves (if any). Modes that are not using primary keep all 574 * slaves up date at all times; only the modes that use primary need to call 575 * this function to swap these settings during a failover. 576 */ 577 static void bond_hw_addr_swap(struct bonding *bond, struct slave *new_active, 578 struct slave *old_active) 579 { 580 if (old_active) { 581 if (bond->dev->flags & IFF_PROMISC) 582 dev_set_promiscuity(old_active->dev, -1); 583 584 if (bond->dev->flags & IFF_ALLMULTI) 585 dev_set_allmulti(old_active->dev, -1); 586 587 bond_hw_addr_flush(bond->dev, old_active->dev); 588 } 589 590 if (new_active) { 591 /* FIXME: Signal errors upstream. */ 592 if (bond->dev->flags & IFF_PROMISC) 593 dev_set_promiscuity(new_active->dev, 1); 594 595 if (bond->dev->flags & IFF_ALLMULTI) 596 dev_set_allmulti(new_active->dev, 1); 597 598 netif_addr_lock_bh(bond->dev); 599 dev_uc_sync(new_active->dev, bond->dev); 600 dev_mc_sync(new_active->dev, bond->dev); 601 netif_addr_unlock_bh(bond->dev); 602 } 603 } 604 605 /** 606 * bond_set_dev_addr - clone slave's address to bond 607 * @bond_dev: bond net device 608 * @slave_dev: slave net device 609 * 610 * Should be called with RTNL held. 611 */ 612 static void bond_set_dev_addr(struct net_device *bond_dev, 613 struct net_device *slave_dev) 614 { 615 netdev_dbg(bond_dev, "bond_dev=%p slave_dev=%p slave_dev->name=%s slave_dev->addr_len=%d\n", 616 bond_dev, slave_dev, slave_dev->name, slave_dev->addr_len); 617 memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len); 618 bond_dev->addr_assign_type = NET_ADDR_STOLEN; 619 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev); 620 } 621 622 static struct slave *bond_get_old_active(struct bonding *bond, 623 struct slave *new_active) 624 { 625 struct slave *slave; 626 struct list_head *iter; 627 628 bond_for_each_slave(bond, slave, iter) { 629 if (slave == new_active) 630 continue; 631 632 if (ether_addr_equal(bond->dev->dev_addr, slave->dev->dev_addr)) 633 return slave; 634 } 635 636 return NULL; 637 } 638 639 /* bond_do_fail_over_mac 640 * 641 * Perform special MAC address swapping for fail_over_mac settings 642 * 643 * Called with RTNL 644 */ 645 static void bond_do_fail_over_mac(struct bonding *bond, 646 struct slave *new_active, 647 struct slave *old_active) 648 { 649 u8 tmp_mac[MAX_ADDR_LEN]; 650 struct sockaddr_storage ss; 651 int rv; 652 653 switch (bond->params.fail_over_mac) { 654 case BOND_FOM_ACTIVE: 655 if (new_active) 656 bond_set_dev_addr(bond->dev, new_active->dev); 657 break; 658 case BOND_FOM_FOLLOW: 659 /* if new_active && old_active, swap them 660 * if just old_active, do nothing (going to no active slave) 661 * if just new_active, set new_active to bond's MAC 662 */ 663 if (!new_active) 664 return; 665 666 if (!old_active) 667 old_active = bond_get_old_active(bond, new_active); 668 669 if (old_active) { 670 bond_hw_addr_copy(tmp_mac, new_active->dev->dev_addr, 671 new_active->dev->addr_len); 672 bond_hw_addr_copy(ss.__data, 673 old_active->dev->dev_addr, 674 old_active->dev->addr_len); 675 ss.ss_family = new_active->dev->type; 676 } else { 677 bond_hw_addr_copy(ss.__data, bond->dev->dev_addr, 678 bond->dev->addr_len); 679 ss.ss_family = bond->dev->type; 680 } 681 682 rv = dev_set_mac_address(new_active->dev, 683 (struct sockaddr *)&ss); 684 if (rv) { 685 netdev_err(bond->dev, "Error %d setting MAC of slave %s\n", 686 -rv, new_active->dev->name); 687 goto out; 688 } 689 690 if (!old_active) 691 goto out; 692 693 bond_hw_addr_copy(ss.__data, tmp_mac, 694 new_active->dev->addr_len); 695 ss.ss_family = old_active->dev->type; 696 697 rv = dev_set_mac_address(old_active->dev, 698 (struct sockaddr *)&ss); 699 if (rv) 700 netdev_err(bond->dev, "Error %d setting MAC of slave %s\n", 701 -rv, new_active->dev->name); 702 out: 703 break; 704 default: 705 netdev_err(bond->dev, "bond_do_fail_over_mac impossible: bad policy %d\n", 706 bond->params.fail_over_mac); 707 break; 708 } 709 710 } 711 712 static struct slave *bond_choose_primary_or_current(struct bonding *bond) 713 { 714 struct slave *prim = rtnl_dereference(bond->primary_slave); 715 struct slave *curr = rtnl_dereference(bond->curr_active_slave); 716 717 if (!prim || prim->link != BOND_LINK_UP) { 718 if (!curr || curr->link != BOND_LINK_UP) 719 return NULL; 720 return curr; 721 } 722 723 if (bond->force_primary) { 724 bond->force_primary = false; 725 return prim; 726 } 727 728 if (!curr || curr->link != BOND_LINK_UP) 729 return prim; 730 731 /* At this point, prim and curr are both up */ 732 switch (bond->params.primary_reselect) { 733 case BOND_PRI_RESELECT_ALWAYS: 734 return prim; 735 case BOND_PRI_RESELECT_BETTER: 736 if (prim->speed < curr->speed) 737 return curr; 738 if (prim->speed == curr->speed && prim->duplex <= curr->duplex) 739 return curr; 740 return prim; 741 case BOND_PRI_RESELECT_FAILURE: 742 return curr; 743 default: 744 netdev_err(bond->dev, "impossible primary_reselect %d\n", 745 bond->params.primary_reselect); 746 return curr; 747 } 748 } 749 750 /** 751 * bond_find_best_slave - select the best available slave to be the active one 752 * @bond: our bonding struct 753 */ 754 static struct slave *bond_find_best_slave(struct bonding *bond) 755 { 756 struct slave *slave, *bestslave = NULL; 757 struct list_head *iter; 758 int mintime = bond->params.updelay; 759 760 slave = bond_choose_primary_or_current(bond); 761 if (slave) 762 return slave; 763 764 bond_for_each_slave(bond, slave, iter) { 765 if (slave->link == BOND_LINK_UP) 766 return slave; 767 if (slave->link == BOND_LINK_BACK && bond_slave_is_up(slave) && 768 slave->delay < mintime) { 769 mintime = slave->delay; 770 bestslave = slave; 771 } 772 } 773 774 return bestslave; 775 } 776 777 static bool bond_should_notify_peers(struct bonding *bond) 778 { 779 struct slave *slave; 780 781 rcu_read_lock(); 782 slave = rcu_dereference(bond->curr_active_slave); 783 rcu_read_unlock(); 784 785 netdev_dbg(bond->dev, "bond_should_notify_peers: slave %s\n", 786 slave ? slave->dev->name : "NULL"); 787 788 if (!slave || !bond->send_peer_notif || 789 !netif_carrier_ok(bond->dev) || 790 test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state)) 791 return false; 792 793 return true; 794 } 795 796 /** 797 * change_active_interface - change the active slave into the specified one 798 * @bond: our bonding struct 799 * @new: the new slave to make the active one 800 * 801 * Set the new slave to the bond's settings and unset them on the old 802 * curr_active_slave. 803 * Setting include flags, mc-list, promiscuity, allmulti, etc. 804 * 805 * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP, 806 * because it is apparently the best available slave we have, even though its 807 * updelay hasn't timed out yet. 808 * 809 * Caller must hold RTNL. 810 */ 811 void bond_change_active_slave(struct bonding *bond, struct slave *new_active) 812 { 813 struct slave *old_active; 814 815 ASSERT_RTNL(); 816 817 old_active = rtnl_dereference(bond->curr_active_slave); 818 819 if (old_active == new_active) 820 return; 821 822 if (new_active) { 823 new_active->last_link_up = jiffies; 824 825 if (new_active->link == BOND_LINK_BACK) { 826 if (bond_uses_primary(bond)) { 827 netdev_info(bond->dev, "making interface %s the new active one %d ms earlier\n", 828 new_active->dev->name, 829 (bond->params.updelay - new_active->delay) * bond->params.miimon); 830 } 831 832 new_active->delay = 0; 833 bond_set_slave_link_state(new_active, BOND_LINK_UP, 834 BOND_SLAVE_NOTIFY_NOW); 835 836 if (BOND_MODE(bond) == BOND_MODE_8023AD) 837 bond_3ad_handle_link_change(new_active, BOND_LINK_UP); 838 839 if (bond_is_lb(bond)) 840 bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP); 841 } else { 842 if (bond_uses_primary(bond)) { 843 netdev_info(bond->dev, "making interface %s the new active one\n", 844 new_active->dev->name); 845 } 846 } 847 } 848 849 if (bond_uses_primary(bond)) 850 bond_hw_addr_swap(bond, new_active, old_active); 851 852 if (bond_is_lb(bond)) { 853 bond_alb_handle_active_change(bond, new_active); 854 if (old_active) 855 bond_set_slave_inactive_flags(old_active, 856 BOND_SLAVE_NOTIFY_NOW); 857 if (new_active) 858 bond_set_slave_active_flags(new_active, 859 BOND_SLAVE_NOTIFY_NOW); 860 } else { 861 rcu_assign_pointer(bond->curr_active_slave, new_active); 862 } 863 864 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) { 865 if (old_active) 866 bond_set_slave_inactive_flags(old_active, 867 BOND_SLAVE_NOTIFY_NOW); 868 869 if (new_active) { 870 bool should_notify_peers = false; 871 872 bond_set_slave_active_flags(new_active, 873 BOND_SLAVE_NOTIFY_NOW); 874 875 if (bond->params.fail_over_mac) 876 bond_do_fail_over_mac(bond, new_active, 877 old_active); 878 879 if (netif_running(bond->dev)) { 880 bond->send_peer_notif = 881 bond->params.num_peer_notif; 882 should_notify_peers = 883 bond_should_notify_peers(bond); 884 } 885 886 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, bond->dev); 887 if (should_notify_peers) 888 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, 889 bond->dev); 890 } 891 } 892 893 /* resend IGMP joins since active slave has changed or 894 * all were sent on curr_active_slave. 895 * resend only if bond is brought up with the affected 896 * bonding modes and the retransmission is enabled 897 */ 898 if (netif_running(bond->dev) && (bond->params.resend_igmp > 0) && 899 ((bond_uses_primary(bond) && new_active) || 900 BOND_MODE(bond) == BOND_MODE_ROUNDROBIN)) { 901 bond->igmp_retrans = bond->params.resend_igmp; 902 queue_delayed_work(bond->wq, &bond->mcast_work, 1); 903 } 904 } 905 906 /** 907 * bond_select_active_slave - select a new active slave, if needed 908 * @bond: our bonding struct 909 * 910 * This functions should be called when one of the following occurs: 911 * - The old curr_active_slave has been released or lost its link. 912 * - The primary_slave has got its link back. 913 * - A slave has got its link back and there's no old curr_active_slave. 914 * 915 * Caller must hold RTNL. 916 */ 917 void bond_select_active_slave(struct bonding *bond) 918 { 919 struct slave *best_slave; 920 int rv; 921 922 ASSERT_RTNL(); 923 924 best_slave = bond_find_best_slave(bond); 925 if (best_slave != rtnl_dereference(bond->curr_active_slave)) { 926 bond_change_active_slave(bond, best_slave); 927 rv = bond_set_carrier(bond); 928 if (!rv) 929 return; 930 931 if (netif_carrier_ok(bond->dev)) 932 netdev_info(bond->dev, "first active interface up!\n"); 933 else 934 netdev_info(bond->dev, "now running without any active interface!\n"); 935 } 936 } 937 938 #ifdef CONFIG_NET_POLL_CONTROLLER 939 static inline int slave_enable_netpoll(struct slave *slave) 940 { 941 struct netpoll *np; 942 int err = 0; 943 944 np = kzalloc(sizeof(*np), GFP_KERNEL); 945 err = -ENOMEM; 946 if (!np) 947 goto out; 948 949 err = __netpoll_setup(np, slave->dev); 950 if (err) { 951 kfree(np); 952 goto out; 953 } 954 slave->np = np; 955 out: 956 return err; 957 } 958 static inline void slave_disable_netpoll(struct slave *slave) 959 { 960 struct netpoll *np = slave->np; 961 962 if (!np) 963 return; 964 965 slave->np = NULL; 966 967 __netpoll_free(np); 968 } 969 970 static void bond_poll_controller(struct net_device *bond_dev) 971 { 972 struct bonding *bond = netdev_priv(bond_dev); 973 struct slave *slave = NULL; 974 struct list_head *iter; 975 struct ad_info ad_info; 976 977 if (BOND_MODE(bond) == BOND_MODE_8023AD) 978 if (bond_3ad_get_active_agg_info(bond, &ad_info)) 979 return; 980 981 bond_for_each_slave_rcu(bond, slave, iter) { 982 if (!bond_slave_is_up(slave)) 983 continue; 984 985 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 986 struct aggregator *agg = 987 SLAVE_AD_INFO(slave)->port.aggregator; 988 989 if (agg && 990 agg->aggregator_identifier != ad_info.aggregator_id) 991 continue; 992 } 993 994 netpoll_poll_dev(slave->dev); 995 } 996 } 997 998 static void bond_netpoll_cleanup(struct net_device *bond_dev) 999 { 1000 struct bonding *bond = netdev_priv(bond_dev); 1001 struct list_head *iter; 1002 struct slave *slave; 1003 1004 bond_for_each_slave(bond, slave, iter) 1005 if (bond_slave_is_up(slave)) 1006 slave_disable_netpoll(slave); 1007 } 1008 1009 static int bond_netpoll_setup(struct net_device *dev, struct netpoll_info *ni) 1010 { 1011 struct bonding *bond = netdev_priv(dev); 1012 struct list_head *iter; 1013 struct slave *slave; 1014 int err = 0; 1015 1016 bond_for_each_slave(bond, slave, iter) { 1017 err = slave_enable_netpoll(slave); 1018 if (err) { 1019 bond_netpoll_cleanup(dev); 1020 break; 1021 } 1022 } 1023 return err; 1024 } 1025 #else 1026 static inline int slave_enable_netpoll(struct slave *slave) 1027 { 1028 return 0; 1029 } 1030 static inline void slave_disable_netpoll(struct slave *slave) 1031 { 1032 } 1033 static void bond_netpoll_cleanup(struct net_device *bond_dev) 1034 { 1035 } 1036 #endif 1037 1038 /*---------------------------------- IOCTL ----------------------------------*/ 1039 1040 static netdev_features_t bond_fix_features(struct net_device *dev, 1041 netdev_features_t features) 1042 { 1043 struct bonding *bond = netdev_priv(dev); 1044 struct list_head *iter; 1045 netdev_features_t mask; 1046 struct slave *slave; 1047 1048 mask = features; 1049 1050 features &= ~NETIF_F_ONE_FOR_ALL; 1051 features |= NETIF_F_ALL_FOR_ALL; 1052 1053 bond_for_each_slave(bond, slave, iter) { 1054 features = netdev_increment_features(features, 1055 slave->dev->features, 1056 mask); 1057 } 1058 features = netdev_add_tso_features(features, mask); 1059 1060 return features; 1061 } 1062 1063 #define BOND_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \ 1064 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \ 1065 NETIF_F_HIGHDMA | NETIF_F_LRO) 1066 1067 #define BOND_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \ 1068 NETIF_F_RXCSUM | NETIF_F_ALL_TSO) 1069 1070 static void bond_compute_features(struct bonding *bond) 1071 { 1072 unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE | 1073 IFF_XMIT_DST_RELEASE_PERM; 1074 netdev_features_t vlan_features = BOND_VLAN_FEATURES; 1075 netdev_features_t enc_features = BOND_ENC_FEATURES; 1076 struct net_device *bond_dev = bond->dev; 1077 struct list_head *iter; 1078 struct slave *slave; 1079 unsigned short max_hard_header_len = ETH_HLEN; 1080 unsigned int gso_max_size = GSO_MAX_SIZE; 1081 u16 gso_max_segs = GSO_MAX_SEGS; 1082 1083 if (!bond_has_slaves(bond)) 1084 goto done; 1085 vlan_features &= NETIF_F_ALL_FOR_ALL; 1086 1087 bond_for_each_slave(bond, slave, iter) { 1088 vlan_features = netdev_increment_features(vlan_features, 1089 slave->dev->vlan_features, BOND_VLAN_FEATURES); 1090 1091 enc_features = netdev_increment_features(enc_features, 1092 slave->dev->hw_enc_features, 1093 BOND_ENC_FEATURES); 1094 dst_release_flag &= slave->dev->priv_flags; 1095 if (slave->dev->hard_header_len > max_hard_header_len) 1096 max_hard_header_len = slave->dev->hard_header_len; 1097 1098 gso_max_size = min(gso_max_size, slave->dev->gso_max_size); 1099 gso_max_segs = min(gso_max_segs, slave->dev->gso_max_segs); 1100 } 1101 bond_dev->hard_header_len = max_hard_header_len; 1102 1103 done: 1104 bond_dev->vlan_features = vlan_features; 1105 bond_dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL | 1106 NETIF_F_GSO_UDP_L4; 1107 bond_dev->gso_max_segs = gso_max_segs; 1108 netif_set_gso_max_size(bond_dev, gso_max_size); 1109 1110 bond_dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; 1111 if ((bond_dev->priv_flags & IFF_XMIT_DST_RELEASE_PERM) && 1112 dst_release_flag == (IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM)) 1113 bond_dev->priv_flags |= IFF_XMIT_DST_RELEASE; 1114 1115 netdev_change_features(bond_dev); 1116 } 1117 1118 static void bond_setup_by_slave(struct net_device *bond_dev, 1119 struct net_device *slave_dev) 1120 { 1121 bond_dev->header_ops = slave_dev->header_ops; 1122 1123 bond_dev->type = slave_dev->type; 1124 bond_dev->hard_header_len = slave_dev->hard_header_len; 1125 bond_dev->addr_len = slave_dev->addr_len; 1126 1127 memcpy(bond_dev->broadcast, slave_dev->broadcast, 1128 slave_dev->addr_len); 1129 } 1130 1131 /* On bonding slaves other than the currently active slave, suppress 1132 * duplicates except for alb non-mcast/bcast. 1133 */ 1134 static bool bond_should_deliver_exact_match(struct sk_buff *skb, 1135 struct slave *slave, 1136 struct bonding *bond) 1137 { 1138 if (bond_is_slave_inactive(slave)) { 1139 if (BOND_MODE(bond) == BOND_MODE_ALB && 1140 skb->pkt_type != PACKET_BROADCAST && 1141 skb->pkt_type != PACKET_MULTICAST) 1142 return false; 1143 return true; 1144 } 1145 return false; 1146 } 1147 1148 static rx_handler_result_t bond_handle_frame(struct sk_buff **pskb) 1149 { 1150 struct sk_buff *skb = *pskb; 1151 struct slave *slave; 1152 struct bonding *bond; 1153 int (*recv_probe)(const struct sk_buff *, struct bonding *, 1154 struct slave *); 1155 int ret = RX_HANDLER_ANOTHER; 1156 1157 skb = skb_share_check(skb, GFP_ATOMIC); 1158 if (unlikely(!skb)) 1159 return RX_HANDLER_CONSUMED; 1160 1161 *pskb = skb; 1162 1163 slave = bond_slave_get_rcu(skb->dev); 1164 bond = slave->bond; 1165 1166 recv_probe = READ_ONCE(bond->recv_probe); 1167 if (recv_probe) { 1168 ret = recv_probe(skb, bond, slave); 1169 if (ret == RX_HANDLER_CONSUMED) { 1170 consume_skb(skb); 1171 return ret; 1172 } 1173 } 1174 1175 /* Link-local multicast packets should be passed to the 1176 * stack on the link they arrive as well as pass them to the 1177 * bond-master device. These packets are mostly usable when 1178 * stack receives it with the link on which they arrive 1179 * (e.g. LLDP) they also must be available on master. Some of 1180 * the use cases include (but are not limited to): LLDP agents 1181 * that must be able to operate both on enslaved interfaces as 1182 * well as on bonds themselves; linux bridges that must be able 1183 * to process/pass BPDUs from attached bonds when any kind of 1184 * STP version is enabled on the network. 1185 */ 1186 if (is_link_local_ether_addr(eth_hdr(skb)->h_dest)) { 1187 struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC); 1188 1189 if (nskb) { 1190 nskb->dev = bond->dev; 1191 nskb->queue_mapping = 0; 1192 netif_rx(nskb); 1193 } 1194 return RX_HANDLER_PASS; 1195 } 1196 if (bond_should_deliver_exact_match(skb, slave, bond)) 1197 return RX_HANDLER_EXACT; 1198 1199 skb->dev = bond->dev; 1200 1201 if (BOND_MODE(bond) == BOND_MODE_ALB && 1202 bond->dev->priv_flags & IFF_BRIDGE_PORT && 1203 skb->pkt_type == PACKET_HOST) { 1204 1205 if (unlikely(skb_cow_head(skb, 1206 skb->data - skb_mac_header(skb)))) { 1207 kfree_skb(skb); 1208 return RX_HANDLER_CONSUMED; 1209 } 1210 bond_hw_addr_copy(eth_hdr(skb)->h_dest, bond->dev->dev_addr, 1211 bond->dev->addr_len); 1212 } 1213 1214 return ret; 1215 } 1216 1217 static enum netdev_lag_tx_type bond_lag_tx_type(struct bonding *bond) 1218 { 1219 switch (BOND_MODE(bond)) { 1220 case BOND_MODE_ROUNDROBIN: 1221 return NETDEV_LAG_TX_TYPE_ROUNDROBIN; 1222 case BOND_MODE_ACTIVEBACKUP: 1223 return NETDEV_LAG_TX_TYPE_ACTIVEBACKUP; 1224 case BOND_MODE_BROADCAST: 1225 return NETDEV_LAG_TX_TYPE_BROADCAST; 1226 case BOND_MODE_XOR: 1227 case BOND_MODE_8023AD: 1228 return NETDEV_LAG_TX_TYPE_HASH; 1229 default: 1230 return NETDEV_LAG_TX_TYPE_UNKNOWN; 1231 } 1232 } 1233 1234 static enum netdev_lag_hash bond_lag_hash_type(struct bonding *bond, 1235 enum netdev_lag_tx_type type) 1236 { 1237 if (type != NETDEV_LAG_TX_TYPE_HASH) 1238 return NETDEV_LAG_HASH_NONE; 1239 1240 switch (bond->params.xmit_policy) { 1241 case BOND_XMIT_POLICY_LAYER2: 1242 return NETDEV_LAG_HASH_L2; 1243 case BOND_XMIT_POLICY_LAYER34: 1244 return NETDEV_LAG_HASH_L34; 1245 case BOND_XMIT_POLICY_LAYER23: 1246 return NETDEV_LAG_HASH_L23; 1247 case BOND_XMIT_POLICY_ENCAP23: 1248 return NETDEV_LAG_HASH_E23; 1249 case BOND_XMIT_POLICY_ENCAP34: 1250 return NETDEV_LAG_HASH_E34; 1251 default: 1252 return NETDEV_LAG_HASH_UNKNOWN; 1253 } 1254 } 1255 1256 static int bond_master_upper_dev_link(struct bonding *bond, struct slave *slave, 1257 struct netlink_ext_ack *extack) 1258 { 1259 struct netdev_lag_upper_info lag_upper_info; 1260 enum netdev_lag_tx_type type; 1261 1262 type = bond_lag_tx_type(bond); 1263 lag_upper_info.tx_type = type; 1264 lag_upper_info.hash_type = bond_lag_hash_type(bond, type); 1265 1266 return netdev_master_upper_dev_link(slave->dev, bond->dev, slave, 1267 &lag_upper_info, extack); 1268 } 1269 1270 static void bond_upper_dev_unlink(struct bonding *bond, struct slave *slave) 1271 { 1272 netdev_upper_dev_unlink(slave->dev, bond->dev); 1273 slave->dev->flags &= ~IFF_SLAVE; 1274 } 1275 1276 static struct slave *bond_alloc_slave(struct bonding *bond) 1277 { 1278 struct slave *slave = NULL; 1279 1280 slave = kzalloc(sizeof(*slave), GFP_KERNEL); 1281 if (!slave) 1282 return NULL; 1283 1284 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 1285 SLAVE_AD_INFO(slave) = kzalloc(sizeof(struct ad_slave_info), 1286 GFP_KERNEL); 1287 if (!SLAVE_AD_INFO(slave)) { 1288 kfree(slave); 1289 return NULL; 1290 } 1291 } 1292 INIT_DELAYED_WORK(&slave->notify_work, bond_netdev_notify_work); 1293 1294 return slave; 1295 } 1296 1297 static void bond_free_slave(struct slave *slave) 1298 { 1299 struct bonding *bond = bond_get_bond_by_slave(slave); 1300 1301 cancel_delayed_work_sync(&slave->notify_work); 1302 if (BOND_MODE(bond) == BOND_MODE_8023AD) 1303 kfree(SLAVE_AD_INFO(slave)); 1304 1305 kfree(slave); 1306 } 1307 1308 static void bond_fill_ifbond(struct bonding *bond, struct ifbond *info) 1309 { 1310 info->bond_mode = BOND_MODE(bond); 1311 info->miimon = bond->params.miimon; 1312 info->num_slaves = bond->slave_cnt; 1313 } 1314 1315 static void bond_fill_ifslave(struct slave *slave, struct ifslave *info) 1316 { 1317 strcpy(info->slave_name, slave->dev->name); 1318 info->link = slave->link; 1319 info->state = bond_slave_state(slave); 1320 info->link_failure_count = slave->link_failure_count; 1321 } 1322 1323 static void bond_netdev_notify_work(struct work_struct *_work) 1324 { 1325 struct slave *slave = container_of(_work, struct slave, 1326 notify_work.work); 1327 1328 if (rtnl_trylock()) { 1329 struct netdev_bonding_info binfo; 1330 1331 bond_fill_ifslave(slave, &binfo.slave); 1332 bond_fill_ifbond(slave->bond, &binfo.master); 1333 netdev_bonding_info_change(slave->dev, &binfo); 1334 rtnl_unlock(); 1335 } else { 1336 queue_delayed_work(slave->bond->wq, &slave->notify_work, 1); 1337 } 1338 } 1339 1340 void bond_queue_slave_event(struct slave *slave) 1341 { 1342 queue_delayed_work(slave->bond->wq, &slave->notify_work, 0); 1343 } 1344 1345 void bond_lower_state_changed(struct slave *slave) 1346 { 1347 struct netdev_lag_lower_state_info info; 1348 1349 info.link_up = slave->link == BOND_LINK_UP || 1350 slave->link == BOND_LINK_FAIL; 1351 info.tx_enabled = bond_is_active_slave(slave); 1352 netdev_lower_state_changed(slave->dev, &info); 1353 } 1354 1355 /* enslave device <slave> to bond device <master> */ 1356 int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev, 1357 struct netlink_ext_ack *extack) 1358 { 1359 struct bonding *bond = netdev_priv(bond_dev); 1360 const struct net_device_ops *slave_ops = slave_dev->netdev_ops; 1361 struct slave *new_slave = NULL, *prev_slave; 1362 struct sockaddr_storage ss; 1363 int link_reporting; 1364 int res = 0, i; 1365 1366 if (!bond->params.use_carrier && 1367 slave_dev->ethtool_ops->get_link == NULL && 1368 slave_ops->ndo_do_ioctl == NULL) { 1369 netdev_warn(bond_dev, "no link monitoring support for %s\n", 1370 slave_dev->name); 1371 } 1372 1373 /* already in-use? */ 1374 if (netdev_is_rx_handler_busy(slave_dev)) { 1375 NL_SET_ERR_MSG(extack, "Device is in use and cannot be enslaved"); 1376 netdev_err(bond_dev, 1377 "Error: Device is in use and cannot be enslaved\n"); 1378 return -EBUSY; 1379 } 1380 1381 if (bond_dev == slave_dev) { 1382 NL_SET_ERR_MSG(extack, "Cannot enslave bond to itself."); 1383 netdev_err(bond_dev, "cannot enslave bond to itself.\n"); 1384 return -EPERM; 1385 } 1386 1387 /* vlan challenged mutual exclusion */ 1388 /* no need to lock since we're protected by rtnl_lock */ 1389 if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) { 1390 netdev_dbg(bond_dev, "%s is NETIF_F_VLAN_CHALLENGED\n", 1391 slave_dev->name); 1392 if (vlan_uses_dev(bond_dev)) { 1393 NL_SET_ERR_MSG(extack, "Can not enslave VLAN challenged device to VLAN enabled bond"); 1394 netdev_err(bond_dev, "Error: cannot enslave VLAN challenged slave %s on VLAN enabled bond %s\n", 1395 slave_dev->name, bond_dev->name); 1396 return -EPERM; 1397 } else { 1398 netdev_warn(bond_dev, "enslaved VLAN challenged slave %s. Adding VLANs will be blocked as long as %s is part of bond %s\n", 1399 slave_dev->name, slave_dev->name, 1400 bond_dev->name); 1401 } 1402 } else { 1403 netdev_dbg(bond_dev, "%s is !NETIF_F_VLAN_CHALLENGED\n", 1404 slave_dev->name); 1405 } 1406 1407 /* Old ifenslave binaries are no longer supported. These can 1408 * be identified with moderate accuracy by the state of the slave: 1409 * the current ifenslave will set the interface down prior to 1410 * enslaving it; the old ifenslave will not. 1411 */ 1412 if (slave_dev->flags & IFF_UP) { 1413 NL_SET_ERR_MSG(extack, "Device can not be enslaved while up"); 1414 netdev_err(bond_dev, "%s is up - this may be due to an out of date ifenslave\n", 1415 slave_dev->name); 1416 return -EPERM; 1417 } 1418 1419 /* set bonding device ether type by slave - bonding netdevices are 1420 * created with ether_setup, so when the slave type is not ARPHRD_ETHER 1421 * there is a need to override some of the type dependent attribs/funcs. 1422 * 1423 * bond ether type mutual exclusion - don't allow slaves of dissimilar 1424 * ether type (eg ARPHRD_ETHER and ARPHRD_INFINIBAND) share the same bond 1425 */ 1426 if (!bond_has_slaves(bond)) { 1427 if (bond_dev->type != slave_dev->type) { 1428 netdev_dbg(bond_dev, "change device type from %d to %d\n", 1429 bond_dev->type, slave_dev->type); 1430 1431 res = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, 1432 bond_dev); 1433 res = notifier_to_errno(res); 1434 if (res) { 1435 netdev_err(bond_dev, "refused to change device type\n"); 1436 return -EBUSY; 1437 } 1438 1439 /* Flush unicast and multicast addresses */ 1440 dev_uc_flush(bond_dev); 1441 dev_mc_flush(bond_dev); 1442 1443 if (slave_dev->type != ARPHRD_ETHER) 1444 bond_setup_by_slave(bond_dev, slave_dev); 1445 else { 1446 ether_setup(bond_dev); 1447 bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1448 } 1449 1450 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, 1451 bond_dev); 1452 } 1453 } else if (bond_dev->type != slave_dev->type) { 1454 NL_SET_ERR_MSG(extack, "Device type is different from other slaves"); 1455 netdev_err(bond_dev, "%s ether type (%d) is different from other slaves (%d), can not enslave it\n", 1456 slave_dev->name, slave_dev->type, bond_dev->type); 1457 return -EINVAL; 1458 } 1459 1460 if (slave_dev->type == ARPHRD_INFINIBAND && 1461 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 1462 NL_SET_ERR_MSG(extack, "Only active-backup mode is supported for infiniband slaves"); 1463 netdev_warn(bond_dev, "Type (%d) supports only active-backup mode\n", 1464 slave_dev->type); 1465 res = -EOPNOTSUPP; 1466 goto err_undo_flags; 1467 } 1468 1469 if (!slave_ops->ndo_set_mac_address || 1470 slave_dev->type == ARPHRD_INFINIBAND) { 1471 netdev_warn(bond_dev, "The slave device specified does not support setting the MAC address\n"); 1472 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP && 1473 bond->params.fail_over_mac != BOND_FOM_ACTIVE) { 1474 if (!bond_has_slaves(bond)) { 1475 bond->params.fail_over_mac = BOND_FOM_ACTIVE; 1476 netdev_warn(bond_dev, "Setting fail_over_mac to active for active-backup mode\n"); 1477 } else { 1478 NL_SET_ERR_MSG(extack, "Slave device does not support setting the MAC address, but fail_over_mac is not set to active"); 1479 netdev_err(bond_dev, "The slave device specified does not support setting the MAC address, but fail_over_mac is not set to active\n"); 1480 res = -EOPNOTSUPP; 1481 goto err_undo_flags; 1482 } 1483 } 1484 } 1485 1486 call_netdevice_notifiers(NETDEV_JOIN, slave_dev); 1487 1488 /* If this is the first slave, then we need to set the master's hardware 1489 * address to be the same as the slave's. 1490 */ 1491 if (!bond_has_slaves(bond) && 1492 bond->dev->addr_assign_type == NET_ADDR_RANDOM) 1493 bond_set_dev_addr(bond->dev, slave_dev); 1494 1495 new_slave = bond_alloc_slave(bond); 1496 if (!new_slave) { 1497 res = -ENOMEM; 1498 goto err_undo_flags; 1499 } 1500 1501 new_slave->bond = bond; 1502 new_slave->dev = slave_dev; 1503 /* Set the new_slave's queue_id to be zero. Queue ID mapping 1504 * is set via sysfs or module option if desired. 1505 */ 1506 new_slave->queue_id = 0; 1507 1508 /* Save slave's original mtu and then set it to match the bond */ 1509 new_slave->original_mtu = slave_dev->mtu; 1510 res = dev_set_mtu(slave_dev, bond->dev->mtu); 1511 if (res) { 1512 netdev_dbg(bond_dev, "Error %d calling dev_set_mtu\n", res); 1513 goto err_free; 1514 } 1515 1516 /* Save slave's original ("permanent") mac address for modes 1517 * that need it, and for restoring it upon release, and then 1518 * set it to the master's address 1519 */ 1520 bond_hw_addr_copy(new_slave->perm_hwaddr, slave_dev->dev_addr, 1521 slave_dev->addr_len); 1522 1523 if (!bond->params.fail_over_mac || 1524 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 1525 /* Set slave to master's mac address. The application already 1526 * set the master's mac address to that of the first slave 1527 */ 1528 memcpy(ss.__data, bond_dev->dev_addr, bond_dev->addr_len); 1529 ss.ss_family = slave_dev->type; 1530 res = dev_set_mac_address(slave_dev, (struct sockaddr *)&ss); 1531 if (res) { 1532 netdev_dbg(bond_dev, "Error %d calling set_mac_address\n", res); 1533 goto err_restore_mtu; 1534 } 1535 } 1536 1537 /* set slave flag before open to prevent IPv6 addrconf */ 1538 slave_dev->flags |= IFF_SLAVE; 1539 1540 /* open the slave since the application closed it */ 1541 res = dev_open(slave_dev); 1542 if (res) { 1543 netdev_dbg(bond_dev, "Opening slave %s failed\n", slave_dev->name); 1544 goto err_restore_mac; 1545 } 1546 1547 slave_dev->priv_flags |= IFF_BONDING; 1548 /* initialize slave stats */ 1549 dev_get_stats(new_slave->dev, &new_slave->slave_stats); 1550 1551 if (bond_is_lb(bond)) { 1552 /* bond_alb_init_slave() must be called before all other stages since 1553 * it might fail and we do not want to have to undo everything 1554 */ 1555 res = bond_alb_init_slave(bond, new_slave); 1556 if (res) 1557 goto err_close; 1558 } 1559 1560 res = vlan_vids_add_by_dev(slave_dev, bond_dev); 1561 if (res) { 1562 netdev_err(bond_dev, "Couldn't add bond vlan ids to %s\n", 1563 slave_dev->name); 1564 goto err_close; 1565 } 1566 1567 prev_slave = bond_last_slave(bond); 1568 1569 new_slave->delay = 0; 1570 new_slave->link_failure_count = 0; 1571 1572 if (bond_update_speed_duplex(new_slave) && 1573 bond_needs_speed_duplex(bond)) 1574 new_slave->link = BOND_LINK_DOWN; 1575 1576 new_slave->last_rx = jiffies - 1577 (msecs_to_jiffies(bond->params.arp_interval) + 1); 1578 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) 1579 new_slave->target_last_arp_rx[i] = new_slave->last_rx; 1580 1581 if (bond->params.miimon && !bond->params.use_carrier) { 1582 link_reporting = bond_check_dev_link(bond, slave_dev, 1); 1583 1584 if ((link_reporting == -1) && !bond->params.arp_interval) { 1585 /* miimon is set but a bonded network driver 1586 * does not support ETHTOOL/MII and 1587 * arp_interval is not set. Note: if 1588 * use_carrier is enabled, we will never go 1589 * here (because netif_carrier is always 1590 * supported); thus, we don't need to change 1591 * the messages for netif_carrier. 1592 */ 1593 netdev_warn(bond_dev, "MII and ETHTOOL support not available for interface %s, and arp_interval/arp_ip_target module parameters not specified, thus bonding will not detect link failures! see bonding.txt for details\n", 1594 slave_dev->name); 1595 } else if (link_reporting == -1) { 1596 /* unable get link status using mii/ethtool */ 1597 netdev_warn(bond_dev, "can't get link status from interface %s; the network driver associated with this interface does not support MII or ETHTOOL link status reporting, thus miimon has no effect on this interface\n", 1598 slave_dev->name); 1599 } 1600 } 1601 1602 /* check for initial state */ 1603 new_slave->link = BOND_LINK_NOCHANGE; 1604 if (bond->params.miimon) { 1605 if (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS) { 1606 if (bond->params.updelay) { 1607 bond_set_slave_link_state(new_slave, 1608 BOND_LINK_BACK, 1609 BOND_SLAVE_NOTIFY_NOW); 1610 new_slave->delay = bond->params.updelay; 1611 } else { 1612 bond_set_slave_link_state(new_slave, 1613 BOND_LINK_UP, 1614 BOND_SLAVE_NOTIFY_NOW); 1615 } 1616 } else { 1617 bond_set_slave_link_state(new_slave, BOND_LINK_DOWN, 1618 BOND_SLAVE_NOTIFY_NOW); 1619 } 1620 } else if (bond->params.arp_interval) { 1621 bond_set_slave_link_state(new_slave, 1622 (netif_carrier_ok(slave_dev) ? 1623 BOND_LINK_UP : BOND_LINK_DOWN), 1624 BOND_SLAVE_NOTIFY_NOW); 1625 } else { 1626 bond_set_slave_link_state(new_slave, BOND_LINK_UP, 1627 BOND_SLAVE_NOTIFY_NOW); 1628 } 1629 1630 if (new_slave->link != BOND_LINK_DOWN) 1631 new_slave->last_link_up = jiffies; 1632 netdev_dbg(bond_dev, "Initial state of slave_dev is BOND_LINK_%s\n", 1633 new_slave->link == BOND_LINK_DOWN ? "DOWN" : 1634 (new_slave->link == BOND_LINK_UP ? "UP" : "BACK")); 1635 1636 if (bond_uses_primary(bond) && bond->params.primary[0]) { 1637 /* if there is a primary slave, remember it */ 1638 if (strcmp(bond->params.primary, new_slave->dev->name) == 0) { 1639 rcu_assign_pointer(bond->primary_slave, new_slave); 1640 bond->force_primary = true; 1641 } 1642 } 1643 1644 switch (BOND_MODE(bond)) { 1645 case BOND_MODE_ACTIVEBACKUP: 1646 bond_set_slave_inactive_flags(new_slave, 1647 BOND_SLAVE_NOTIFY_NOW); 1648 break; 1649 case BOND_MODE_8023AD: 1650 /* in 802.3ad mode, the internal mechanism 1651 * will activate the slaves in the selected 1652 * aggregator 1653 */ 1654 bond_set_slave_inactive_flags(new_slave, BOND_SLAVE_NOTIFY_NOW); 1655 /* if this is the first slave */ 1656 if (!prev_slave) { 1657 SLAVE_AD_INFO(new_slave)->id = 1; 1658 /* Initialize AD with the number of times that the AD timer is called in 1 second 1659 * can be called only after the mac address of the bond is set 1660 */ 1661 bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL); 1662 } else { 1663 SLAVE_AD_INFO(new_slave)->id = 1664 SLAVE_AD_INFO(prev_slave)->id + 1; 1665 } 1666 1667 bond_3ad_bind_slave(new_slave); 1668 break; 1669 case BOND_MODE_TLB: 1670 case BOND_MODE_ALB: 1671 bond_set_active_slave(new_slave); 1672 bond_set_slave_inactive_flags(new_slave, BOND_SLAVE_NOTIFY_NOW); 1673 break; 1674 default: 1675 netdev_dbg(bond_dev, "This slave is always active in trunk mode\n"); 1676 1677 /* always active in trunk mode */ 1678 bond_set_active_slave(new_slave); 1679 1680 /* In trunking mode there is little meaning to curr_active_slave 1681 * anyway (it holds no special properties of the bond device), 1682 * so we can change it without calling change_active_interface() 1683 */ 1684 if (!rcu_access_pointer(bond->curr_active_slave) && 1685 new_slave->link == BOND_LINK_UP) 1686 rcu_assign_pointer(bond->curr_active_slave, new_slave); 1687 1688 break; 1689 } /* switch(bond_mode) */ 1690 1691 #ifdef CONFIG_NET_POLL_CONTROLLER 1692 if (bond->dev->npinfo) { 1693 if (slave_enable_netpoll(new_slave)) { 1694 netdev_info(bond_dev, "master_dev is using netpoll, but new slave device does not support netpoll\n"); 1695 res = -EBUSY; 1696 goto err_detach; 1697 } 1698 } 1699 #endif 1700 1701 if (!(bond_dev->features & NETIF_F_LRO)) 1702 dev_disable_lro(slave_dev); 1703 1704 res = netdev_rx_handler_register(slave_dev, bond_handle_frame, 1705 new_slave); 1706 if (res) { 1707 netdev_dbg(bond_dev, "Error %d calling netdev_rx_handler_register\n", res); 1708 goto err_detach; 1709 } 1710 1711 res = bond_master_upper_dev_link(bond, new_slave, extack); 1712 if (res) { 1713 netdev_dbg(bond_dev, "Error %d calling bond_master_upper_dev_link\n", res); 1714 goto err_unregister; 1715 } 1716 1717 res = bond_sysfs_slave_add(new_slave); 1718 if (res) { 1719 netdev_dbg(bond_dev, "Error %d calling bond_sysfs_slave_add\n", res); 1720 goto err_upper_unlink; 1721 } 1722 1723 bond->nest_level = dev_get_nest_level(bond_dev) + 1; 1724 1725 /* If the mode uses primary, then the following is handled by 1726 * bond_change_active_slave(). 1727 */ 1728 if (!bond_uses_primary(bond)) { 1729 /* set promiscuity level to new slave */ 1730 if (bond_dev->flags & IFF_PROMISC) { 1731 res = dev_set_promiscuity(slave_dev, 1); 1732 if (res) 1733 goto err_sysfs_del; 1734 } 1735 1736 /* set allmulti level to new slave */ 1737 if (bond_dev->flags & IFF_ALLMULTI) { 1738 res = dev_set_allmulti(slave_dev, 1); 1739 if (res) { 1740 if (bond_dev->flags & IFF_PROMISC) 1741 dev_set_promiscuity(slave_dev, -1); 1742 goto err_sysfs_del; 1743 } 1744 } 1745 1746 netif_addr_lock_bh(bond_dev); 1747 dev_mc_sync_multiple(slave_dev, bond_dev); 1748 dev_uc_sync_multiple(slave_dev, bond_dev); 1749 netif_addr_unlock_bh(bond_dev); 1750 1751 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 1752 /* add lacpdu mc addr to mc list */ 1753 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR; 1754 1755 dev_mc_add(slave_dev, lacpdu_multicast); 1756 } 1757 } 1758 1759 bond->slave_cnt++; 1760 bond_compute_features(bond); 1761 bond_set_carrier(bond); 1762 1763 if (bond_uses_primary(bond)) { 1764 block_netpoll_tx(); 1765 bond_select_active_slave(bond); 1766 unblock_netpoll_tx(); 1767 } 1768 1769 if (bond_mode_can_use_xmit_hash(bond)) 1770 bond_update_slave_arr(bond, NULL); 1771 1772 1773 netdev_info(bond_dev, "Enslaving %s as %s interface with %s link\n", 1774 slave_dev->name, 1775 bond_is_active_slave(new_slave) ? "an active" : "a backup", 1776 new_slave->link != BOND_LINK_DOWN ? "an up" : "a down"); 1777 1778 /* enslave is successful */ 1779 bond_queue_slave_event(new_slave); 1780 return 0; 1781 1782 /* Undo stages on error */ 1783 err_sysfs_del: 1784 bond_sysfs_slave_del(new_slave); 1785 1786 err_upper_unlink: 1787 bond_upper_dev_unlink(bond, new_slave); 1788 1789 err_unregister: 1790 netdev_rx_handler_unregister(slave_dev); 1791 1792 err_detach: 1793 vlan_vids_del_by_dev(slave_dev, bond_dev); 1794 if (rcu_access_pointer(bond->primary_slave) == new_slave) 1795 RCU_INIT_POINTER(bond->primary_slave, NULL); 1796 if (rcu_access_pointer(bond->curr_active_slave) == new_slave) { 1797 block_netpoll_tx(); 1798 bond_change_active_slave(bond, NULL); 1799 bond_select_active_slave(bond); 1800 unblock_netpoll_tx(); 1801 } 1802 /* either primary_slave or curr_active_slave might've changed */ 1803 synchronize_rcu(); 1804 slave_disable_netpoll(new_slave); 1805 1806 err_close: 1807 slave_dev->priv_flags &= ~IFF_BONDING; 1808 dev_close(slave_dev); 1809 1810 err_restore_mac: 1811 slave_dev->flags &= ~IFF_SLAVE; 1812 if (!bond->params.fail_over_mac || 1813 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 1814 /* XXX TODO - fom follow mode needs to change master's 1815 * MAC if this slave's MAC is in use by the bond, or at 1816 * least print a warning. 1817 */ 1818 bond_hw_addr_copy(ss.__data, new_slave->perm_hwaddr, 1819 new_slave->dev->addr_len); 1820 ss.ss_family = slave_dev->type; 1821 dev_set_mac_address(slave_dev, (struct sockaddr *)&ss); 1822 } 1823 1824 err_restore_mtu: 1825 dev_set_mtu(slave_dev, new_slave->original_mtu); 1826 1827 err_free: 1828 bond_free_slave(new_slave); 1829 1830 err_undo_flags: 1831 /* Enslave of first slave has failed and we need to fix master's mac */ 1832 if (!bond_has_slaves(bond)) { 1833 if (ether_addr_equal_64bits(bond_dev->dev_addr, 1834 slave_dev->dev_addr)) 1835 eth_hw_addr_random(bond_dev); 1836 if (bond_dev->type != ARPHRD_ETHER) { 1837 dev_close(bond_dev); 1838 ether_setup(bond_dev); 1839 bond_dev->flags |= IFF_MASTER; 1840 bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1841 } 1842 } 1843 1844 return res; 1845 } 1846 1847 /* Try to release the slave device <slave> from the bond device <master> 1848 * It is legal to access curr_active_slave without a lock because all the function 1849 * is RTNL-locked. If "all" is true it means that the function is being called 1850 * while destroying a bond interface and all slaves are being released. 1851 * 1852 * The rules for slave state should be: 1853 * for Active/Backup: 1854 * Active stays on all backups go down 1855 * for Bonded connections: 1856 * The first up interface should be left on and all others downed. 1857 */ 1858 static int __bond_release_one(struct net_device *bond_dev, 1859 struct net_device *slave_dev, 1860 bool all, bool unregister) 1861 { 1862 struct bonding *bond = netdev_priv(bond_dev); 1863 struct slave *slave, *oldcurrent; 1864 struct sockaddr_storage ss; 1865 int old_flags = bond_dev->flags; 1866 netdev_features_t old_features = bond_dev->features; 1867 1868 /* slave is not a slave or master is not master of this slave */ 1869 if (!(slave_dev->flags & IFF_SLAVE) || 1870 !netdev_has_upper_dev(slave_dev, bond_dev)) { 1871 netdev_dbg(bond_dev, "cannot release %s\n", 1872 slave_dev->name); 1873 return -EINVAL; 1874 } 1875 1876 block_netpoll_tx(); 1877 1878 slave = bond_get_slave_by_dev(bond, slave_dev); 1879 if (!slave) { 1880 /* not a slave of this bond */ 1881 netdev_info(bond_dev, "%s not enslaved\n", 1882 slave_dev->name); 1883 unblock_netpoll_tx(); 1884 return -EINVAL; 1885 } 1886 1887 bond_set_slave_inactive_flags(slave, BOND_SLAVE_NOTIFY_NOW); 1888 1889 bond_sysfs_slave_del(slave); 1890 1891 /* recompute stats just before removing the slave */ 1892 bond_get_stats(bond->dev, &bond->bond_stats); 1893 1894 bond_upper_dev_unlink(bond, slave); 1895 /* unregister rx_handler early so bond_handle_frame wouldn't be called 1896 * for this slave anymore. 1897 */ 1898 netdev_rx_handler_unregister(slave_dev); 1899 1900 if (BOND_MODE(bond) == BOND_MODE_8023AD) 1901 bond_3ad_unbind_slave(slave); 1902 1903 if (bond_mode_can_use_xmit_hash(bond)) 1904 bond_update_slave_arr(bond, slave); 1905 1906 netdev_info(bond_dev, "Releasing %s interface %s\n", 1907 bond_is_active_slave(slave) ? "active" : "backup", 1908 slave_dev->name); 1909 1910 oldcurrent = rcu_access_pointer(bond->curr_active_slave); 1911 1912 RCU_INIT_POINTER(bond->current_arp_slave, NULL); 1913 1914 if (!all && (!bond->params.fail_over_mac || 1915 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP)) { 1916 if (ether_addr_equal_64bits(bond_dev->dev_addr, slave->perm_hwaddr) && 1917 bond_has_slaves(bond)) 1918 netdev_warn(bond_dev, "the permanent HWaddr of %s - %pM - is still in use by %s - set the HWaddr of %s to a different address to avoid conflicts\n", 1919 slave_dev->name, slave->perm_hwaddr, 1920 bond_dev->name, slave_dev->name); 1921 } 1922 1923 if (rtnl_dereference(bond->primary_slave) == slave) 1924 RCU_INIT_POINTER(bond->primary_slave, NULL); 1925 1926 if (oldcurrent == slave) 1927 bond_change_active_slave(bond, NULL); 1928 1929 if (bond_is_lb(bond)) { 1930 /* Must be called only after the slave has been 1931 * detached from the list and the curr_active_slave 1932 * has been cleared (if our_slave == old_current), 1933 * but before a new active slave is selected. 1934 */ 1935 bond_alb_deinit_slave(bond, slave); 1936 } 1937 1938 if (all) { 1939 RCU_INIT_POINTER(bond->curr_active_slave, NULL); 1940 } else if (oldcurrent == slave) { 1941 /* Note that we hold RTNL over this sequence, so there 1942 * is no concern that another slave add/remove event 1943 * will interfere. 1944 */ 1945 bond_select_active_slave(bond); 1946 } 1947 1948 if (!bond_has_slaves(bond)) { 1949 bond_set_carrier(bond); 1950 eth_hw_addr_random(bond_dev); 1951 } 1952 1953 unblock_netpoll_tx(); 1954 synchronize_rcu(); 1955 bond->slave_cnt--; 1956 1957 if (!bond_has_slaves(bond)) { 1958 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev); 1959 call_netdevice_notifiers(NETDEV_RELEASE, bond->dev); 1960 } 1961 1962 bond_compute_features(bond); 1963 if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) && 1964 (old_features & NETIF_F_VLAN_CHALLENGED)) 1965 netdev_info(bond_dev, "last VLAN challenged slave %s left bond %s - VLAN blocking is removed\n", 1966 slave_dev->name, bond_dev->name); 1967 1968 vlan_vids_del_by_dev(slave_dev, bond_dev); 1969 1970 /* If the mode uses primary, then this case was handled above by 1971 * bond_change_active_slave(..., NULL) 1972 */ 1973 if (!bond_uses_primary(bond)) { 1974 /* unset promiscuity level from slave 1975 * NOTE: The NETDEV_CHANGEADDR call above may change the value 1976 * of the IFF_PROMISC flag in the bond_dev, but we need the 1977 * value of that flag before that change, as that was the value 1978 * when this slave was attached, so we cache at the start of the 1979 * function and use it here. Same goes for ALLMULTI below 1980 */ 1981 if (old_flags & IFF_PROMISC) 1982 dev_set_promiscuity(slave_dev, -1); 1983 1984 /* unset allmulti level from slave */ 1985 if (old_flags & IFF_ALLMULTI) 1986 dev_set_allmulti(slave_dev, -1); 1987 1988 bond_hw_addr_flush(bond_dev, slave_dev); 1989 } 1990 1991 slave_disable_netpoll(slave); 1992 1993 /* close slave before restoring its mac address */ 1994 dev_close(slave_dev); 1995 1996 if (bond->params.fail_over_mac != BOND_FOM_ACTIVE || 1997 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 1998 /* restore original ("permanent") mac address */ 1999 bond_hw_addr_copy(ss.__data, slave->perm_hwaddr, 2000 slave->dev->addr_len); 2001 ss.ss_family = slave_dev->type; 2002 dev_set_mac_address(slave_dev, (struct sockaddr *)&ss); 2003 } 2004 2005 if (unregister) 2006 __dev_set_mtu(slave_dev, slave->original_mtu); 2007 else 2008 dev_set_mtu(slave_dev, slave->original_mtu); 2009 2010 slave_dev->priv_flags &= ~IFF_BONDING; 2011 2012 bond_free_slave(slave); 2013 2014 return 0; 2015 } 2016 2017 /* A wrapper used because of ndo_del_link */ 2018 int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) 2019 { 2020 return __bond_release_one(bond_dev, slave_dev, false, false); 2021 } 2022 2023 /* First release a slave and then destroy the bond if no more slaves are left. 2024 * Must be under rtnl_lock when this function is called. 2025 */ 2026 static int bond_release_and_destroy(struct net_device *bond_dev, 2027 struct net_device *slave_dev) 2028 { 2029 struct bonding *bond = netdev_priv(bond_dev); 2030 int ret; 2031 2032 ret = __bond_release_one(bond_dev, slave_dev, false, true); 2033 if (ret == 0 && !bond_has_slaves(bond)) { 2034 bond_dev->priv_flags |= IFF_DISABLE_NETPOLL; 2035 netdev_info(bond_dev, "Destroying bond %s\n", 2036 bond_dev->name); 2037 bond_remove_proc_entry(bond); 2038 unregister_netdevice(bond_dev); 2039 } 2040 return ret; 2041 } 2042 2043 static void bond_info_query(struct net_device *bond_dev, struct ifbond *info) 2044 { 2045 struct bonding *bond = netdev_priv(bond_dev); 2046 bond_fill_ifbond(bond, info); 2047 } 2048 2049 static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info) 2050 { 2051 struct bonding *bond = netdev_priv(bond_dev); 2052 struct list_head *iter; 2053 int i = 0, res = -ENODEV; 2054 struct slave *slave; 2055 2056 bond_for_each_slave(bond, slave, iter) { 2057 if (i++ == (int)info->slave_id) { 2058 res = 0; 2059 bond_fill_ifslave(slave, info); 2060 break; 2061 } 2062 } 2063 2064 return res; 2065 } 2066 2067 /*-------------------------------- Monitoring -------------------------------*/ 2068 2069 /* called with rcu_read_lock() */ 2070 static int bond_miimon_inspect(struct bonding *bond) 2071 { 2072 int link_state, commit = 0; 2073 struct list_head *iter; 2074 struct slave *slave; 2075 bool ignore_updelay; 2076 2077 ignore_updelay = !rcu_dereference(bond->curr_active_slave); 2078 2079 bond_for_each_slave_rcu(bond, slave, iter) { 2080 slave->new_link = BOND_LINK_NOCHANGE; 2081 slave->link_new_state = slave->link; 2082 2083 link_state = bond_check_dev_link(bond, slave->dev, 0); 2084 2085 switch (slave->link) { 2086 case BOND_LINK_UP: 2087 if (link_state) 2088 continue; 2089 2090 bond_propose_link_state(slave, BOND_LINK_FAIL); 2091 commit++; 2092 slave->delay = bond->params.downdelay; 2093 if (slave->delay) { 2094 netdev_info(bond->dev, "link status down for %sinterface %s, disabling it in %d ms\n", 2095 (BOND_MODE(bond) == 2096 BOND_MODE_ACTIVEBACKUP) ? 2097 (bond_is_active_slave(slave) ? 2098 "active " : "backup ") : "", 2099 slave->dev->name, 2100 bond->params.downdelay * bond->params.miimon); 2101 } 2102 /*FALLTHRU*/ 2103 case BOND_LINK_FAIL: 2104 if (link_state) { 2105 /* recovered before downdelay expired */ 2106 bond_propose_link_state(slave, BOND_LINK_UP); 2107 slave->last_link_up = jiffies; 2108 netdev_info(bond->dev, "link status up again after %d ms for interface %s\n", 2109 (bond->params.downdelay - slave->delay) * 2110 bond->params.miimon, 2111 slave->dev->name); 2112 commit++; 2113 continue; 2114 } 2115 2116 if (slave->delay <= 0) { 2117 slave->new_link = BOND_LINK_DOWN; 2118 commit++; 2119 continue; 2120 } 2121 2122 slave->delay--; 2123 break; 2124 2125 case BOND_LINK_DOWN: 2126 if (!link_state) 2127 continue; 2128 2129 bond_propose_link_state(slave, BOND_LINK_BACK); 2130 commit++; 2131 slave->delay = bond->params.updelay; 2132 2133 if (slave->delay) { 2134 netdev_info(bond->dev, "link status up for interface %s, enabling it in %d ms\n", 2135 slave->dev->name, 2136 ignore_updelay ? 0 : 2137 bond->params.updelay * 2138 bond->params.miimon); 2139 } 2140 /*FALLTHRU*/ 2141 case BOND_LINK_BACK: 2142 if (!link_state) { 2143 bond_propose_link_state(slave, BOND_LINK_DOWN); 2144 netdev_info(bond->dev, "link status down again after %d ms for interface %s\n", 2145 (bond->params.updelay - slave->delay) * 2146 bond->params.miimon, 2147 slave->dev->name); 2148 commit++; 2149 continue; 2150 } 2151 2152 if (ignore_updelay) 2153 slave->delay = 0; 2154 2155 if (slave->delay <= 0) { 2156 slave->new_link = BOND_LINK_UP; 2157 commit++; 2158 ignore_updelay = false; 2159 continue; 2160 } 2161 2162 slave->delay--; 2163 break; 2164 } 2165 } 2166 2167 return commit; 2168 } 2169 2170 static void bond_miimon_link_change(struct bonding *bond, 2171 struct slave *slave, 2172 char link) 2173 { 2174 switch (BOND_MODE(bond)) { 2175 case BOND_MODE_8023AD: 2176 bond_3ad_handle_link_change(slave, link); 2177 break; 2178 case BOND_MODE_TLB: 2179 case BOND_MODE_ALB: 2180 bond_alb_handle_link_change(bond, slave, link); 2181 break; 2182 case BOND_MODE_XOR: 2183 bond_update_slave_arr(bond, NULL); 2184 break; 2185 } 2186 } 2187 2188 static void bond_miimon_commit(struct bonding *bond) 2189 { 2190 struct list_head *iter; 2191 struct slave *slave, *primary; 2192 2193 bond_for_each_slave(bond, slave, iter) { 2194 switch (slave->new_link) { 2195 case BOND_LINK_NOCHANGE: 2196 continue; 2197 2198 case BOND_LINK_UP: 2199 if (bond_update_speed_duplex(slave) && 2200 bond_needs_speed_duplex(bond)) { 2201 slave->link = BOND_LINK_DOWN; 2202 if (net_ratelimit()) 2203 netdev_warn(bond->dev, 2204 "failed to get link speed/duplex for %s\n", 2205 slave->dev->name); 2206 continue; 2207 } 2208 bond_set_slave_link_state(slave, BOND_LINK_UP, 2209 BOND_SLAVE_NOTIFY_NOW); 2210 slave->last_link_up = jiffies; 2211 2212 primary = rtnl_dereference(bond->primary_slave); 2213 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 2214 /* prevent it from being the active one */ 2215 bond_set_backup_slave(slave); 2216 } else if (BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 2217 /* make it immediately active */ 2218 bond_set_active_slave(slave); 2219 } else if (slave != primary) { 2220 /* prevent it from being the active one */ 2221 bond_set_backup_slave(slave); 2222 } 2223 2224 netdev_info(bond->dev, "link status definitely up for interface %s, %u Mbps %s duplex\n", 2225 slave->dev->name, 2226 slave->speed == SPEED_UNKNOWN ? 0 : slave->speed, 2227 slave->duplex ? "full" : "half"); 2228 2229 bond_miimon_link_change(bond, slave, BOND_LINK_UP); 2230 2231 if (!bond->curr_active_slave || slave == primary) 2232 goto do_failover; 2233 2234 continue; 2235 2236 case BOND_LINK_DOWN: 2237 if (slave->link_failure_count < UINT_MAX) 2238 slave->link_failure_count++; 2239 2240 bond_set_slave_link_state(slave, BOND_LINK_DOWN, 2241 BOND_SLAVE_NOTIFY_NOW); 2242 2243 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP || 2244 BOND_MODE(bond) == BOND_MODE_8023AD) 2245 bond_set_slave_inactive_flags(slave, 2246 BOND_SLAVE_NOTIFY_NOW); 2247 2248 netdev_info(bond->dev, "link status definitely down for interface %s, disabling it\n", 2249 slave->dev->name); 2250 2251 bond_miimon_link_change(bond, slave, BOND_LINK_DOWN); 2252 2253 if (slave == rcu_access_pointer(bond->curr_active_slave)) 2254 goto do_failover; 2255 2256 continue; 2257 2258 default: 2259 netdev_err(bond->dev, "invalid new link %d on slave %s\n", 2260 slave->new_link, slave->dev->name); 2261 slave->new_link = BOND_LINK_NOCHANGE; 2262 2263 continue; 2264 } 2265 2266 do_failover: 2267 block_netpoll_tx(); 2268 bond_select_active_slave(bond); 2269 unblock_netpoll_tx(); 2270 } 2271 2272 bond_set_carrier(bond); 2273 } 2274 2275 /* bond_mii_monitor 2276 * 2277 * Really a wrapper that splits the mii monitor into two phases: an 2278 * inspection, then (if inspection indicates something needs to be done) 2279 * an acquisition of appropriate locks followed by a commit phase to 2280 * implement whatever link state changes are indicated. 2281 */ 2282 static void bond_mii_monitor(struct work_struct *work) 2283 { 2284 struct bonding *bond = container_of(work, struct bonding, 2285 mii_work.work); 2286 bool should_notify_peers = false; 2287 unsigned long delay; 2288 struct slave *slave; 2289 struct list_head *iter; 2290 2291 delay = msecs_to_jiffies(bond->params.miimon); 2292 2293 if (!bond_has_slaves(bond)) 2294 goto re_arm; 2295 2296 rcu_read_lock(); 2297 2298 should_notify_peers = bond_should_notify_peers(bond); 2299 2300 if (bond_miimon_inspect(bond)) { 2301 rcu_read_unlock(); 2302 2303 /* Race avoidance with bond_close cancel of workqueue */ 2304 if (!rtnl_trylock()) { 2305 delay = 1; 2306 should_notify_peers = false; 2307 goto re_arm; 2308 } 2309 2310 bond_for_each_slave(bond, slave, iter) { 2311 bond_commit_link_state(slave, BOND_SLAVE_NOTIFY_LATER); 2312 } 2313 bond_miimon_commit(bond); 2314 2315 rtnl_unlock(); /* might sleep, hold no other locks */ 2316 } else 2317 rcu_read_unlock(); 2318 2319 re_arm: 2320 if (bond->params.miimon) 2321 queue_delayed_work(bond->wq, &bond->mii_work, delay); 2322 2323 if (should_notify_peers) { 2324 if (!rtnl_trylock()) 2325 return; 2326 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev); 2327 rtnl_unlock(); 2328 } 2329 } 2330 2331 static int bond_upper_dev_walk(struct net_device *upper, void *data) 2332 { 2333 __be32 ip = *((__be32 *)data); 2334 2335 return ip == bond_confirm_addr(upper, 0, ip); 2336 } 2337 2338 static bool bond_has_this_ip(struct bonding *bond, __be32 ip) 2339 { 2340 bool ret = false; 2341 2342 if (ip == bond_confirm_addr(bond->dev, 0, ip)) 2343 return true; 2344 2345 rcu_read_lock(); 2346 if (netdev_walk_all_upper_dev_rcu(bond->dev, bond_upper_dev_walk, &ip)) 2347 ret = true; 2348 rcu_read_unlock(); 2349 2350 return ret; 2351 } 2352 2353 /* We go to the (large) trouble of VLAN tagging ARP frames because 2354 * switches in VLAN mode (especially if ports are configured as 2355 * "native" to a VLAN) might not pass non-tagged frames. 2356 */ 2357 static void bond_arp_send(struct net_device *slave_dev, int arp_op, 2358 __be32 dest_ip, __be32 src_ip, 2359 struct bond_vlan_tag *tags) 2360 { 2361 struct sk_buff *skb; 2362 struct bond_vlan_tag *outer_tag = tags; 2363 2364 netdev_dbg(slave_dev, "arp %d on slave %s: dst %pI4 src %pI4\n", 2365 arp_op, slave_dev->name, &dest_ip, &src_ip); 2366 2367 skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip, 2368 NULL, slave_dev->dev_addr, NULL); 2369 2370 if (!skb) { 2371 net_err_ratelimited("ARP packet allocation failed\n"); 2372 return; 2373 } 2374 2375 if (!tags || tags->vlan_proto == VLAN_N_VID) 2376 goto xmit; 2377 2378 tags++; 2379 2380 /* Go through all the tags backwards and add them to the packet */ 2381 while (tags->vlan_proto != VLAN_N_VID) { 2382 if (!tags->vlan_id) { 2383 tags++; 2384 continue; 2385 } 2386 2387 netdev_dbg(slave_dev, "inner tag: proto %X vid %X\n", 2388 ntohs(outer_tag->vlan_proto), tags->vlan_id); 2389 skb = vlan_insert_tag_set_proto(skb, tags->vlan_proto, 2390 tags->vlan_id); 2391 if (!skb) { 2392 net_err_ratelimited("failed to insert inner VLAN tag\n"); 2393 return; 2394 } 2395 2396 tags++; 2397 } 2398 /* Set the outer tag */ 2399 if (outer_tag->vlan_id) { 2400 netdev_dbg(slave_dev, "outer tag: proto %X vid %X\n", 2401 ntohs(outer_tag->vlan_proto), outer_tag->vlan_id); 2402 __vlan_hwaccel_put_tag(skb, outer_tag->vlan_proto, 2403 outer_tag->vlan_id); 2404 } 2405 2406 xmit: 2407 arp_xmit(skb); 2408 } 2409 2410 /* Validate the device path between the @start_dev and the @end_dev. 2411 * The path is valid if the @end_dev is reachable through device 2412 * stacking. 2413 * When the path is validated, collect any vlan information in the 2414 * path. 2415 */ 2416 struct bond_vlan_tag *bond_verify_device_path(struct net_device *start_dev, 2417 struct net_device *end_dev, 2418 int level) 2419 { 2420 struct bond_vlan_tag *tags; 2421 struct net_device *upper; 2422 struct list_head *iter; 2423 2424 if (start_dev == end_dev) { 2425 tags = kcalloc(level + 1, sizeof(*tags), GFP_ATOMIC); 2426 if (!tags) 2427 return ERR_PTR(-ENOMEM); 2428 tags[level].vlan_proto = VLAN_N_VID; 2429 return tags; 2430 } 2431 2432 netdev_for_each_upper_dev_rcu(start_dev, upper, iter) { 2433 tags = bond_verify_device_path(upper, end_dev, level + 1); 2434 if (IS_ERR_OR_NULL(tags)) { 2435 if (IS_ERR(tags)) 2436 return tags; 2437 continue; 2438 } 2439 if (is_vlan_dev(upper)) { 2440 tags[level].vlan_proto = vlan_dev_vlan_proto(upper); 2441 tags[level].vlan_id = vlan_dev_vlan_id(upper); 2442 } 2443 2444 return tags; 2445 } 2446 2447 return NULL; 2448 } 2449 2450 static void bond_arp_send_all(struct bonding *bond, struct slave *slave) 2451 { 2452 struct rtable *rt; 2453 struct bond_vlan_tag *tags; 2454 __be32 *targets = bond->params.arp_targets, addr; 2455 int i; 2456 2457 for (i = 0; i < BOND_MAX_ARP_TARGETS && targets[i]; i++) { 2458 netdev_dbg(bond->dev, "basa: target %pI4\n", &targets[i]); 2459 tags = NULL; 2460 2461 /* Find out through which dev should the packet go */ 2462 rt = ip_route_output(dev_net(bond->dev), targets[i], 0, 2463 RTO_ONLINK, 0); 2464 if (IS_ERR(rt)) { 2465 /* there's no route to target - try to send arp 2466 * probe to generate any traffic (arp_validate=0) 2467 */ 2468 if (bond->params.arp_validate) 2469 net_warn_ratelimited("%s: no route to arp_ip_target %pI4 and arp_validate is set\n", 2470 bond->dev->name, 2471 &targets[i]); 2472 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i], 2473 0, tags); 2474 continue; 2475 } 2476 2477 /* bond device itself */ 2478 if (rt->dst.dev == bond->dev) 2479 goto found; 2480 2481 rcu_read_lock(); 2482 tags = bond_verify_device_path(bond->dev, rt->dst.dev, 0); 2483 rcu_read_unlock(); 2484 2485 if (!IS_ERR_OR_NULL(tags)) 2486 goto found; 2487 2488 /* Not our device - skip */ 2489 netdev_dbg(bond->dev, "no path to arp_ip_target %pI4 via rt.dev %s\n", 2490 &targets[i], rt->dst.dev ? rt->dst.dev->name : "NULL"); 2491 2492 ip_rt_put(rt); 2493 continue; 2494 2495 found: 2496 addr = bond_confirm_addr(rt->dst.dev, targets[i], 0); 2497 ip_rt_put(rt); 2498 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i], 2499 addr, tags); 2500 kfree(tags); 2501 } 2502 } 2503 2504 static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip) 2505 { 2506 int i; 2507 2508 if (!sip || !bond_has_this_ip(bond, tip)) { 2509 netdev_dbg(bond->dev, "bva: sip %pI4 tip %pI4 not found\n", 2510 &sip, &tip); 2511 return; 2512 } 2513 2514 i = bond_get_targets_ip(bond->params.arp_targets, sip); 2515 if (i == -1) { 2516 netdev_dbg(bond->dev, "bva: sip %pI4 not found in targets\n", 2517 &sip); 2518 return; 2519 } 2520 slave->last_rx = jiffies; 2521 slave->target_last_arp_rx[i] = jiffies; 2522 } 2523 2524 int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond, 2525 struct slave *slave) 2526 { 2527 struct arphdr *arp = (struct arphdr *)skb->data; 2528 struct slave *curr_active_slave, *curr_arp_slave; 2529 unsigned char *arp_ptr; 2530 __be32 sip, tip; 2531 int is_arp = skb->protocol == __cpu_to_be16(ETH_P_ARP); 2532 unsigned int alen; 2533 2534 if (!slave_do_arp_validate(bond, slave)) { 2535 if ((slave_do_arp_validate_only(bond) && is_arp) || 2536 !slave_do_arp_validate_only(bond)) 2537 slave->last_rx = jiffies; 2538 return RX_HANDLER_ANOTHER; 2539 } else if (!is_arp) { 2540 return RX_HANDLER_ANOTHER; 2541 } 2542 2543 alen = arp_hdr_len(bond->dev); 2544 2545 netdev_dbg(bond->dev, "bond_arp_rcv: skb->dev %s\n", 2546 skb->dev->name); 2547 2548 if (alen > skb_headlen(skb)) { 2549 arp = kmalloc(alen, GFP_ATOMIC); 2550 if (!arp) 2551 goto out_unlock; 2552 if (skb_copy_bits(skb, 0, arp, alen) < 0) 2553 goto out_unlock; 2554 } 2555 2556 if (arp->ar_hln != bond->dev->addr_len || 2557 skb->pkt_type == PACKET_OTHERHOST || 2558 skb->pkt_type == PACKET_LOOPBACK || 2559 arp->ar_hrd != htons(ARPHRD_ETHER) || 2560 arp->ar_pro != htons(ETH_P_IP) || 2561 arp->ar_pln != 4) 2562 goto out_unlock; 2563 2564 arp_ptr = (unsigned char *)(arp + 1); 2565 arp_ptr += bond->dev->addr_len; 2566 memcpy(&sip, arp_ptr, 4); 2567 arp_ptr += 4 + bond->dev->addr_len; 2568 memcpy(&tip, arp_ptr, 4); 2569 2570 netdev_dbg(bond->dev, "bond_arp_rcv: %s/%d av %d sv %d sip %pI4 tip %pI4\n", 2571 slave->dev->name, bond_slave_state(slave), 2572 bond->params.arp_validate, slave_do_arp_validate(bond, slave), 2573 &sip, &tip); 2574 2575 curr_active_slave = rcu_dereference(bond->curr_active_slave); 2576 curr_arp_slave = rcu_dereference(bond->current_arp_slave); 2577 2578 /* We 'trust' the received ARP enough to validate it if: 2579 * 2580 * (a) the slave receiving the ARP is active (which includes the 2581 * current ARP slave, if any), or 2582 * 2583 * (b) the receiving slave isn't active, but there is a currently 2584 * active slave and it received valid arp reply(s) after it became 2585 * the currently active slave, or 2586 * 2587 * (c) there is an ARP slave that sent an ARP during the prior ARP 2588 * interval, and we receive an ARP reply on any slave. We accept 2589 * these because switch FDB update delays may deliver the ARP 2590 * reply to a slave other than the sender of the ARP request. 2591 * 2592 * Note: for (b), backup slaves are receiving the broadcast ARP 2593 * request, not a reply. This request passes from the sending 2594 * slave through the L2 switch(es) to the receiving slave. Since 2595 * this is checking the request, sip/tip are swapped for 2596 * validation. 2597 * 2598 * This is done to avoid endless looping when we can't reach the 2599 * arp_ip_target and fool ourselves with our own arp requests. 2600 */ 2601 if (bond_is_active_slave(slave)) 2602 bond_validate_arp(bond, slave, sip, tip); 2603 else if (curr_active_slave && 2604 time_after(slave_last_rx(bond, curr_active_slave), 2605 curr_active_slave->last_link_up)) 2606 bond_validate_arp(bond, slave, tip, sip); 2607 else if (curr_arp_slave && (arp->ar_op == htons(ARPOP_REPLY)) && 2608 bond_time_in_interval(bond, 2609 dev_trans_start(curr_arp_slave->dev), 1)) 2610 bond_validate_arp(bond, slave, sip, tip); 2611 2612 out_unlock: 2613 if (arp != (struct arphdr *)skb->data) 2614 kfree(arp); 2615 return RX_HANDLER_ANOTHER; 2616 } 2617 2618 /* function to verify if we're in the arp_interval timeslice, returns true if 2619 * (last_act - arp_interval) <= jiffies <= (last_act + mod * arp_interval + 2620 * arp_interval/2) . the arp_interval/2 is needed for really fast networks. 2621 */ 2622 static bool bond_time_in_interval(struct bonding *bond, unsigned long last_act, 2623 int mod) 2624 { 2625 int delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval); 2626 2627 return time_in_range(jiffies, 2628 last_act - delta_in_ticks, 2629 last_act + mod * delta_in_ticks + delta_in_ticks/2); 2630 } 2631 2632 /* This function is called regularly to monitor each slave's link 2633 * ensuring that traffic is being sent and received when arp monitoring 2634 * is used in load-balancing mode. if the adapter has been dormant, then an 2635 * arp is transmitted to generate traffic. see activebackup_arp_monitor for 2636 * arp monitoring in active backup mode. 2637 */ 2638 static void bond_loadbalance_arp_mon(struct bonding *bond) 2639 { 2640 struct slave *slave, *oldcurrent; 2641 struct list_head *iter; 2642 int do_failover = 0, slave_state_changed = 0; 2643 2644 if (!bond_has_slaves(bond)) 2645 goto re_arm; 2646 2647 rcu_read_lock(); 2648 2649 oldcurrent = rcu_dereference(bond->curr_active_slave); 2650 /* see if any of the previous devices are up now (i.e. they have 2651 * xmt and rcv traffic). the curr_active_slave does not come into 2652 * the picture unless it is null. also, slave->last_link_up is not 2653 * needed here because we send an arp on each slave and give a slave 2654 * as long as it needs to get the tx/rx within the delta. 2655 * TODO: what about up/down delay in arp mode? it wasn't here before 2656 * so it can wait 2657 */ 2658 bond_for_each_slave_rcu(bond, slave, iter) { 2659 unsigned long trans_start = dev_trans_start(slave->dev); 2660 2661 slave->new_link = BOND_LINK_NOCHANGE; 2662 2663 if (slave->link != BOND_LINK_UP) { 2664 if (bond_time_in_interval(bond, trans_start, 1) && 2665 bond_time_in_interval(bond, slave->last_rx, 1)) { 2666 2667 slave->new_link = BOND_LINK_UP; 2668 slave_state_changed = 1; 2669 2670 /* primary_slave has no meaning in round-robin 2671 * mode. the window of a slave being up and 2672 * curr_active_slave being null after enslaving 2673 * is closed. 2674 */ 2675 if (!oldcurrent) { 2676 netdev_info(bond->dev, "link status definitely up for interface %s\n", 2677 slave->dev->name); 2678 do_failover = 1; 2679 } else { 2680 netdev_info(bond->dev, "interface %s is now up\n", 2681 slave->dev->name); 2682 } 2683 } 2684 } else { 2685 /* slave->link == BOND_LINK_UP */ 2686 2687 /* not all switches will respond to an arp request 2688 * when the source ip is 0, so don't take the link down 2689 * if we don't know our ip yet 2690 */ 2691 if (!bond_time_in_interval(bond, trans_start, 2) || 2692 !bond_time_in_interval(bond, slave->last_rx, 2)) { 2693 2694 slave->new_link = BOND_LINK_DOWN; 2695 slave_state_changed = 1; 2696 2697 if (slave->link_failure_count < UINT_MAX) 2698 slave->link_failure_count++; 2699 2700 netdev_info(bond->dev, "interface %s is now down\n", 2701 slave->dev->name); 2702 2703 if (slave == oldcurrent) 2704 do_failover = 1; 2705 } 2706 } 2707 2708 /* note: if switch is in round-robin mode, all links 2709 * must tx arp to ensure all links rx an arp - otherwise 2710 * links may oscillate or not come up at all; if switch is 2711 * in something like xor mode, there is nothing we can 2712 * do - all replies will be rx'ed on same link causing slaves 2713 * to be unstable during low/no traffic periods 2714 */ 2715 if (bond_slave_is_up(slave)) 2716 bond_arp_send_all(bond, slave); 2717 } 2718 2719 rcu_read_unlock(); 2720 2721 if (do_failover || slave_state_changed) { 2722 if (!rtnl_trylock()) 2723 goto re_arm; 2724 2725 bond_for_each_slave(bond, slave, iter) { 2726 if (slave->new_link != BOND_LINK_NOCHANGE) 2727 slave->link = slave->new_link; 2728 } 2729 2730 if (slave_state_changed) { 2731 bond_slave_state_change(bond); 2732 if (BOND_MODE(bond) == BOND_MODE_XOR) 2733 bond_update_slave_arr(bond, NULL); 2734 } 2735 if (do_failover) { 2736 block_netpoll_tx(); 2737 bond_select_active_slave(bond); 2738 unblock_netpoll_tx(); 2739 } 2740 rtnl_unlock(); 2741 } 2742 2743 re_arm: 2744 if (bond->params.arp_interval) 2745 queue_delayed_work(bond->wq, &bond->arp_work, 2746 msecs_to_jiffies(bond->params.arp_interval)); 2747 } 2748 2749 /* Called to inspect slaves for active-backup mode ARP monitor link state 2750 * changes. Sets new_link in slaves to specify what action should take 2751 * place for the slave. Returns 0 if no changes are found, >0 if changes 2752 * to link states must be committed. 2753 * 2754 * Called with rcu_read_lock held. 2755 */ 2756 static int bond_ab_arp_inspect(struct bonding *bond) 2757 { 2758 unsigned long trans_start, last_rx; 2759 struct list_head *iter; 2760 struct slave *slave; 2761 int commit = 0; 2762 2763 bond_for_each_slave_rcu(bond, slave, iter) { 2764 slave->new_link = BOND_LINK_NOCHANGE; 2765 last_rx = slave_last_rx(bond, slave); 2766 2767 if (slave->link != BOND_LINK_UP) { 2768 if (bond_time_in_interval(bond, last_rx, 1)) { 2769 slave->new_link = BOND_LINK_UP; 2770 commit++; 2771 } 2772 continue; 2773 } 2774 2775 /* Give slaves 2*delta after being enslaved or made 2776 * active. This avoids bouncing, as the last receive 2777 * times need a full ARP monitor cycle to be updated. 2778 */ 2779 if (bond_time_in_interval(bond, slave->last_link_up, 2)) 2780 continue; 2781 2782 /* Backup slave is down if: 2783 * - No current_arp_slave AND 2784 * - more than 3*delta since last receive AND 2785 * - the bond has an IP address 2786 * 2787 * Note: a non-null current_arp_slave indicates 2788 * the curr_active_slave went down and we are 2789 * searching for a new one; under this condition 2790 * we only take the curr_active_slave down - this 2791 * gives each slave a chance to tx/rx traffic 2792 * before being taken out 2793 */ 2794 if (!bond_is_active_slave(slave) && 2795 !rcu_access_pointer(bond->current_arp_slave) && 2796 !bond_time_in_interval(bond, last_rx, 3)) { 2797 slave->new_link = BOND_LINK_DOWN; 2798 commit++; 2799 } 2800 2801 /* Active slave is down if: 2802 * - more than 2*delta since transmitting OR 2803 * - (more than 2*delta since receive AND 2804 * the bond has an IP address) 2805 */ 2806 trans_start = dev_trans_start(slave->dev); 2807 if (bond_is_active_slave(slave) && 2808 (!bond_time_in_interval(bond, trans_start, 2) || 2809 !bond_time_in_interval(bond, last_rx, 2))) { 2810 slave->new_link = BOND_LINK_DOWN; 2811 commit++; 2812 } 2813 } 2814 2815 return commit; 2816 } 2817 2818 /* Called to commit link state changes noted by inspection step of 2819 * active-backup mode ARP monitor. 2820 * 2821 * Called with RTNL hold. 2822 */ 2823 static void bond_ab_arp_commit(struct bonding *bond) 2824 { 2825 unsigned long trans_start; 2826 struct list_head *iter; 2827 struct slave *slave; 2828 2829 bond_for_each_slave(bond, slave, iter) { 2830 switch (slave->new_link) { 2831 case BOND_LINK_NOCHANGE: 2832 continue; 2833 2834 case BOND_LINK_UP: 2835 trans_start = dev_trans_start(slave->dev); 2836 if (rtnl_dereference(bond->curr_active_slave) != slave || 2837 (!rtnl_dereference(bond->curr_active_slave) && 2838 bond_time_in_interval(bond, trans_start, 1))) { 2839 struct slave *current_arp_slave; 2840 2841 current_arp_slave = rtnl_dereference(bond->current_arp_slave); 2842 bond_set_slave_link_state(slave, BOND_LINK_UP, 2843 BOND_SLAVE_NOTIFY_NOW); 2844 if (current_arp_slave) { 2845 bond_set_slave_inactive_flags( 2846 current_arp_slave, 2847 BOND_SLAVE_NOTIFY_NOW); 2848 RCU_INIT_POINTER(bond->current_arp_slave, NULL); 2849 } 2850 2851 netdev_info(bond->dev, "link status definitely up for interface %s\n", 2852 slave->dev->name); 2853 2854 if (!rtnl_dereference(bond->curr_active_slave) || 2855 slave == rtnl_dereference(bond->primary_slave)) 2856 goto do_failover; 2857 2858 } 2859 2860 continue; 2861 2862 case BOND_LINK_DOWN: 2863 if (slave->link_failure_count < UINT_MAX) 2864 slave->link_failure_count++; 2865 2866 bond_set_slave_link_state(slave, BOND_LINK_DOWN, 2867 BOND_SLAVE_NOTIFY_NOW); 2868 bond_set_slave_inactive_flags(slave, 2869 BOND_SLAVE_NOTIFY_NOW); 2870 2871 netdev_info(bond->dev, "link status definitely down for interface %s, disabling it\n", 2872 slave->dev->name); 2873 2874 if (slave == rtnl_dereference(bond->curr_active_slave)) { 2875 RCU_INIT_POINTER(bond->current_arp_slave, NULL); 2876 goto do_failover; 2877 } 2878 2879 continue; 2880 2881 default: 2882 netdev_err(bond->dev, "impossible: new_link %d on slave %s\n", 2883 slave->new_link, slave->dev->name); 2884 continue; 2885 } 2886 2887 do_failover: 2888 block_netpoll_tx(); 2889 bond_select_active_slave(bond); 2890 unblock_netpoll_tx(); 2891 } 2892 2893 bond_set_carrier(bond); 2894 } 2895 2896 /* Send ARP probes for active-backup mode ARP monitor. 2897 * 2898 * Called with rcu_read_lock held. 2899 */ 2900 static bool bond_ab_arp_probe(struct bonding *bond) 2901 { 2902 struct slave *slave, *before = NULL, *new_slave = NULL, 2903 *curr_arp_slave = rcu_dereference(bond->current_arp_slave), 2904 *curr_active_slave = rcu_dereference(bond->curr_active_slave); 2905 struct list_head *iter; 2906 bool found = false; 2907 bool should_notify_rtnl = BOND_SLAVE_NOTIFY_LATER; 2908 2909 if (curr_arp_slave && curr_active_slave) 2910 netdev_info(bond->dev, "PROBE: c_arp %s && cas %s BAD\n", 2911 curr_arp_slave->dev->name, 2912 curr_active_slave->dev->name); 2913 2914 if (curr_active_slave) { 2915 bond_arp_send_all(bond, curr_active_slave); 2916 return should_notify_rtnl; 2917 } 2918 2919 /* if we don't have a curr_active_slave, search for the next available 2920 * backup slave from the current_arp_slave and make it the candidate 2921 * for becoming the curr_active_slave 2922 */ 2923 2924 if (!curr_arp_slave) { 2925 curr_arp_slave = bond_first_slave_rcu(bond); 2926 if (!curr_arp_slave) 2927 return should_notify_rtnl; 2928 } 2929 2930 bond_set_slave_inactive_flags(curr_arp_slave, BOND_SLAVE_NOTIFY_LATER); 2931 2932 bond_for_each_slave_rcu(bond, slave, iter) { 2933 if (!found && !before && bond_slave_is_up(slave)) 2934 before = slave; 2935 2936 if (found && !new_slave && bond_slave_is_up(slave)) 2937 new_slave = slave; 2938 /* if the link state is up at this point, we 2939 * mark it down - this can happen if we have 2940 * simultaneous link failures and 2941 * reselect_active_interface doesn't make this 2942 * one the current slave so it is still marked 2943 * up when it is actually down 2944 */ 2945 if (!bond_slave_is_up(slave) && slave->link == BOND_LINK_UP) { 2946 bond_set_slave_link_state(slave, BOND_LINK_DOWN, 2947 BOND_SLAVE_NOTIFY_LATER); 2948 if (slave->link_failure_count < UINT_MAX) 2949 slave->link_failure_count++; 2950 2951 bond_set_slave_inactive_flags(slave, 2952 BOND_SLAVE_NOTIFY_LATER); 2953 2954 netdev_info(bond->dev, "backup interface %s is now down\n", 2955 slave->dev->name); 2956 } 2957 if (slave == curr_arp_slave) 2958 found = true; 2959 } 2960 2961 if (!new_slave && before) 2962 new_slave = before; 2963 2964 if (!new_slave) 2965 goto check_state; 2966 2967 bond_set_slave_link_state(new_slave, BOND_LINK_BACK, 2968 BOND_SLAVE_NOTIFY_LATER); 2969 bond_set_slave_active_flags(new_slave, BOND_SLAVE_NOTIFY_LATER); 2970 bond_arp_send_all(bond, new_slave); 2971 new_slave->last_link_up = jiffies; 2972 rcu_assign_pointer(bond->current_arp_slave, new_slave); 2973 2974 check_state: 2975 bond_for_each_slave_rcu(bond, slave, iter) { 2976 if (slave->should_notify || slave->should_notify_link) { 2977 should_notify_rtnl = BOND_SLAVE_NOTIFY_NOW; 2978 break; 2979 } 2980 } 2981 return should_notify_rtnl; 2982 } 2983 2984 static void bond_activebackup_arp_mon(struct bonding *bond) 2985 { 2986 bool should_notify_peers = false; 2987 bool should_notify_rtnl = false; 2988 int delta_in_ticks; 2989 2990 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval); 2991 2992 if (!bond_has_slaves(bond)) 2993 goto re_arm; 2994 2995 rcu_read_lock(); 2996 2997 should_notify_peers = bond_should_notify_peers(bond); 2998 2999 if (bond_ab_arp_inspect(bond)) { 3000 rcu_read_unlock(); 3001 3002 /* Race avoidance with bond_close flush of workqueue */ 3003 if (!rtnl_trylock()) { 3004 delta_in_ticks = 1; 3005 should_notify_peers = false; 3006 goto re_arm; 3007 } 3008 3009 bond_ab_arp_commit(bond); 3010 3011 rtnl_unlock(); 3012 rcu_read_lock(); 3013 } 3014 3015 should_notify_rtnl = bond_ab_arp_probe(bond); 3016 rcu_read_unlock(); 3017 3018 re_arm: 3019 if (bond->params.arp_interval) 3020 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks); 3021 3022 if (should_notify_peers || should_notify_rtnl) { 3023 if (!rtnl_trylock()) 3024 return; 3025 3026 if (should_notify_peers) 3027 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, 3028 bond->dev); 3029 if (should_notify_rtnl) { 3030 bond_slave_state_notify(bond); 3031 bond_slave_link_notify(bond); 3032 } 3033 3034 rtnl_unlock(); 3035 } 3036 } 3037 3038 static void bond_arp_monitor(struct work_struct *work) 3039 { 3040 struct bonding *bond = container_of(work, struct bonding, 3041 arp_work.work); 3042 3043 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) 3044 bond_activebackup_arp_mon(bond); 3045 else 3046 bond_loadbalance_arp_mon(bond); 3047 } 3048 3049 /*-------------------------- netdev event handling --------------------------*/ 3050 3051 /* Change device name */ 3052 static int bond_event_changename(struct bonding *bond) 3053 { 3054 bond_remove_proc_entry(bond); 3055 bond_create_proc_entry(bond); 3056 3057 bond_debug_reregister(bond); 3058 3059 return NOTIFY_DONE; 3060 } 3061 3062 static int bond_master_netdev_event(unsigned long event, 3063 struct net_device *bond_dev) 3064 { 3065 struct bonding *event_bond = netdev_priv(bond_dev); 3066 3067 switch (event) { 3068 case NETDEV_CHANGENAME: 3069 return bond_event_changename(event_bond); 3070 case NETDEV_UNREGISTER: 3071 bond_remove_proc_entry(event_bond); 3072 break; 3073 case NETDEV_REGISTER: 3074 bond_create_proc_entry(event_bond); 3075 break; 3076 case NETDEV_NOTIFY_PEERS: 3077 if (event_bond->send_peer_notif) 3078 event_bond->send_peer_notif--; 3079 break; 3080 default: 3081 break; 3082 } 3083 3084 return NOTIFY_DONE; 3085 } 3086 3087 static int bond_slave_netdev_event(unsigned long event, 3088 struct net_device *slave_dev) 3089 { 3090 struct slave *slave = bond_slave_get_rtnl(slave_dev), *primary; 3091 struct bonding *bond; 3092 struct net_device *bond_dev; 3093 3094 /* A netdev event can be generated while enslaving a device 3095 * before netdev_rx_handler_register is called in which case 3096 * slave will be NULL 3097 */ 3098 if (!slave) 3099 return NOTIFY_DONE; 3100 bond_dev = slave->bond->dev; 3101 bond = slave->bond; 3102 primary = rtnl_dereference(bond->primary_slave); 3103 3104 switch (event) { 3105 case NETDEV_UNREGISTER: 3106 if (bond_dev->type != ARPHRD_ETHER) 3107 bond_release_and_destroy(bond_dev, slave_dev); 3108 else 3109 __bond_release_one(bond_dev, slave_dev, false, true); 3110 break; 3111 case NETDEV_UP: 3112 case NETDEV_CHANGE: 3113 /* For 802.3ad mode only: 3114 * Getting invalid Speed/Duplex values here will put slave 3115 * in weird state. So mark it as link-down for the time 3116 * being and let link-monitoring (miimon) set it right when 3117 * correct speeds/duplex are available. 3118 */ 3119 if (bond_update_speed_duplex(slave) && 3120 BOND_MODE(bond) == BOND_MODE_8023AD) 3121 slave->link = BOND_LINK_DOWN; 3122 3123 if (BOND_MODE(bond) == BOND_MODE_8023AD) 3124 bond_3ad_adapter_speed_duplex_changed(slave); 3125 /* Fallthrough */ 3126 case NETDEV_DOWN: 3127 /* Refresh slave-array if applicable! 3128 * If the setup does not use miimon or arpmon (mode-specific!), 3129 * then these events will not cause the slave-array to be 3130 * refreshed. This will cause xmit to use a slave that is not 3131 * usable. Avoid such situation by refeshing the array at these 3132 * events. If these (miimon/arpmon) parameters are configured 3133 * then array gets refreshed twice and that should be fine! 3134 */ 3135 if (bond_mode_can_use_xmit_hash(bond)) 3136 bond_update_slave_arr(bond, NULL); 3137 break; 3138 case NETDEV_CHANGEMTU: 3139 /* TODO: Should slaves be allowed to 3140 * independently alter their MTU? For 3141 * an active-backup bond, slaves need 3142 * not be the same type of device, so 3143 * MTUs may vary. For other modes, 3144 * slaves arguably should have the 3145 * same MTUs. To do this, we'd need to 3146 * take over the slave's change_mtu 3147 * function for the duration of their 3148 * servitude. 3149 */ 3150 break; 3151 case NETDEV_CHANGENAME: 3152 /* we don't care if we don't have primary set */ 3153 if (!bond_uses_primary(bond) || 3154 !bond->params.primary[0]) 3155 break; 3156 3157 if (slave == primary) { 3158 /* slave's name changed - he's no longer primary */ 3159 RCU_INIT_POINTER(bond->primary_slave, NULL); 3160 } else if (!strcmp(slave_dev->name, bond->params.primary)) { 3161 /* we have a new primary slave */ 3162 rcu_assign_pointer(bond->primary_slave, slave); 3163 } else { /* we didn't change primary - exit */ 3164 break; 3165 } 3166 3167 netdev_info(bond->dev, "Primary slave changed to %s, reselecting active slave\n", 3168 primary ? slave_dev->name : "none"); 3169 3170 block_netpoll_tx(); 3171 bond_select_active_slave(bond); 3172 unblock_netpoll_tx(); 3173 break; 3174 case NETDEV_FEAT_CHANGE: 3175 bond_compute_features(bond); 3176 break; 3177 case NETDEV_RESEND_IGMP: 3178 /* Propagate to master device */ 3179 call_netdevice_notifiers(event, slave->bond->dev); 3180 break; 3181 default: 3182 break; 3183 } 3184 3185 return NOTIFY_DONE; 3186 } 3187 3188 /* bond_netdev_event: handle netdev notifier chain events. 3189 * 3190 * This function receives events for the netdev chain. The caller (an 3191 * ioctl handler calling blocking_notifier_call_chain) holds the necessary 3192 * locks for us to safely manipulate the slave devices (RTNL lock, 3193 * dev_probe_lock). 3194 */ 3195 static int bond_netdev_event(struct notifier_block *this, 3196 unsigned long event, void *ptr) 3197 { 3198 struct net_device *event_dev = netdev_notifier_info_to_dev(ptr); 3199 3200 netdev_dbg(event_dev, "event: %lx\n", event); 3201 3202 if (!(event_dev->priv_flags & IFF_BONDING)) 3203 return NOTIFY_DONE; 3204 3205 if (event_dev->flags & IFF_MASTER) { 3206 netdev_dbg(event_dev, "IFF_MASTER\n"); 3207 return bond_master_netdev_event(event, event_dev); 3208 } 3209 3210 if (event_dev->flags & IFF_SLAVE) { 3211 netdev_dbg(event_dev, "IFF_SLAVE\n"); 3212 return bond_slave_netdev_event(event, event_dev); 3213 } 3214 3215 return NOTIFY_DONE; 3216 } 3217 3218 static struct notifier_block bond_netdev_notifier = { 3219 .notifier_call = bond_netdev_event, 3220 }; 3221 3222 /*---------------------------- Hashing Policies -----------------------------*/ 3223 3224 /* L2 hash helper */ 3225 static inline u32 bond_eth_hash(struct sk_buff *skb) 3226 { 3227 struct ethhdr *ep, hdr_tmp; 3228 3229 ep = skb_header_pointer(skb, 0, sizeof(hdr_tmp), &hdr_tmp); 3230 if (ep) 3231 return ep->h_dest[5] ^ ep->h_source[5] ^ ep->h_proto; 3232 return 0; 3233 } 3234 3235 /* Extract the appropriate headers based on bond's xmit policy */ 3236 static bool bond_flow_dissect(struct bonding *bond, struct sk_buff *skb, 3237 struct flow_keys *fk) 3238 { 3239 const struct ipv6hdr *iph6; 3240 const struct iphdr *iph; 3241 int noff, proto = -1; 3242 3243 if (bond->params.xmit_policy > BOND_XMIT_POLICY_LAYER23) 3244 return skb_flow_dissect_flow_keys(skb, fk, 0); 3245 3246 fk->ports.ports = 0; 3247 noff = skb_network_offset(skb); 3248 if (skb->protocol == htons(ETH_P_IP)) { 3249 if (unlikely(!pskb_may_pull(skb, noff + sizeof(*iph)))) 3250 return false; 3251 iph = ip_hdr(skb); 3252 iph_to_flow_copy_v4addrs(fk, iph); 3253 noff += iph->ihl << 2; 3254 if (!ip_is_fragment(iph)) 3255 proto = iph->protocol; 3256 } else if (skb->protocol == htons(ETH_P_IPV6)) { 3257 if (unlikely(!pskb_may_pull(skb, noff + sizeof(*iph6)))) 3258 return false; 3259 iph6 = ipv6_hdr(skb); 3260 iph_to_flow_copy_v6addrs(fk, iph6); 3261 noff += sizeof(*iph6); 3262 proto = iph6->nexthdr; 3263 } else { 3264 return false; 3265 } 3266 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34 && proto >= 0) 3267 fk->ports.ports = skb_flow_get_ports(skb, noff, proto); 3268 3269 return true; 3270 } 3271 3272 /** 3273 * bond_xmit_hash - generate a hash value based on the xmit policy 3274 * @bond: bonding device 3275 * @skb: buffer to use for headers 3276 * 3277 * This function will extract the necessary headers from the skb buffer and use 3278 * them to generate a hash based on the xmit_policy set in the bonding device 3279 */ 3280 u32 bond_xmit_hash(struct bonding *bond, struct sk_buff *skb) 3281 { 3282 struct flow_keys flow; 3283 u32 hash; 3284 3285 if (bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP34 && 3286 skb->l4_hash) 3287 return skb->hash; 3288 3289 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER2 || 3290 !bond_flow_dissect(bond, skb, &flow)) 3291 return bond_eth_hash(skb); 3292 3293 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER23 || 3294 bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP23) 3295 hash = bond_eth_hash(skb); 3296 else 3297 hash = (__force u32)flow.ports.ports; 3298 hash ^= (__force u32)flow_get_u32_dst(&flow) ^ 3299 (__force u32)flow_get_u32_src(&flow); 3300 hash ^= (hash >> 16); 3301 hash ^= (hash >> 8); 3302 3303 return hash >> 1; 3304 } 3305 3306 /*-------------------------- Device entry points ----------------------------*/ 3307 3308 void bond_work_init_all(struct bonding *bond) 3309 { 3310 INIT_DELAYED_WORK(&bond->mcast_work, 3311 bond_resend_igmp_join_requests_delayed); 3312 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor); 3313 INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor); 3314 INIT_DELAYED_WORK(&bond->arp_work, bond_arp_monitor); 3315 INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler); 3316 INIT_DELAYED_WORK(&bond->slave_arr_work, bond_slave_arr_handler); 3317 } 3318 3319 static void bond_work_cancel_all(struct bonding *bond) 3320 { 3321 cancel_delayed_work_sync(&bond->mii_work); 3322 cancel_delayed_work_sync(&bond->arp_work); 3323 cancel_delayed_work_sync(&bond->alb_work); 3324 cancel_delayed_work_sync(&bond->ad_work); 3325 cancel_delayed_work_sync(&bond->mcast_work); 3326 cancel_delayed_work_sync(&bond->slave_arr_work); 3327 } 3328 3329 static int bond_open(struct net_device *bond_dev) 3330 { 3331 struct bonding *bond = netdev_priv(bond_dev); 3332 struct list_head *iter; 3333 struct slave *slave; 3334 3335 /* reset slave->backup and slave->inactive */ 3336 if (bond_has_slaves(bond)) { 3337 bond_for_each_slave(bond, slave, iter) { 3338 if (bond_uses_primary(bond) && 3339 slave != rcu_access_pointer(bond->curr_active_slave)) { 3340 bond_set_slave_inactive_flags(slave, 3341 BOND_SLAVE_NOTIFY_NOW); 3342 } else if (BOND_MODE(bond) != BOND_MODE_8023AD) { 3343 bond_set_slave_active_flags(slave, 3344 BOND_SLAVE_NOTIFY_NOW); 3345 } 3346 } 3347 } 3348 3349 if (bond_is_lb(bond)) { 3350 /* bond_alb_initialize must be called before the timer 3351 * is started. 3352 */ 3353 if (bond_alb_initialize(bond, (BOND_MODE(bond) == BOND_MODE_ALB))) 3354 return -ENOMEM; 3355 if (bond->params.tlb_dynamic_lb || BOND_MODE(bond) == BOND_MODE_ALB) 3356 queue_delayed_work(bond->wq, &bond->alb_work, 0); 3357 } 3358 3359 if (bond->params.miimon) /* link check interval, in milliseconds. */ 3360 queue_delayed_work(bond->wq, &bond->mii_work, 0); 3361 3362 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */ 3363 queue_delayed_work(bond->wq, &bond->arp_work, 0); 3364 bond->recv_probe = bond_arp_rcv; 3365 } 3366 3367 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 3368 queue_delayed_work(bond->wq, &bond->ad_work, 0); 3369 /* register to receive LACPDUs */ 3370 bond->recv_probe = bond_3ad_lacpdu_recv; 3371 bond_3ad_initiate_agg_selection(bond, 1); 3372 } 3373 3374 if (bond_mode_can_use_xmit_hash(bond)) 3375 bond_update_slave_arr(bond, NULL); 3376 3377 return 0; 3378 } 3379 3380 static int bond_close(struct net_device *bond_dev) 3381 { 3382 struct bonding *bond = netdev_priv(bond_dev); 3383 3384 bond_work_cancel_all(bond); 3385 bond->send_peer_notif = 0; 3386 if (bond_is_lb(bond)) 3387 bond_alb_deinitialize(bond); 3388 bond->recv_probe = NULL; 3389 3390 return 0; 3391 } 3392 3393 /* fold stats, assuming all rtnl_link_stats64 fields are u64, but 3394 * that some drivers can provide 32bit values only. 3395 */ 3396 static void bond_fold_stats(struct rtnl_link_stats64 *_res, 3397 const struct rtnl_link_stats64 *_new, 3398 const struct rtnl_link_stats64 *_old) 3399 { 3400 const u64 *new = (const u64 *)_new; 3401 const u64 *old = (const u64 *)_old; 3402 u64 *res = (u64 *)_res; 3403 int i; 3404 3405 for (i = 0; i < sizeof(*_res) / sizeof(u64); i++) { 3406 u64 nv = new[i]; 3407 u64 ov = old[i]; 3408 s64 delta = nv - ov; 3409 3410 /* detects if this particular field is 32bit only */ 3411 if (((nv | ov) >> 32) == 0) 3412 delta = (s64)(s32)((u32)nv - (u32)ov); 3413 3414 /* filter anomalies, some drivers reset their stats 3415 * at down/up events. 3416 */ 3417 if (delta > 0) 3418 res[i] += delta; 3419 } 3420 } 3421 3422 static int bond_get_nest_level(struct net_device *bond_dev) 3423 { 3424 struct bonding *bond = netdev_priv(bond_dev); 3425 3426 return bond->nest_level; 3427 } 3428 3429 static void bond_get_stats(struct net_device *bond_dev, 3430 struct rtnl_link_stats64 *stats) 3431 { 3432 struct bonding *bond = netdev_priv(bond_dev); 3433 struct rtnl_link_stats64 temp; 3434 struct list_head *iter; 3435 struct slave *slave; 3436 3437 spin_lock_nested(&bond->stats_lock, bond_get_nest_level(bond_dev)); 3438 memcpy(stats, &bond->bond_stats, sizeof(*stats)); 3439 3440 rcu_read_lock(); 3441 bond_for_each_slave_rcu(bond, slave, iter) { 3442 const struct rtnl_link_stats64 *new = 3443 dev_get_stats(slave->dev, &temp); 3444 3445 bond_fold_stats(stats, new, &slave->slave_stats); 3446 3447 /* save off the slave stats for the next run */ 3448 memcpy(&slave->slave_stats, new, sizeof(*new)); 3449 } 3450 rcu_read_unlock(); 3451 3452 memcpy(&bond->bond_stats, stats, sizeof(*stats)); 3453 spin_unlock(&bond->stats_lock); 3454 } 3455 3456 static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd) 3457 { 3458 struct bonding *bond = netdev_priv(bond_dev); 3459 struct net_device *slave_dev = NULL; 3460 struct ifbond k_binfo; 3461 struct ifbond __user *u_binfo = NULL; 3462 struct ifslave k_sinfo; 3463 struct ifslave __user *u_sinfo = NULL; 3464 struct mii_ioctl_data *mii = NULL; 3465 struct bond_opt_value newval; 3466 struct net *net; 3467 int res = 0; 3468 3469 netdev_dbg(bond_dev, "bond_ioctl: cmd=%d\n", cmd); 3470 3471 switch (cmd) { 3472 case SIOCGMIIPHY: 3473 mii = if_mii(ifr); 3474 if (!mii) 3475 return -EINVAL; 3476 3477 mii->phy_id = 0; 3478 /* Fall Through */ 3479 case SIOCGMIIREG: 3480 /* We do this again just in case we were called by SIOCGMIIREG 3481 * instead of SIOCGMIIPHY. 3482 */ 3483 mii = if_mii(ifr); 3484 if (!mii) 3485 return -EINVAL; 3486 3487 if (mii->reg_num == 1) { 3488 mii->val_out = 0; 3489 if (netif_carrier_ok(bond->dev)) 3490 mii->val_out = BMSR_LSTATUS; 3491 } 3492 3493 return 0; 3494 case BOND_INFO_QUERY_OLD: 3495 case SIOCBONDINFOQUERY: 3496 u_binfo = (struct ifbond __user *)ifr->ifr_data; 3497 3498 if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) 3499 return -EFAULT; 3500 3501 bond_info_query(bond_dev, &k_binfo); 3502 if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) 3503 return -EFAULT; 3504 3505 return 0; 3506 case BOND_SLAVE_INFO_QUERY_OLD: 3507 case SIOCBONDSLAVEINFOQUERY: 3508 u_sinfo = (struct ifslave __user *)ifr->ifr_data; 3509 3510 if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) 3511 return -EFAULT; 3512 3513 res = bond_slave_info_query(bond_dev, &k_sinfo); 3514 if (res == 0 && 3515 copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) 3516 return -EFAULT; 3517 3518 return res; 3519 default: 3520 break; 3521 } 3522 3523 net = dev_net(bond_dev); 3524 3525 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 3526 return -EPERM; 3527 3528 slave_dev = __dev_get_by_name(net, ifr->ifr_slave); 3529 3530 netdev_dbg(bond_dev, "slave_dev=%p:\n", slave_dev); 3531 3532 if (!slave_dev) 3533 return -ENODEV; 3534 3535 netdev_dbg(bond_dev, "slave_dev->name=%s:\n", slave_dev->name); 3536 switch (cmd) { 3537 case BOND_ENSLAVE_OLD: 3538 case SIOCBONDENSLAVE: 3539 res = bond_enslave(bond_dev, slave_dev, NULL); 3540 break; 3541 case BOND_RELEASE_OLD: 3542 case SIOCBONDRELEASE: 3543 res = bond_release(bond_dev, slave_dev); 3544 break; 3545 case BOND_SETHWADDR_OLD: 3546 case SIOCBONDSETHWADDR: 3547 bond_set_dev_addr(bond_dev, slave_dev); 3548 res = 0; 3549 break; 3550 case BOND_CHANGE_ACTIVE_OLD: 3551 case SIOCBONDCHANGEACTIVE: 3552 bond_opt_initstr(&newval, slave_dev->name); 3553 res = __bond_opt_set_notify(bond, BOND_OPT_ACTIVE_SLAVE, 3554 &newval); 3555 break; 3556 default: 3557 res = -EOPNOTSUPP; 3558 } 3559 3560 return res; 3561 } 3562 3563 static void bond_change_rx_flags(struct net_device *bond_dev, int change) 3564 { 3565 struct bonding *bond = netdev_priv(bond_dev); 3566 3567 if (change & IFF_PROMISC) 3568 bond_set_promiscuity(bond, 3569 bond_dev->flags & IFF_PROMISC ? 1 : -1); 3570 3571 if (change & IFF_ALLMULTI) 3572 bond_set_allmulti(bond, 3573 bond_dev->flags & IFF_ALLMULTI ? 1 : -1); 3574 } 3575 3576 static void bond_set_rx_mode(struct net_device *bond_dev) 3577 { 3578 struct bonding *bond = netdev_priv(bond_dev); 3579 struct list_head *iter; 3580 struct slave *slave; 3581 3582 rcu_read_lock(); 3583 if (bond_uses_primary(bond)) { 3584 slave = rcu_dereference(bond->curr_active_slave); 3585 if (slave) { 3586 dev_uc_sync(slave->dev, bond_dev); 3587 dev_mc_sync(slave->dev, bond_dev); 3588 } 3589 } else { 3590 bond_for_each_slave_rcu(bond, slave, iter) { 3591 dev_uc_sync_multiple(slave->dev, bond_dev); 3592 dev_mc_sync_multiple(slave->dev, bond_dev); 3593 } 3594 } 3595 rcu_read_unlock(); 3596 } 3597 3598 static int bond_neigh_init(struct neighbour *n) 3599 { 3600 struct bonding *bond = netdev_priv(n->dev); 3601 const struct net_device_ops *slave_ops; 3602 struct neigh_parms parms; 3603 struct slave *slave; 3604 int ret; 3605 3606 slave = bond_first_slave(bond); 3607 if (!slave) 3608 return 0; 3609 slave_ops = slave->dev->netdev_ops; 3610 if (!slave_ops->ndo_neigh_setup) 3611 return 0; 3612 3613 parms.neigh_setup = NULL; 3614 parms.neigh_cleanup = NULL; 3615 ret = slave_ops->ndo_neigh_setup(slave->dev, &parms); 3616 if (ret) 3617 return ret; 3618 3619 /* Assign slave's neigh_cleanup to neighbour in case cleanup is called 3620 * after the last slave has been detached. Assumes that all slaves 3621 * utilize the same neigh_cleanup (true at this writing as only user 3622 * is ipoib). 3623 */ 3624 n->parms->neigh_cleanup = parms.neigh_cleanup; 3625 3626 if (!parms.neigh_setup) 3627 return 0; 3628 3629 return parms.neigh_setup(n); 3630 } 3631 3632 /* The bonding ndo_neigh_setup is called at init time beofre any 3633 * slave exists. So we must declare proxy setup function which will 3634 * be used at run time to resolve the actual slave neigh param setup. 3635 * 3636 * It's also called by master devices (such as vlans) to setup their 3637 * underlying devices. In that case - do nothing, we're already set up from 3638 * our init. 3639 */ 3640 static int bond_neigh_setup(struct net_device *dev, 3641 struct neigh_parms *parms) 3642 { 3643 /* modify only our neigh_parms */ 3644 if (parms->dev == dev) 3645 parms->neigh_setup = bond_neigh_init; 3646 3647 return 0; 3648 } 3649 3650 /* Change the MTU of all of a master's slaves to match the master */ 3651 static int bond_change_mtu(struct net_device *bond_dev, int new_mtu) 3652 { 3653 struct bonding *bond = netdev_priv(bond_dev); 3654 struct slave *slave, *rollback_slave; 3655 struct list_head *iter; 3656 int res = 0; 3657 3658 netdev_dbg(bond_dev, "bond=%p, new_mtu=%d\n", bond, new_mtu); 3659 3660 bond_for_each_slave(bond, slave, iter) { 3661 netdev_dbg(bond_dev, "s %p c_m %p\n", 3662 slave, slave->dev->netdev_ops->ndo_change_mtu); 3663 3664 res = dev_set_mtu(slave->dev, new_mtu); 3665 3666 if (res) { 3667 /* If we failed to set the slave's mtu to the new value 3668 * we must abort the operation even in ACTIVE_BACKUP 3669 * mode, because if we allow the backup slaves to have 3670 * different mtu values than the active slave we'll 3671 * need to change their mtu when doing a failover. That 3672 * means changing their mtu from timer context, which 3673 * is probably not a good idea. 3674 */ 3675 netdev_dbg(bond_dev, "err %d %s\n", res, 3676 slave->dev->name); 3677 goto unwind; 3678 } 3679 } 3680 3681 bond_dev->mtu = new_mtu; 3682 3683 return 0; 3684 3685 unwind: 3686 /* unwind from head to the slave that failed */ 3687 bond_for_each_slave(bond, rollback_slave, iter) { 3688 int tmp_res; 3689 3690 if (rollback_slave == slave) 3691 break; 3692 3693 tmp_res = dev_set_mtu(rollback_slave->dev, bond_dev->mtu); 3694 if (tmp_res) { 3695 netdev_dbg(bond_dev, "unwind err %d dev %s\n", 3696 tmp_res, rollback_slave->dev->name); 3697 } 3698 } 3699 3700 return res; 3701 } 3702 3703 /* Change HW address 3704 * 3705 * Note that many devices must be down to change the HW address, and 3706 * downing the master releases all slaves. We can make bonds full of 3707 * bonding devices to test this, however. 3708 */ 3709 static int bond_set_mac_address(struct net_device *bond_dev, void *addr) 3710 { 3711 struct bonding *bond = netdev_priv(bond_dev); 3712 struct slave *slave, *rollback_slave; 3713 struct sockaddr_storage *ss = addr, tmp_ss; 3714 struct list_head *iter; 3715 int res = 0; 3716 3717 if (BOND_MODE(bond) == BOND_MODE_ALB) 3718 return bond_alb_set_mac_address(bond_dev, addr); 3719 3720 3721 netdev_dbg(bond_dev, "bond=%p\n", bond); 3722 3723 /* If fail_over_mac is enabled, do nothing and return success. 3724 * Returning an error causes ifenslave to fail. 3725 */ 3726 if (bond->params.fail_over_mac && 3727 BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) 3728 return 0; 3729 3730 if (!is_valid_ether_addr(ss->__data)) 3731 return -EADDRNOTAVAIL; 3732 3733 bond_for_each_slave(bond, slave, iter) { 3734 netdev_dbg(bond_dev, "slave %p %s\n", slave, slave->dev->name); 3735 res = dev_set_mac_address(slave->dev, addr); 3736 if (res) { 3737 /* TODO: consider downing the slave 3738 * and retry ? 3739 * User should expect communications 3740 * breakage anyway until ARP finish 3741 * updating, so... 3742 */ 3743 netdev_dbg(bond_dev, "err %d %s\n", res, slave->dev->name); 3744 goto unwind; 3745 } 3746 } 3747 3748 /* success */ 3749 memcpy(bond_dev->dev_addr, ss->__data, bond_dev->addr_len); 3750 return 0; 3751 3752 unwind: 3753 memcpy(tmp_ss.__data, bond_dev->dev_addr, bond_dev->addr_len); 3754 tmp_ss.ss_family = bond_dev->type; 3755 3756 /* unwind from head to the slave that failed */ 3757 bond_for_each_slave(bond, rollback_slave, iter) { 3758 int tmp_res; 3759 3760 if (rollback_slave == slave) 3761 break; 3762 3763 tmp_res = dev_set_mac_address(rollback_slave->dev, 3764 (struct sockaddr *)&tmp_ss); 3765 if (tmp_res) { 3766 netdev_dbg(bond_dev, "unwind err %d dev %s\n", 3767 tmp_res, rollback_slave->dev->name); 3768 } 3769 } 3770 3771 return res; 3772 } 3773 3774 /** 3775 * bond_xmit_slave_id - transmit skb through slave with slave_id 3776 * @bond: bonding device that is transmitting 3777 * @skb: buffer to transmit 3778 * @slave_id: slave id up to slave_cnt-1 through which to transmit 3779 * 3780 * This function tries to transmit through slave with slave_id but in case 3781 * it fails, it tries to find the first available slave for transmission. 3782 * The skb is consumed in all cases, thus the function is void. 3783 */ 3784 static void bond_xmit_slave_id(struct bonding *bond, struct sk_buff *skb, int slave_id) 3785 { 3786 struct list_head *iter; 3787 struct slave *slave; 3788 int i = slave_id; 3789 3790 /* Here we start from the slave with slave_id */ 3791 bond_for_each_slave_rcu(bond, slave, iter) { 3792 if (--i < 0) { 3793 if (bond_slave_can_tx(slave)) { 3794 bond_dev_queue_xmit(bond, skb, slave->dev); 3795 return; 3796 } 3797 } 3798 } 3799 3800 /* Here we start from the first slave up to slave_id */ 3801 i = slave_id; 3802 bond_for_each_slave_rcu(bond, slave, iter) { 3803 if (--i < 0) 3804 break; 3805 if (bond_slave_can_tx(slave)) { 3806 bond_dev_queue_xmit(bond, skb, slave->dev); 3807 return; 3808 } 3809 } 3810 /* no slave that can tx has been found */ 3811 bond_tx_drop(bond->dev, skb); 3812 } 3813 3814 /** 3815 * bond_rr_gen_slave_id - generate slave id based on packets_per_slave 3816 * @bond: bonding device to use 3817 * 3818 * Based on the value of the bonding device's packets_per_slave parameter 3819 * this function generates a slave id, which is usually used as the next 3820 * slave to transmit through. 3821 */ 3822 static u32 bond_rr_gen_slave_id(struct bonding *bond) 3823 { 3824 u32 slave_id; 3825 struct reciprocal_value reciprocal_packets_per_slave; 3826 int packets_per_slave = bond->params.packets_per_slave; 3827 3828 switch (packets_per_slave) { 3829 case 0: 3830 slave_id = prandom_u32(); 3831 break; 3832 case 1: 3833 slave_id = bond->rr_tx_counter; 3834 break; 3835 default: 3836 reciprocal_packets_per_slave = 3837 bond->params.reciprocal_packets_per_slave; 3838 slave_id = reciprocal_divide(bond->rr_tx_counter, 3839 reciprocal_packets_per_slave); 3840 break; 3841 } 3842 bond->rr_tx_counter++; 3843 3844 return slave_id; 3845 } 3846 3847 static netdev_tx_t bond_xmit_roundrobin(struct sk_buff *skb, 3848 struct net_device *bond_dev) 3849 { 3850 struct bonding *bond = netdev_priv(bond_dev); 3851 struct iphdr *iph = ip_hdr(skb); 3852 struct slave *slave; 3853 u32 slave_id; 3854 3855 /* Start with the curr_active_slave that joined the bond as the 3856 * default for sending IGMP traffic. For failover purposes one 3857 * needs to maintain some consistency for the interface that will 3858 * send the join/membership reports. The curr_active_slave found 3859 * will send all of this type of traffic. 3860 */ 3861 if (iph->protocol == IPPROTO_IGMP && skb->protocol == htons(ETH_P_IP)) { 3862 slave = rcu_dereference(bond->curr_active_slave); 3863 if (slave) 3864 bond_dev_queue_xmit(bond, skb, slave->dev); 3865 else 3866 bond_xmit_slave_id(bond, skb, 0); 3867 } else { 3868 int slave_cnt = READ_ONCE(bond->slave_cnt); 3869 3870 if (likely(slave_cnt)) { 3871 slave_id = bond_rr_gen_slave_id(bond); 3872 bond_xmit_slave_id(bond, skb, slave_id % slave_cnt); 3873 } else { 3874 bond_tx_drop(bond_dev, skb); 3875 } 3876 } 3877 3878 return NETDEV_TX_OK; 3879 } 3880 3881 /* In active-backup mode, we know that bond->curr_active_slave is always valid if 3882 * the bond has a usable interface. 3883 */ 3884 static netdev_tx_t bond_xmit_activebackup(struct sk_buff *skb, 3885 struct net_device *bond_dev) 3886 { 3887 struct bonding *bond = netdev_priv(bond_dev); 3888 struct slave *slave; 3889 3890 slave = rcu_dereference(bond->curr_active_slave); 3891 if (slave) 3892 bond_dev_queue_xmit(bond, skb, slave->dev); 3893 else 3894 bond_tx_drop(bond_dev, skb); 3895 3896 return NETDEV_TX_OK; 3897 } 3898 3899 /* Use this to update slave_array when (a) it's not appropriate to update 3900 * slave_array right away (note that update_slave_array() may sleep) 3901 * and / or (b) RTNL is not held. 3902 */ 3903 void bond_slave_arr_work_rearm(struct bonding *bond, unsigned long delay) 3904 { 3905 queue_delayed_work(bond->wq, &bond->slave_arr_work, delay); 3906 } 3907 3908 /* Slave array work handler. Holds only RTNL */ 3909 static void bond_slave_arr_handler(struct work_struct *work) 3910 { 3911 struct bonding *bond = container_of(work, struct bonding, 3912 slave_arr_work.work); 3913 int ret; 3914 3915 if (!rtnl_trylock()) 3916 goto err; 3917 3918 ret = bond_update_slave_arr(bond, NULL); 3919 rtnl_unlock(); 3920 if (ret) { 3921 pr_warn_ratelimited("Failed to update slave array from WT\n"); 3922 goto err; 3923 } 3924 return; 3925 3926 err: 3927 bond_slave_arr_work_rearm(bond, 1); 3928 } 3929 3930 /* Build the usable slaves array in control path for modes that use xmit-hash 3931 * to determine the slave interface - 3932 * (a) BOND_MODE_8023AD 3933 * (b) BOND_MODE_XOR 3934 * (c) (BOND_MODE_TLB || BOND_MODE_ALB) && tlb_dynamic_lb == 0 3935 * 3936 * The caller is expected to hold RTNL only and NO other lock! 3937 */ 3938 int bond_update_slave_arr(struct bonding *bond, struct slave *skipslave) 3939 { 3940 struct slave *slave; 3941 struct list_head *iter; 3942 struct bond_up_slave *new_arr, *old_arr; 3943 int agg_id = 0; 3944 int ret = 0; 3945 3946 #ifdef CONFIG_LOCKDEP 3947 WARN_ON(lockdep_is_held(&bond->mode_lock)); 3948 #endif 3949 3950 new_arr = kzalloc(offsetof(struct bond_up_slave, arr[bond->slave_cnt]), 3951 GFP_KERNEL); 3952 if (!new_arr) { 3953 ret = -ENOMEM; 3954 pr_err("Failed to build slave-array.\n"); 3955 goto out; 3956 } 3957 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 3958 struct ad_info ad_info; 3959 3960 if (bond_3ad_get_active_agg_info(bond, &ad_info)) { 3961 pr_debug("bond_3ad_get_active_agg_info failed\n"); 3962 kfree_rcu(new_arr, rcu); 3963 /* No active aggragator means it's not safe to use 3964 * the previous array. 3965 */ 3966 old_arr = rtnl_dereference(bond->slave_arr); 3967 if (old_arr) { 3968 RCU_INIT_POINTER(bond->slave_arr, NULL); 3969 kfree_rcu(old_arr, rcu); 3970 } 3971 goto out; 3972 } 3973 agg_id = ad_info.aggregator_id; 3974 } 3975 bond_for_each_slave(bond, slave, iter) { 3976 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 3977 struct aggregator *agg; 3978 3979 agg = SLAVE_AD_INFO(slave)->port.aggregator; 3980 if (!agg || agg->aggregator_identifier != agg_id) 3981 continue; 3982 } 3983 if (!bond_slave_can_tx(slave)) 3984 continue; 3985 if (skipslave == slave) 3986 continue; 3987 3988 netdev_dbg(bond->dev, 3989 "Adding slave dev %s to tx hash array[%d]\n", 3990 slave->dev->name, new_arr->count); 3991 3992 new_arr->arr[new_arr->count++] = slave; 3993 } 3994 3995 old_arr = rtnl_dereference(bond->slave_arr); 3996 rcu_assign_pointer(bond->slave_arr, new_arr); 3997 if (old_arr) 3998 kfree_rcu(old_arr, rcu); 3999 out: 4000 if (ret != 0 && skipslave) { 4001 int idx; 4002 4003 /* Rare situation where caller has asked to skip a specific 4004 * slave but allocation failed (most likely!). BTW this is 4005 * only possible when the call is initiated from 4006 * __bond_release_one(). In this situation; overwrite the 4007 * skipslave entry in the array with the last entry from the 4008 * array to avoid a situation where the xmit path may choose 4009 * this to-be-skipped slave to send a packet out. 4010 */ 4011 old_arr = rtnl_dereference(bond->slave_arr); 4012 for (idx = 0; idx < old_arr->count; idx++) { 4013 if (skipslave == old_arr->arr[idx]) { 4014 old_arr->arr[idx] = 4015 old_arr->arr[old_arr->count-1]; 4016 old_arr->count--; 4017 break; 4018 } 4019 } 4020 } 4021 return ret; 4022 } 4023 4024 /* Use this Xmit function for 3AD as well as XOR modes. The current 4025 * usable slave array is formed in the control path. The xmit function 4026 * just calculates hash and sends the packet out. 4027 */ 4028 static netdev_tx_t bond_3ad_xor_xmit(struct sk_buff *skb, 4029 struct net_device *dev) 4030 { 4031 struct bonding *bond = netdev_priv(dev); 4032 struct slave *slave; 4033 struct bond_up_slave *slaves; 4034 unsigned int count; 4035 4036 slaves = rcu_dereference(bond->slave_arr); 4037 count = slaves ? READ_ONCE(slaves->count) : 0; 4038 if (likely(count)) { 4039 slave = slaves->arr[bond_xmit_hash(bond, skb) % count]; 4040 bond_dev_queue_xmit(bond, skb, slave->dev); 4041 } else { 4042 bond_tx_drop(dev, skb); 4043 } 4044 4045 return NETDEV_TX_OK; 4046 } 4047 4048 /* in broadcast mode, we send everything to all usable interfaces. */ 4049 static netdev_tx_t bond_xmit_broadcast(struct sk_buff *skb, 4050 struct net_device *bond_dev) 4051 { 4052 struct bonding *bond = netdev_priv(bond_dev); 4053 struct slave *slave = NULL; 4054 struct list_head *iter; 4055 4056 bond_for_each_slave_rcu(bond, slave, iter) { 4057 if (bond_is_last_slave(bond, slave)) 4058 break; 4059 if (bond_slave_is_up(slave) && slave->link == BOND_LINK_UP) { 4060 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 4061 4062 if (!skb2) { 4063 net_err_ratelimited("%s: Error: %s: skb_clone() failed\n", 4064 bond_dev->name, __func__); 4065 continue; 4066 } 4067 bond_dev_queue_xmit(bond, skb2, slave->dev); 4068 } 4069 } 4070 if (slave && bond_slave_is_up(slave) && slave->link == BOND_LINK_UP) 4071 bond_dev_queue_xmit(bond, skb, slave->dev); 4072 else 4073 bond_tx_drop(bond_dev, skb); 4074 4075 return NETDEV_TX_OK; 4076 } 4077 4078 /*------------------------- Device initialization ---------------------------*/ 4079 4080 /* Lookup the slave that corresponds to a qid */ 4081 static inline int bond_slave_override(struct bonding *bond, 4082 struct sk_buff *skb) 4083 { 4084 struct slave *slave = NULL; 4085 struct list_head *iter; 4086 4087 if (!skb_rx_queue_recorded(skb)) 4088 return 1; 4089 4090 /* Find out if any slaves have the same mapping as this skb. */ 4091 bond_for_each_slave_rcu(bond, slave, iter) { 4092 if (slave->queue_id == skb_get_queue_mapping(skb)) { 4093 if (bond_slave_is_up(slave) && 4094 slave->link == BOND_LINK_UP) { 4095 bond_dev_queue_xmit(bond, skb, slave->dev); 4096 return 0; 4097 } 4098 /* If the slave isn't UP, use default transmit policy. */ 4099 break; 4100 } 4101 } 4102 4103 return 1; 4104 } 4105 4106 4107 static u16 bond_select_queue(struct net_device *dev, struct sk_buff *skb, 4108 struct net_device *sb_dev, 4109 select_queue_fallback_t fallback) 4110 { 4111 /* This helper function exists to help dev_pick_tx get the correct 4112 * destination queue. Using a helper function skips a call to 4113 * skb_tx_hash and will put the skbs in the queue we expect on their 4114 * way down to the bonding driver. 4115 */ 4116 u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0; 4117 4118 /* Save the original txq to restore before passing to the driver */ 4119 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb_get_queue_mapping(skb); 4120 4121 if (unlikely(txq >= dev->real_num_tx_queues)) { 4122 do { 4123 txq -= dev->real_num_tx_queues; 4124 } while (txq >= dev->real_num_tx_queues); 4125 } 4126 return txq; 4127 } 4128 4129 static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev) 4130 { 4131 struct bonding *bond = netdev_priv(dev); 4132 4133 if (bond_should_override_tx_queue(bond) && 4134 !bond_slave_override(bond, skb)) 4135 return NETDEV_TX_OK; 4136 4137 switch (BOND_MODE(bond)) { 4138 case BOND_MODE_ROUNDROBIN: 4139 return bond_xmit_roundrobin(skb, dev); 4140 case BOND_MODE_ACTIVEBACKUP: 4141 return bond_xmit_activebackup(skb, dev); 4142 case BOND_MODE_8023AD: 4143 case BOND_MODE_XOR: 4144 return bond_3ad_xor_xmit(skb, dev); 4145 case BOND_MODE_BROADCAST: 4146 return bond_xmit_broadcast(skb, dev); 4147 case BOND_MODE_ALB: 4148 return bond_alb_xmit(skb, dev); 4149 case BOND_MODE_TLB: 4150 return bond_tlb_xmit(skb, dev); 4151 default: 4152 /* Should never happen, mode already checked */ 4153 netdev_err(dev, "Unknown bonding mode %d\n", BOND_MODE(bond)); 4154 WARN_ON_ONCE(1); 4155 bond_tx_drop(dev, skb); 4156 return NETDEV_TX_OK; 4157 } 4158 } 4159 4160 static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev) 4161 { 4162 struct bonding *bond = netdev_priv(dev); 4163 netdev_tx_t ret = NETDEV_TX_OK; 4164 4165 /* If we risk deadlock from transmitting this in the 4166 * netpoll path, tell netpoll to queue the frame for later tx 4167 */ 4168 if (unlikely(is_netpoll_tx_blocked(dev))) 4169 return NETDEV_TX_BUSY; 4170 4171 rcu_read_lock(); 4172 if (bond_has_slaves(bond)) 4173 ret = __bond_start_xmit(skb, dev); 4174 else 4175 bond_tx_drop(dev, skb); 4176 rcu_read_unlock(); 4177 4178 return ret; 4179 } 4180 4181 static int bond_ethtool_get_link_ksettings(struct net_device *bond_dev, 4182 struct ethtool_link_ksettings *cmd) 4183 { 4184 struct bonding *bond = netdev_priv(bond_dev); 4185 unsigned long speed = 0; 4186 struct list_head *iter; 4187 struct slave *slave; 4188 4189 cmd->base.duplex = DUPLEX_UNKNOWN; 4190 cmd->base.port = PORT_OTHER; 4191 4192 /* Since bond_slave_can_tx returns false for all inactive or down slaves, we 4193 * do not need to check mode. Though link speed might not represent 4194 * the true receive or transmit bandwidth (not all modes are symmetric) 4195 * this is an accurate maximum. 4196 */ 4197 bond_for_each_slave(bond, slave, iter) { 4198 if (bond_slave_can_tx(slave)) { 4199 if (slave->speed != SPEED_UNKNOWN) 4200 speed += slave->speed; 4201 if (cmd->base.duplex == DUPLEX_UNKNOWN && 4202 slave->duplex != DUPLEX_UNKNOWN) 4203 cmd->base.duplex = slave->duplex; 4204 } 4205 } 4206 cmd->base.speed = speed ? : SPEED_UNKNOWN; 4207 4208 return 0; 4209 } 4210 4211 static void bond_ethtool_get_drvinfo(struct net_device *bond_dev, 4212 struct ethtool_drvinfo *drvinfo) 4213 { 4214 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver)); 4215 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version)); 4216 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%d", 4217 BOND_ABI_VERSION); 4218 } 4219 4220 static const struct ethtool_ops bond_ethtool_ops = { 4221 .get_drvinfo = bond_ethtool_get_drvinfo, 4222 .get_link = ethtool_op_get_link, 4223 .get_link_ksettings = bond_ethtool_get_link_ksettings, 4224 }; 4225 4226 static const struct net_device_ops bond_netdev_ops = { 4227 .ndo_init = bond_init, 4228 .ndo_uninit = bond_uninit, 4229 .ndo_open = bond_open, 4230 .ndo_stop = bond_close, 4231 .ndo_start_xmit = bond_start_xmit, 4232 .ndo_select_queue = bond_select_queue, 4233 .ndo_get_stats64 = bond_get_stats, 4234 .ndo_do_ioctl = bond_do_ioctl, 4235 .ndo_change_rx_flags = bond_change_rx_flags, 4236 .ndo_set_rx_mode = bond_set_rx_mode, 4237 .ndo_change_mtu = bond_change_mtu, 4238 .ndo_set_mac_address = bond_set_mac_address, 4239 .ndo_neigh_setup = bond_neigh_setup, 4240 .ndo_vlan_rx_add_vid = bond_vlan_rx_add_vid, 4241 .ndo_vlan_rx_kill_vid = bond_vlan_rx_kill_vid, 4242 .ndo_get_lock_subclass = bond_get_nest_level, 4243 #ifdef CONFIG_NET_POLL_CONTROLLER 4244 .ndo_netpoll_setup = bond_netpoll_setup, 4245 .ndo_netpoll_cleanup = bond_netpoll_cleanup, 4246 .ndo_poll_controller = bond_poll_controller, 4247 #endif 4248 .ndo_add_slave = bond_enslave, 4249 .ndo_del_slave = bond_release, 4250 .ndo_fix_features = bond_fix_features, 4251 .ndo_features_check = passthru_features_check, 4252 }; 4253 4254 static const struct device_type bond_type = { 4255 .name = "bond", 4256 }; 4257 4258 static void bond_destructor(struct net_device *bond_dev) 4259 { 4260 struct bonding *bond = netdev_priv(bond_dev); 4261 if (bond->wq) 4262 destroy_workqueue(bond->wq); 4263 } 4264 4265 void bond_setup(struct net_device *bond_dev) 4266 { 4267 struct bonding *bond = netdev_priv(bond_dev); 4268 4269 spin_lock_init(&bond->mode_lock); 4270 spin_lock_init(&bond->stats_lock); 4271 bond->params = bonding_defaults; 4272 4273 /* Initialize pointers */ 4274 bond->dev = bond_dev; 4275 4276 /* Initialize the device entry points */ 4277 ether_setup(bond_dev); 4278 bond_dev->max_mtu = ETH_MAX_MTU; 4279 bond_dev->netdev_ops = &bond_netdev_ops; 4280 bond_dev->ethtool_ops = &bond_ethtool_ops; 4281 4282 bond_dev->needs_free_netdev = true; 4283 bond_dev->priv_destructor = bond_destructor; 4284 4285 SET_NETDEV_DEVTYPE(bond_dev, &bond_type); 4286 4287 /* Initialize the device options */ 4288 bond_dev->flags |= IFF_MASTER; 4289 bond_dev->priv_flags |= IFF_BONDING | IFF_UNICAST_FLT | IFF_NO_QUEUE; 4290 bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING); 4291 4292 /* don't acquire bond device's netif_tx_lock when transmitting */ 4293 bond_dev->features |= NETIF_F_LLTX; 4294 4295 /* By default, we declare the bond to be fully 4296 * VLAN hardware accelerated capable. Special 4297 * care is taken in the various xmit functions 4298 * when there are slaves that are not hw accel 4299 * capable 4300 */ 4301 4302 /* Don't allow bond devices to change network namespaces. */ 4303 bond_dev->features |= NETIF_F_NETNS_LOCAL; 4304 4305 bond_dev->hw_features = BOND_VLAN_FEATURES | 4306 NETIF_F_HW_VLAN_CTAG_TX | 4307 NETIF_F_HW_VLAN_CTAG_RX | 4308 NETIF_F_HW_VLAN_CTAG_FILTER; 4309 4310 bond_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL | NETIF_F_GSO_UDP_L4; 4311 bond_dev->features |= bond_dev->hw_features; 4312 } 4313 4314 /* Destroy a bonding device. 4315 * Must be under rtnl_lock when this function is called. 4316 */ 4317 static void bond_uninit(struct net_device *bond_dev) 4318 { 4319 struct bonding *bond = netdev_priv(bond_dev); 4320 struct list_head *iter; 4321 struct slave *slave; 4322 struct bond_up_slave *arr; 4323 4324 bond_netpoll_cleanup(bond_dev); 4325 4326 /* Release the bonded slaves */ 4327 bond_for_each_slave(bond, slave, iter) 4328 __bond_release_one(bond_dev, slave->dev, true, true); 4329 netdev_info(bond_dev, "Released all slaves\n"); 4330 4331 arr = rtnl_dereference(bond->slave_arr); 4332 if (arr) { 4333 RCU_INIT_POINTER(bond->slave_arr, NULL); 4334 kfree_rcu(arr, rcu); 4335 } 4336 4337 list_del(&bond->bond_list); 4338 4339 bond_debug_unregister(bond); 4340 } 4341 4342 /*------------------------- Module initialization ---------------------------*/ 4343 4344 static int bond_check_params(struct bond_params *params) 4345 { 4346 int arp_validate_value, fail_over_mac_value, primary_reselect_value, i; 4347 struct bond_opt_value newval; 4348 const struct bond_opt_value *valptr; 4349 int arp_all_targets_value = 0; 4350 u16 ad_actor_sys_prio = 0; 4351 u16 ad_user_port_key = 0; 4352 __be32 arp_target[BOND_MAX_ARP_TARGETS] = { 0 }; 4353 int arp_ip_count; 4354 int bond_mode = BOND_MODE_ROUNDROBIN; 4355 int xmit_hashtype = BOND_XMIT_POLICY_LAYER2; 4356 int lacp_fast = 0; 4357 int tlb_dynamic_lb; 4358 4359 /* Convert string parameters. */ 4360 if (mode) { 4361 bond_opt_initstr(&newval, mode); 4362 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_MODE), &newval); 4363 if (!valptr) { 4364 pr_err("Error: Invalid bonding mode \"%s\"\n", mode); 4365 return -EINVAL; 4366 } 4367 bond_mode = valptr->value; 4368 } 4369 4370 if (xmit_hash_policy) { 4371 if (bond_mode == BOND_MODE_ROUNDROBIN || 4372 bond_mode == BOND_MODE_ACTIVEBACKUP || 4373 bond_mode == BOND_MODE_BROADCAST) { 4374 pr_info("xmit_hash_policy param is irrelevant in mode %s\n", 4375 bond_mode_name(bond_mode)); 4376 } else { 4377 bond_opt_initstr(&newval, xmit_hash_policy); 4378 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_XMIT_HASH), 4379 &newval); 4380 if (!valptr) { 4381 pr_err("Error: Invalid xmit_hash_policy \"%s\"\n", 4382 xmit_hash_policy); 4383 return -EINVAL; 4384 } 4385 xmit_hashtype = valptr->value; 4386 } 4387 } 4388 4389 if (lacp_rate) { 4390 if (bond_mode != BOND_MODE_8023AD) { 4391 pr_info("lacp_rate param is irrelevant in mode %s\n", 4392 bond_mode_name(bond_mode)); 4393 } else { 4394 bond_opt_initstr(&newval, lacp_rate); 4395 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_LACP_RATE), 4396 &newval); 4397 if (!valptr) { 4398 pr_err("Error: Invalid lacp rate \"%s\"\n", 4399 lacp_rate); 4400 return -EINVAL; 4401 } 4402 lacp_fast = valptr->value; 4403 } 4404 } 4405 4406 if (ad_select) { 4407 bond_opt_initstr(&newval, ad_select); 4408 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_AD_SELECT), 4409 &newval); 4410 if (!valptr) { 4411 pr_err("Error: Invalid ad_select \"%s\"\n", ad_select); 4412 return -EINVAL; 4413 } 4414 params->ad_select = valptr->value; 4415 if (bond_mode != BOND_MODE_8023AD) 4416 pr_warn("ad_select param only affects 802.3ad mode\n"); 4417 } else { 4418 params->ad_select = BOND_AD_STABLE; 4419 } 4420 4421 if (max_bonds < 0) { 4422 pr_warn("Warning: max_bonds (%d) not in range %d-%d, so it was reset to BOND_DEFAULT_MAX_BONDS (%d)\n", 4423 max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS); 4424 max_bonds = BOND_DEFAULT_MAX_BONDS; 4425 } 4426 4427 if (miimon < 0) { 4428 pr_warn("Warning: miimon module parameter (%d), not in range 0-%d, so it was reset to 0\n", 4429 miimon, INT_MAX); 4430 miimon = 0; 4431 } 4432 4433 if (updelay < 0) { 4434 pr_warn("Warning: updelay module parameter (%d), not in range 0-%d, so it was reset to 0\n", 4435 updelay, INT_MAX); 4436 updelay = 0; 4437 } 4438 4439 if (downdelay < 0) { 4440 pr_warn("Warning: downdelay module parameter (%d), not in range 0-%d, so it was reset to 0\n", 4441 downdelay, INT_MAX); 4442 downdelay = 0; 4443 } 4444 4445 if ((use_carrier != 0) && (use_carrier != 1)) { 4446 pr_warn("Warning: use_carrier module parameter (%d), not of valid value (0/1), so it was set to 1\n", 4447 use_carrier); 4448 use_carrier = 1; 4449 } 4450 4451 if (num_peer_notif < 0 || num_peer_notif > 255) { 4452 pr_warn("Warning: num_grat_arp/num_unsol_na (%d) not in range 0-255 so it was reset to 1\n", 4453 num_peer_notif); 4454 num_peer_notif = 1; 4455 } 4456 4457 /* reset values for 802.3ad/TLB/ALB */ 4458 if (!bond_mode_uses_arp(bond_mode)) { 4459 if (!miimon) { 4460 pr_warn("Warning: miimon must be specified, otherwise bonding will not detect link failure, speed and duplex which are essential for 802.3ad operation\n"); 4461 pr_warn("Forcing miimon to 100msec\n"); 4462 miimon = BOND_DEFAULT_MIIMON; 4463 } 4464 } 4465 4466 if (tx_queues < 1 || tx_queues > 255) { 4467 pr_warn("Warning: tx_queues (%d) should be between 1 and 255, resetting to %d\n", 4468 tx_queues, BOND_DEFAULT_TX_QUEUES); 4469 tx_queues = BOND_DEFAULT_TX_QUEUES; 4470 } 4471 4472 if ((all_slaves_active != 0) && (all_slaves_active != 1)) { 4473 pr_warn("Warning: all_slaves_active module parameter (%d), not of valid value (0/1), so it was set to 0\n", 4474 all_slaves_active); 4475 all_slaves_active = 0; 4476 } 4477 4478 if (resend_igmp < 0 || resend_igmp > 255) { 4479 pr_warn("Warning: resend_igmp (%d) should be between 0 and 255, resetting to %d\n", 4480 resend_igmp, BOND_DEFAULT_RESEND_IGMP); 4481 resend_igmp = BOND_DEFAULT_RESEND_IGMP; 4482 } 4483 4484 bond_opt_initval(&newval, packets_per_slave); 4485 if (!bond_opt_parse(bond_opt_get(BOND_OPT_PACKETS_PER_SLAVE), &newval)) { 4486 pr_warn("Warning: packets_per_slave (%d) should be between 0 and %u resetting to 1\n", 4487 packets_per_slave, USHRT_MAX); 4488 packets_per_slave = 1; 4489 } 4490 4491 if (bond_mode == BOND_MODE_ALB) { 4492 pr_notice("In ALB mode you might experience client disconnections upon reconnection of a link if the bonding module updelay parameter (%d msec) is incompatible with the forwarding delay time of the switch\n", 4493 updelay); 4494 } 4495 4496 if (!miimon) { 4497 if (updelay || downdelay) { 4498 /* just warn the user the up/down delay will have 4499 * no effect since miimon is zero... 4500 */ 4501 pr_warn("Warning: miimon module parameter not set and updelay (%d) or downdelay (%d) module parameter is set; updelay and downdelay have no effect unless miimon is set\n", 4502 updelay, downdelay); 4503 } 4504 } else { 4505 /* don't allow arp monitoring */ 4506 if (arp_interval) { 4507 pr_warn("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n", 4508 miimon, arp_interval); 4509 arp_interval = 0; 4510 } 4511 4512 if ((updelay % miimon) != 0) { 4513 pr_warn("Warning: updelay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n", 4514 updelay, miimon, (updelay / miimon) * miimon); 4515 } 4516 4517 updelay /= miimon; 4518 4519 if ((downdelay % miimon) != 0) { 4520 pr_warn("Warning: downdelay (%d) is not a multiple of miimon (%d), downdelay rounded to %d ms\n", 4521 downdelay, miimon, 4522 (downdelay / miimon) * miimon); 4523 } 4524 4525 downdelay /= miimon; 4526 } 4527 4528 if (arp_interval < 0) { 4529 pr_warn("Warning: arp_interval module parameter (%d), not in range 0-%d, so it was reset to 0\n", 4530 arp_interval, INT_MAX); 4531 arp_interval = 0; 4532 } 4533 4534 for (arp_ip_count = 0, i = 0; 4535 (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[i]; i++) { 4536 __be32 ip; 4537 4538 /* not a complete check, but good enough to catch mistakes */ 4539 if (!in4_pton(arp_ip_target[i], -1, (u8 *)&ip, -1, NULL) || 4540 !bond_is_ip_target_ok(ip)) { 4541 pr_warn("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n", 4542 arp_ip_target[i]); 4543 arp_interval = 0; 4544 } else { 4545 if (bond_get_targets_ip(arp_target, ip) == -1) 4546 arp_target[arp_ip_count++] = ip; 4547 else 4548 pr_warn("Warning: duplicate address %pI4 in arp_ip_target, skipping\n", 4549 &ip); 4550 } 4551 } 4552 4553 if (arp_interval && !arp_ip_count) { 4554 /* don't allow arping if no arp_ip_target given... */ 4555 pr_warn("Warning: arp_interval module parameter (%d) specified without providing an arp_ip_target parameter, arp_interval was reset to 0\n", 4556 arp_interval); 4557 arp_interval = 0; 4558 } 4559 4560 if (arp_validate) { 4561 if (!arp_interval) { 4562 pr_err("arp_validate requires arp_interval\n"); 4563 return -EINVAL; 4564 } 4565 4566 bond_opt_initstr(&newval, arp_validate); 4567 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_ARP_VALIDATE), 4568 &newval); 4569 if (!valptr) { 4570 pr_err("Error: invalid arp_validate \"%s\"\n", 4571 arp_validate); 4572 return -EINVAL; 4573 } 4574 arp_validate_value = valptr->value; 4575 } else { 4576 arp_validate_value = 0; 4577 } 4578 4579 if (arp_all_targets) { 4580 bond_opt_initstr(&newval, arp_all_targets); 4581 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_ARP_ALL_TARGETS), 4582 &newval); 4583 if (!valptr) { 4584 pr_err("Error: invalid arp_all_targets_value \"%s\"\n", 4585 arp_all_targets); 4586 arp_all_targets_value = 0; 4587 } else { 4588 arp_all_targets_value = valptr->value; 4589 } 4590 } 4591 4592 if (miimon) { 4593 pr_info("MII link monitoring set to %d ms\n", miimon); 4594 } else if (arp_interval) { 4595 valptr = bond_opt_get_val(BOND_OPT_ARP_VALIDATE, 4596 arp_validate_value); 4597 pr_info("ARP monitoring set to %d ms, validate %s, with %d target(s):", 4598 arp_interval, valptr->string, arp_ip_count); 4599 4600 for (i = 0; i < arp_ip_count; i++) 4601 pr_cont(" %s", arp_ip_target[i]); 4602 4603 pr_cont("\n"); 4604 4605 } else if (max_bonds) { 4606 /* miimon and arp_interval not set, we need one so things 4607 * work as expected, see bonding.txt for details 4608 */ 4609 pr_debug("Warning: either miimon or arp_interval and arp_ip_target module parameters must be specified, otherwise bonding will not detect link failures! see bonding.txt for details\n"); 4610 } 4611 4612 if (primary && !bond_mode_uses_primary(bond_mode)) { 4613 /* currently, using a primary only makes sense 4614 * in active backup, TLB or ALB modes 4615 */ 4616 pr_warn("Warning: %s primary device specified but has no effect in %s mode\n", 4617 primary, bond_mode_name(bond_mode)); 4618 primary = NULL; 4619 } 4620 4621 if (primary && primary_reselect) { 4622 bond_opt_initstr(&newval, primary_reselect); 4623 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_PRIMARY_RESELECT), 4624 &newval); 4625 if (!valptr) { 4626 pr_err("Error: Invalid primary_reselect \"%s\"\n", 4627 primary_reselect); 4628 return -EINVAL; 4629 } 4630 primary_reselect_value = valptr->value; 4631 } else { 4632 primary_reselect_value = BOND_PRI_RESELECT_ALWAYS; 4633 } 4634 4635 if (fail_over_mac) { 4636 bond_opt_initstr(&newval, fail_over_mac); 4637 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_FAIL_OVER_MAC), 4638 &newval); 4639 if (!valptr) { 4640 pr_err("Error: invalid fail_over_mac \"%s\"\n", 4641 fail_over_mac); 4642 return -EINVAL; 4643 } 4644 fail_over_mac_value = valptr->value; 4645 if (bond_mode != BOND_MODE_ACTIVEBACKUP) 4646 pr_warn("Warning: fail_over_mac only affects active-backup mode\n"); 4647 } else { 4648 fail_over_mac_value = BOND_FOM_NONE; 4649 } 4650 4651 bond_opt_initstr(&newval, "default"); 4652 valptr = bond_opt_parse( 4653 bond_opt_get(BOND_OPT_AD_ACTOR_SYS_PRIO), 4654 &newval); 4655 if (!valptr) { 4656 pr_err("Error: No ad_actor_sys_prio default value"); 4657 return -EINVAL; 4658 } 4659 ad_actor_sys_prio = valptr->value; 4660 4661 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_AD_USER_PORT_KEY), 4662 &newval); 4663 if (!valptr) { 4664 pr_err("Error: No ad_user_port_key default value"); 4665 return -EINVAL; 4666 } 4667 ad_user_port_key = valptr->value; 4668 4669 bond_opt_initstr(&newval, "default"); 4670 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_TLB_DYNAMIC_LB), &newval); 4671 if (!valptr) { 4672 pr_err("Error: No tlb_dynamic_lb default value"); 4673 return -EINVAL; 4674 } 4675 tlb_dynamic_lb = valptr->value; 4676 4677 if (lp_interval == 0) { 4678 pr_warn("Warning: ip_interval must be between 1 and %d, so it was reset to %d\n", 4679 INT_MAX, BOND_ALB_DEFAULT_LP_INTERVAL); 4680 lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL; 4681 } 4682 4683 /* fill params struct with the proper values */ 4684 params->mode = bond_mode; 4685 params->xmit_policy = xmit_hashtype; 4686 params->miimon = miimon; 4687 params->num_peer_notif = num_peer_notif; 4688 params->arp_interval = arp_interval; 4689 params->arp_validate = arp_validate_value; 4690 params->arp_all_targets = arp_all_targets_value; 4691 params->updelay = updelay; 4692 params->downdelay = downdelay; 4693 params->use_carrier = use_carrier; 4694 params->lacp_fast = lacp_fast; 4695 params->primary[0] = 0; 4696 params->primary_reselect = primary_reselect_value; 4697 params->fail_over_mac = fail_over_mac_value; 4698 params->tx_queues = tx_queues; 4699 params->all_slaves_active = all_slaves_active; 4700 params->resend_igmp = resend_igmp; 4701 params->min_links = min_links; 4702 params->lp_interval = lp_interval; 4703 params->packets_per_slave = packets_per_slave; 4704 params->tlb_dynamic_lb = tlb_dynamic_lb; 4705 params->ad_actor_sys_prio = ad_actor_sys_prio; 4706 eth_zero_addr(params->ad_actor_system); 4707 params->ad_user_port_key = ad_user_port_key; 4708 if (packets_per_slave > 0) { 4709 params->reciprocal_packets_per_slave = 4710 reciprocal_value(packets_per_slave); 4711 } else { 4712 /* reciprocal_packets_per_slave is unused if 4713 * packets_per_slave is 0 or 1, just initialize it 4714 */ 4715 params->reciprocal_packets_per_slave = 4716 (struct reciprocal_value) { 0 }; 4717 } 4718 4719 if (primary) { 4720 strncpy(params->primary, primary, IFNAMSIZ); 4721 params->primary[IFNAMSIZ - 1] = 0; 4722 } 4723 4724 memcpy(params->arp_targets, arp_target, sizeof(arp_target)); 4725 4726 return 0; 4727 } 4728 4729 /* Called from registration process */ 4730 static int bond_init(struct net_device *bond_dev) 4731 { 4732 struct bonding *bond = netdev_priv(bond_dev); 4733 struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id); 4734 4735 netdev_dbg(bond_dev, "Begin bond_init\n"); 4736 4737 bond->wq = alloc_ordered_workqueue(bond_dev->name, WQ_MEM_RECLAIM); 4738 if (!bond->wq) 4739 return -ENOMEM; 4740 4741 bond->nest_level = SINGLE_DEPTH_NESTING; 4742 netdev_lockdep_set_classes(bond_dev); 4743 4744 list_add_tail(&bond->bond_list, &bn->dev_list); 4745 4746 bond_prepare_sysfs_group(bond); 4747 4748 bond_debug_register(bond); 4749 4750 /* Ensure valid dev_addr */ 4751 if (is_zero_ether_addr(bond_dev->dev_addr) && 4752 bond_dev->addr_assign_type == NET_ADDR_PERM) 4753 eth_hw_addr_random(bond_dev); 4754 4755 return 0; 4756 } 4757 4758 unsigned int bond_get_num_tx_queues(void) 4759 { 4760 return tx_queues; 4761 } 4762 4763 /* Create a new bond based on the specified name and bonding parameters. 4764 * If name is NULL, obtain a suitable "bond%d" name for us. 4765 * Caller must NOT hold rtnl_lock; we need to release it here before we 4766 * set up our sysfs entries. 4767 */ 4768 int bond_create(struct net *net, const char *name) 4769 { 4770 struct net_device *bond_dev; 4771 struct bonding *bond; 4772 struct alb_bond_info *bond_info; 4773 int res; 4774 4775 rtnl_lock(); 4776 4777 bond_dev = alloc_netdev_mq(sizeof(struct bonding), 4778 name ? name : "bond%d", NET_NAME_UNKNOWN, 4779 bond_setup, tx_queues); 4780 if (!bond_dev) { 4781 pr_err("%s: eek! can't alloc netdev!\n", name); 4782 rtnl_unlock(); 4783 return -ENOMEM; 4784 } 4785 4786 /* 4787 * Initialize rx_hashtbl_used_head to RLB_NULL_INDEX. 4788 * It is set to 0 by default which is wrong. 4789 */ 4790 bond = netdev_priv(bond_dev); 4791 bond_info = &(BOND_ALB_INFO(bond)); 4792 bond_info->rx_hashtbl_used_head = RLB_NULL_INDEX; 4793 4794 dev_net_set(bond_dev, net); 4795 bond_dev->rtnl_link_ops = &bond_link_ops; 4796 4797 res = register_netdevice(bond_dev); 4798 4799 netif_carrier_off(bond_dev); 4800 4801 bond_work_init_all(bond); 4802 4803 rtnl_unlock(); 4804 if (res < 0) 4805 free_netdev(bond_dev); 4806 return res; 4807 } 4808 4809 static int __net_init bond_net_init(struct net *net) 4810 { 4811 struct bond_net *bn = net_generic(net, bond_net_id); 4812 4813 bn->net = net; 4814 INIT_LIST_HEAD(&bn->dev_list); 4815 4816 bond_create_proc_dir(bn); 4817 bond_create_sysfs(bn); 4818 4819 return 0; 4820 } 4821 4822 static void __net_exit bond_net_exit(struct net *net) 4823 { 4824 struct bond_net *bn = net_generic(net, bond_net_id); 4825 struct bonding *bond, *tmp_bond; 4826 LIST_HEAD(list); 4827 4828 bond_destroy_sysfs(bn); 4829 4830 /* Kill off any bonds created after unregistering bond rtnl ops */ 4831 rtnl_lock(); 4832 list_for_each_entry_safe(bond, tmp_bond, &bn->dev_list, bond_list) 4833 unregister_netdevice_queue(bond->dev, &list); 4834 unregister_netdevice_many(&list); 4835 rtnl_unlock(); 4836 4837 bond_destroy_proc_dir(bn); 4838 } 4839 4840 static struct pernet_operations bond_net_ops = { 4841 .init = bond_net_init, 4842 .exit = bond_net_exit, 4843 .id = &bond_net_id, 4844 .size = sizeof(struct bond_net), 4845 }; 4846 4847 static int __init bonding_init(void) 4848 { 4849 int i; 4850 int res; 4851 4852 pr_info("%s", bond_version); 4853 4854 res = bond_check_params(&bonding_defaults); 4855 if (res) 4856 goto out; 4857 4858 res = register_pernet_subsys(&bond_net_ops); 4859 if (res) 4860 goto out; 4861 4862 res = bond_netlink_init(); 4863 if (res) 4864 goto err_link; 4865 4866 bond_create_debugfs(); 4867 4868 for (i = 0; i < max_bonds; i++) { 4869 res = bond_create(&init_net, NULL); 4870 if (res) 4871 goto err; 4872 } 4873 4874 register_netdevice_notifier(&bond_netdev_notifier); 4875 out: 4876 return res; 4877 err: 4878 bond_destroy_debugfs(); 4879 bond_netlink_fini(); 4880 err_link: 4881 unregister_pernet_subsys(&bond_net_ops); 4882 goto out; 4883 4884 } 4885 4886 static void __exit bonding_exit(void) 4887 { 4888 unregister_netdevice_notifier(&bond_netdev_notifier); 4889 4890 bond_destroy_debugfs(); 4891 4892 bond_netlink_fini(); 4893 unregister_pernet_subsys(&bond_net_ops); 4894 4895 #ifdef CONFIG_NET_POLL_CONTROLLER 4896 /* Make sure we don't have an imbalance on our netpoll blocking */ 4897 WARN_ON(atomic_read(&netpoll_block_tx)); 4898 #endif 4899 } 4900 4901 module_init(bonding_init); 4902 module_exit(bonding_exit); 4903 MODULE_LICENSE("GPL"); 4904 MODULE_VERSION(DRV_VERSION); 4905 MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION); 4906 MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others"); 4907