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