1 // SPDX-License-Identifier: GPL-1.0+ 2 /* 3 * originally based on the dummy device. 4 * 5 * Copyright 1999, Thomas Davis, tadavis@lbl.gov. 6 * Based on dummy.c, and eql.c devices. 7 * 8 * bonding.c: an Ethernet Bonding driver 9 * 10 * This is useful to talk to a Cisco EtherChannel compatible equipment: 11 * Cisco 5500 12 * Sun Trunking (Solaris) 13 * Alteon AceDirector Trunks 14 * Linux Bonding 15 * and probably many L2 switches ... 16 * 17 * How it works: 18 * ifconfig bond0 ipaddress netmask up 19 * will setup a network device, with an ip address. No mac address 20 * will be assigned at this time. The hw mac address will come from 21 * the first slave bonded to the channel. All slaves will then use 22 * this hw mac address. 23 * 24 * ifconfig bond0 down 25 * will release all slaves, marking them as down. 26 * 27 * ifenslave bond0 eth0 28 * will attach eth0 to bond0 as a slave. eth0 hw mac address will either 29 * a: be used as initial mac address 30 * b: if a hw mac address already is there, eth0's hw mac address 31 * will then be set from bond0. 32 * 33 */ 34 35 #include <linux/kernel.h> 36 #include <linux/module.h> 37 #include <linux/types.h> 38 #include <linux/fcntl.h> 39 #include <linux/filter.h> 40 #include <linux/interrupt.h> 41 #include <linux/ptrace.h> 42 #include <linux/ioport.h> 43 #include <linux/in.h> 44 #include <net/ip.h> 45 #include <linux/ip.h> 46 #include <linux/icmp.h> 47 #include <linux/icmpv6.h> 48 #include <linux/tcp.h> 49 #include <linux/udp.h> 50 #include <linux/slab.h> 51 #include <linux/string.h> 52 #include <linux/init.h> 53 #include <linux/timer.h> 54 #include <linux/socket.h> 55 #include <linux/ctype.h> 56 #include <linux/inet.h> 57 #include <linux/bitops.h> 58 #include <linux/io.h> 59 #include <asm/dma.h> 60 #include <linux/uaccess.h> 61 #include <linux/errno.h> 62 #include <linux/netdevice.h> 63 #include <linux/inetdevice.h> 64 #include <linux/igmp.h> 65 #include <linux/etherdevice.h> 66 #include <linux/skbuff.h> 67 #include <net/sock.h> 68 #include <linux/rtnetlink.h> 69 #include <linux/smp.h> 70 #include <linux/if_ether.h> 71 #include <net/arp.h> 72 #include <linux/mii.h> 73 #include <linux/ethtool.h> 74 #include <linux/if_vlan.h> 75 #include <linux/if_bonding.h> 76 #include <linux/phy.h> 77 #include <linux/jiffies.h> 78 #include <linux/preempt.h> 79 #include <net/route.h> 80 #include <net/net_namespace.h> 81 #include <net/netns/generic.h> 82 #include <net/pkt_sched.h> 83 #include <linux/rculist.h> 84 #include <net/flow_dissector.h> 85 #include <net/xfrm.h> 86 #include <net/bonding.h> 87 #include <net/bond_3ad.h> 88 #include <net/bond_alb.h> 89 #if IS_ENABLED(CONFIG_TLS_DEVICE) 90 #include <net/tls.h> 91 #endif 92 #include <net/ip6_route.h> 93 #include <net/xdp.h> 94 95 #include "bonding_priv.h" 96 97 /*---------------------------- Module parameters ----------------------------*/ 98 99 /* monitor all links that often (in milliseconds). <=0 disables monitoring */ 100 101 static int max_bonds = BOND_DEFAULT_MAX_BONDS; 102 static int tx_queues = BOND_DEFAULT_TX_QUEUES; 103 static int num_peer_notif = 1; 104 static int miimon; 105 static int updelay; 106 static int downdelay; 107 static int use_carrier = 1; 108 static char *mode; 109 static char *primary; 110 static char *primary_reselect; 111 static char *lacp_rate; 112 static int min_links; 113 static char *ad_select; 114 static char *xmit_hash_policy; 115 static int arp_interval; 116 static char *arp_ip_target[BOND_MAX_ARP_TARGETS]; 117 static char *arp_validate; 118 static char *arp_all_targets; 119 static char *fail_over_mac; 120 static int all_slaves_active; 121 static struct bond_params bonding_defaults; 122 static int resend_igmp = BOND_DEFAULT_RESEND_IGMP; 123 static int packets_per_slave = 1; 124 static int lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL; 125 126 module_param(max_bonds, int, 0); 127 MODULE_PARM_DESC(max_bonds, "Max number of bonded devices"); 128 module_param(tx_queues, int, 0); 129 MODULE_PARM_DESC(tx_queues, "Max number of transmit queues (default = 16)"); 130 module_param_named(num_grat_arp, num_peer_notif, int, 0644); 131 MODULE_PARM_DESC(num_grat_arp, "Number of peer notifications to send on " 132 "failover event (alias of num_unsol_na)"); 133 module_param_named(num_unsol_na, num_peer_notif, int, 0644); 134 MODULE_PARM_DESC(num_unsol_na, "Number of peer notifications to send on " 135 "failover event (alias of num_grat_arp)"); 136 module_param(miimon, int, 0); 137 MODULE_PARM_DESC(miimon, "Link check interval in milliseconds"); 138 module_param(updelay, int, 0); 139 MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds"); 140 module_param(downdelay, int, 0); 141 MODULE_PARM_DESC(downdelay, "Delay before considering link down, " 142 "in milliseconds"); 143 module_param(use_carrier, int, 0); 144 MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; " 145 "0 for off, 1 for on (default)"); 146 module_param(mode, charp, 0); 147 MODULE_PARM_DESC(mode, "Mode of operation; 0 for balance-rr, " 148 "1 for active-backup, 2 for balance-xor, " 149 "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, " 150 "6 for balance-alb"); 151 module_param(primary, charp, 0); 152 MODULE_PARM_DESC(primary, "Primary network device to use"); 153 module_param(primary_reselect, charp, 0); 154 MODULE_PARM_DESC(primary_reselect, "Reselect primary slave " 155 "once it comes up; " 156 "0 for always (default), " 157 "1 for only if speed of primary is " 158 "better, " 159 "2 for only on active slave " 160 "failure"); 161 module_param(lacp_rate, charp, 0); 162 MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner; " 163 "0 for slow, 1 for fast"); 164 module_param(ad_select, charp, 0); 165 MODULE_PARM_DESC(ad_select, "802.3ad aggregation selection logic; " 166 "0 for stable (default), 1 for bandwidth, " 167 "2 for count"); 168 module_param(min_links, int, 0); 169 MODULE_PARM_DESC(min_links, "Minimum number of available links before turning on carrier"); 170 171 module_param(xmit_hash_policy, charp, 0); 172 MODULE_PARM_DESC(xmit_hash_policy, "balance-alb, balance-tlb, balance-xor, 802.3ad hashing method; " 173 "0 for layer 2 (default), 1 for layer 3+4, " 174 "2 for layer 2+3, 3 for encap layer 2+3, " 175 "4 for encap layer 3+4, 5 for vlan+srcmac"); 176 module_param(arp_interval, int, 0); 177 MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds"); 178 module_param_array(arp_ip_target, charp, NULL, 0); 179 MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form"); 180 module_param(arp_validate, charp, 0); 181 MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes; " 182 "0 for none (default), 1 for active, " 183 "2 for backup, 3 for all"); 184 module_param(arp_all_targets, charp, 0); 185 MODULE_PARM_DESC(arp_all_targets, "fail on any/all arp targets timeout; 0 for any (default), 1 for all"); 186 module_param(fail_over_mac, charp, 0); 187 MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to " 188 "the same MAC; 0 for none (default), " 189 "1 for active, 2 for follow"); 190 module_param(all_slaves_active, int, 0); 191 MODULE_PARM_DESC(all_slaves_active, "Keep all frames received on an interface " 192 "by setting active flag for all slaves; " 193 "0 for never (default), 1 for always."); 194 module_param(resend_igmp, int, 0); 195 MODULE_PARM_DESC(resend_igmp, "Number of IGMP membership reports to send on " 196 "link failure"); 197 module_param(packets_per_slave, int, 0); 198 MODULE_PARM_DESC(packets_per_slave, "Packets to send per slave in balance-rr " 199 "mode; 0 for a random slave, 1 packet per " 200 "slave (default), >1 packets per slave."); 201 module_param(lp_interval, uint, 0); 202 MODULE_PARM_DESC(lp_interval, "The number of seconds between instances where " 203 "the bonding driver sends learning packets to " 204 "each slaves peer switch. The default is 1."); 205 206 /*----------------------------- Global variables ----------------------------*/ 207 208 #ifdef CONFIG_NET_POLL_CONTROLLER 209 atomic_t netpoll_block_tx = ATOMIC_INIT(0); 210 #endif 211 212 unsigned int bond_net_id __read_mostly; 213 214 static const struct flow_dissector_key flow_keys_bonding_keys[] = { 215 { 216 .key_id = FLOW_DISSECTOR_KEY_CONTROL, 217 .offset = offsetof(struct flow_keys, control), 218 }, 219 { 220 .key_id = FLOW_DISSECTOR_KEY_BASIC, 221 .offset = offsetof(struct flow_keys, basic), 222 }, 223 { 224 .key_id = FLOW_DISSECTOR_KEY_IPV4_ADDRS, 225 .offset = offsetof(struct flow_keys, addrs.v4addrs), 226 }, 227 { 228 .key_id = FLOW_DISSECTOR_KEY_IPV6_ADDRS, 229 .offset = offsetof(struct flow_keys, addrs.v6addrs), 230 }, 231 { 232 .key_id = FLOW_DISSECTOR_KEY_TIPC, 233 .offset = offsetof(struct flow_keys, addrs.tipckey), 234 }, 235 { 236 .key_id = FLOW_DISSECTOR_KEY_PORTS, 237 .offset = offsetof(struct flow_keys, ports), 238 }, 239 { 240 .key_id = FLOW_DISSECTOR_KEY_ICMP, 241 .offset = offsetof(struct flow_keys, icmp), 242 }, 243 { 244 .key_id = FLOW_DISSECTOR_KEY_VLAN, 245 .offset = offsetof(struct flow_keys, vlan), 246 }, 247 { 248 .key_id = FLOW_DISSECTOR_KEY_FLOW_LABEL, 249 .offset = offsetof(struct flow_keys, tags), 250 }, 251 { 252 .key_id = FLOW_DISSECTOR_KEY_GRE_KEYID, 253 .offset = offsetof(struct flow_keys, keyid), 254 }, 255 }; 256 257 static struct flow_dissector flow_keys_bonding __read_mostly; 258 259 /*-------------------------- Forward declarations ---------------------------*/ 260 261 static int bond_init(struct net_device *bond_dev); 262 static void bond_uninit(struct net_device *bond_dev); 263 static void bond_get_stats(struct net_device *bond_dev, 264 struct rtnl_link_stats64 *stats); 265 static void bond_slave_arr_handler(struct work_struct *work); 266 static bool bond_time_in_interval(struct bonding *bond, unsigned long last_act, 267 int mod); 268 static void bond_netdev_notify_work(struct work_struct *work); 269 270 /*---------------------------- General routines -----------------------------*/ 271 272 const char *bond_mode_name(int mode) 273 { 274 static const char *names[] = { 275 [BOND_MODE_ROUNDROBIN] = "load balancing (round-robin)", 276 [BOND_MODE_ACTIVEBACKUP] = "fault-tolerance (active-backup)", 277 [BOND_MODE_XOR] = "load balancing (xor)", 278 [BOND_MODE_BROADCAST] = "fault-tolerance (broadcast)", 279 [BOND_MODE_8023AD] = "IEEE 802.3ad Dynamic link aggregation", 280 [BOND_MODE_TLB] = "transmit load balancing", 281 [BOND_MODE_ALB] = "adaptive load balancing", 282 }; 283 284 if (mode < BOND_MODE_ROUNDROBIN || mode > BOND_MODE_ALB) 285 return "unknown"; 286 287 return names[mode]; 288 } 289 290 /** 291 * bond_dev_queue_xmit - Prepare skb for xmit. 292 * 293 * @bond: bond device that got this skb for tx. 294 * @skb: hw accel VLAN tagged skb to transmit 295 * @slave_dev: slave that is supposed to xmit this skbuff 296 */ 297 netdev_tx_t bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, 298 struct net_device *slave_dev) 299 { 300 skb->dev = slave_dev; 301 302 BUILD_BUG_ON(sizeof(skb->queue_mapping) != 303 sizeof(qdisc_skb_cb(skb)->slave_dev_queue_mapping)); 304 skb_set_queue_mapping(skb, qdisc_skb_cb(skb)->slave_dev_queue_mapping); 305 306 if (unlikely(netpoll_tx_running(bond->dev))) 307 return bond_netpoll_send_skb(bond_get_slave_by_dev(bond, slave_dev), skb); 308 309 return dev_queue_xmit(skb); 310 } 311 312 static bool bond_sk_check(struct bonding *bond) 313 { 314 switch (BOND_MODE(bond)) { 315 case BOND_MODE_8023AD: 316 case BOND_MODE_XOR: 317 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34) 318 return true; 319 fallthrough; 320 default: 321 return false; 322 } 323 } 324 325 static bool bond_xdp_check(struct bonding *bond) 326 { 327 switch (BOND_MODE(bond)) { 328 case BOND_MODE_ROUNDROBIN: 329 case BOND_MODE_ACTIVEBACKUP: 330 return true; 331 case BOND_MODE_8023AD: 332 case BOND_MODE_XOR: 333 /* vlan+srcmac is not supported with XDP as in most cases the 802.1q 334 * payload is not in the packet due to hardware offload. 335 */ 336 if (bond->params.xmit_policy != BOND_XMIT_POLICY_VLAN_SRCMAC) 337 return true; 338 fallthrough; 339 default: 340 return false; 341 } 342 } 343 344 /*---------------------------------- VLAN -----------------------------------*/ 345 346 /* In the following 2 functions, bond_vlan_rx_add_vid and bond_vlan_rx_kill_vid, 347 * We don't protect the slave list iteration with a lock because: 348 * a. This operation is performed in IOCTL context, 349 * b. The operation is protected by the RTNL semaphore in the 8021q code, 350 * c. Holding a lock with BH disabled while directly calling a base driver 351 * entry point is generally a BAD idea. 352 * 353 * The design of synchronization/protection for this operation in the 8021q 354 * module is good for one or more VLAN devices over a single physical device 355 * and cannot be extended for a teaming solution like bonding, so there is a 356 * potential race condition here where a net device from the vlan group might 357 * be referenced (either by a base driver or the 8021q code) while it is being 358 * removed from the system. However, it turns out we're not making matters 359 * worse, and if it works for regular VLAN usage it will work here too. 360 */ 361 362 /** 363 * bond_vlan_rx_add_vid - Propagates adding an id to slaves 364 * @bond_dev: bonding net device that got called 365 * @proto: network protocol ID 366 * @vid: vlan id being added 367 */ 368 static int bond_vlan_rx_add_vid(struct net_device *bond_dev, 369 __be16 proto, u16 vid) 370 { 371 struct bonding *bond = netdev_priv(bond_dev); 372 struct slave *slave, *rollback_slave; 373 struct list_head *iter; 374 int res; 375 376 bond_for_each_slave(bond, slave, iter) { 377 res = vlan_vid_add(slave->dev, proto, vid); 378 if (res) 379 goto unwind; 380 } 381 382 return 0; 383 384 unwind: 385 /* unwind to the slave that failed */ 386 bond_for_each_slave(bond, rollback_slave, iter) { 387 if (rollback_slave == slave) 388 break; 389 390 vlan_vid_del(rollback_slave->dev, proto, vid); 391 } 392 393 return res; 394 } 395 396 /** 397 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves 398 * @bond_dev: bonding net device that got called 399 * @proto: network protocol ID 400 * @vid: vlan id being removed 401 */ 402 static int bond_vlan_rx_kill_vid(struct net_device *bond_dev, 403 __be16 proto, u16 vid) 404 { 405 struct bonding *bond = netdev_priv(bond_dev); 406 struct list_head *iter; 407 struct slave *slave; 408 409 bond_for_each_slave(bond, slave, iter) 410 vlan_vid_del(slave->dev, proto, vid); 411 412 if (bond_is_lb(bond)) 413 bond_alb_clear_vlan(bond, vid); 414 415 return 0; 416 } 417 418 /*---------------------------------- XFRM -----------------------------------*/ 419 420 #ifdef CONFIG_XFRM_OFFLOAD 421 /** 422 * bond_ipsec_add_sa - program device with a security association 423 * @xs: pointer to transformer state struct 424 * @extack: extack point to fill failure reason 425 **/ 426 static int bond_ipsec_add_sa(struct xfrm_state *xs, 427 struct netlink_ext_ack *extack) 428 { 429 struct net_device *bond_dev = xs->xso.dev; 430 struct bond_ipsec *ipsec; 431 struct bonding *bond; 432 struct slave *slave; 433 int err; 434 435 if (!bond_dev) 436 return -EINVAL; 437 438 rcu_read_lock(); 439 bond = netdev_priv(bond_dev); 440 slave = rcu_dereference(bond->curr_active_slave); 441 if (!slave) { 442 rcu_read_unlock(); 443 return -ENODEV; 444 } 445 446 if (!slave->dev->xfrmdev_ops || 447 !slave->dev->xfrmdev_ops->xdo_dev_state_add || 448 netif_is_bond_master(slave->dev)) { 449 NL_SET_ERR_MSG_MOD(extack, "Slave does not support ipsec offload"); 450 rcu_read_unlock(); 451 return -EINVAL; 452 } 453 454 ipsec = kmalloc(sizeof(*ipsec), GFP_ATOMIC); 455 if (!ipsec) { 456 rcu_read_unlock(); 457 return -ENOMEM; 458 } 459 xs->xso.real_dev = slave->dev; 460 461 err = slave->dev->xfrmdev_ops->xdo_dev_state_add(xs, extack); 462 if (!err) { 463 ipsec->xs = xs; 464 INIT_LIST_HEAD(&ipsec->list); 465 spin_lock_bh(&bond->ipsec_lock); 466 list_add(&ipsec->list, &bond->ipsec_list); 467 spin_unlock_bh(&bond->ipsec_lock); 468 } else { 469 kfree(ipsec); 470 } 471 rcu_read_unlock(); 472 return err; 473 } 474 475 static void bond_ipsec_add_sa_all(struct bonding *bond) 476 { 477 struct net_device *bond_dev = bond->dev; 478 struct bond_ipsec *ipsec; 479 struct slave *slave; 480 481 rcu_read_lock(); 482 slave = rcu_dereference(bond->curr_active_slave); 483 if (!slave) 484 goto out; 485 486 if (!slave->dev->xfrmdev_ops || 487 !slave->dev->xfrmdev_ops->xdo_dev_state_add || 488 netif_is_bond_master(slave->dev)) { 489 spin_lock_bh(&bond->ipsec_lock); 490 if (!list_empty(&bond->ipsec_list)) 491 slave_warn(bond_dev, slave->dev, 492 "%s: no slave xdo_dev_state_add\n", 493 __func__); 494 spin_unlock_bh(&bond->ipsec_lock); 495 goto out; 496 } 497 498 spin_lock_bh(&bond->ipsec_lock); 499 list_for_each_entry(ipsec, &bond->ipsec_list, list) { 500 ipsec->xs->xso.real_dev = slave->dev; 501 if (slave->dev->xfrmdev_ops->xdo_dev_state_add(ipsec->xs, NULL)) { 502 slave_warn(bond_dev, slave->dev, "%s: failed to add SA\n", __func__); 503 ipsec->xs->xso.real_dev = NULL; 504 } 505 } 506 spin_unlock_bh(&bond->ipsec_lock); 507 out: 508 rcu_read_unlock(); 509 } 510 511 /** 512 * bond_ipsec_del_sa - clear out this specific SA 513 * @xs: pointer to transformer state struct 514 **/ 515 static void bond_ipsec_del_sa(struct xfrm_state *xs) 516 { 517 struct net_device *bond_dev = xs->xso.dev; 518 struct bond_ipsec *ipsec; 519 struct bonding *bond; 520 struct slave *slave; 521 522 if (!bond_dev) 523 return; 524 525 rcu_read_lock(); 526 bond = netdev_priv(bond_dev); 527 slave = rcu_dereference(bond->curr_active_slave); 528 529 if (!slave) 530 goto out; 531 532 if (!xs->xso.real_dev) 533 goto out; 534 535 WARN_ON(xs->xso.real_dev != slave->dev); 536 537 if (!slave->dev->xfrmdev_ops || 538 !slave->dev->xfrmdev_ops->xdo_dev_state_delete || 539 netif_is_bond_master(slave->dev)) { 540 slave_warn(bond_dev, slave->dev, "%s: no slave xdo_dev_state_delete\n", __func__); 541 goto out; 542 } 543 544 slave->dev->xfrmdev_ops->xdo_dev_state_delete(xs); 545 out: 546 spin_lock_bh(&bond->ipsec_lock); 547 list_for_each_entry(ipsec, &bond->ipsec_list, list) { 548 if (ipsec->xs == xs) { 549 list_del(&ipsec->list); 550 kfree(ipsec); 551 break; 552 } 553 } 554 spin_unlock_bh(&bond->ipsec_lock); 555 rcu_read_unlock(); 556 } 557 558 static void bond_ipsec_del_sa_all(struct bonding *bond) 559 { 560 struct net_device *bond_dev = bond->dev; 561 struct bond_ipsec *ipsec; 562 struct slave *slave; 563 564 rcu_read_lock(); 565 slave = rcu_dereference(bond->curr_active_slave); 566 if (!slave) { 567 rcu_read_unlock(); 568 return; 569 } 570 571 spin_lock_bh(&bond->ipsec_lock); 572 list_for_each_entry(ipsec, &bond->ipsec_list, list) { 573 if (!ipsec->xs->xso.real_dev) 574 continue; 575 576 if (!slave->dev->xfrmdev_ops || 577 !slave->dev->xfrmdev_ops->xdo_dev_state_delete || 578 netif_is_bond_master(slave->dev)) { 579 slave_warn(bond_dev, slave->dev, 580 "%s: no slave xdo_dev_state_delete\n", 581 __func__); 582 } else { 583 slave->dev->xfrmdev_ops->xdo_dev_state_delete(ipsec->xs); 584 } 585 ipsec->xs->xso.real_dev = NULL; 586 } 587 spin_unlock_bh(&bond->ipsec_lock); 588 rcu_read_unlock(); 589 } 590 591 /** 592 * bond_ipsec_offload_ok - can this packet use the xfrm hw offload 593 * @skb: current data packet 594 * @xs: pointer to transformer state struct 595 **/ 596 static bool bond_ipsec_offload_ok(struct sk_buff *skb, struct xfrm_state *xs) 597 { 598 struct net_device *bond_dev = xs->xso.dev; 599 struct net_device *real_dev; 600 struct slave *curr_active; 601 struct bonding *bond; 602 int err; 603 604 bond = netdev_priv(bond_dev); 605 rcu_read_lock(); 606 curr_active = rcu_dereference(bond->curr_active_slave); 607 real_dev = curr_active->dev; 608 609 if (BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 610 err = false; 611 goto out; 612 } 613 614 if (!xs->xso.real_dev) { 615 err = false; 616 goto out; 617 } 618 619 if (!real_dev->xfrmdev_ops || 620 !real_dev->xfrmdev_ops->xdo_dev_offload_ok || 621 netif_is_bond_master(real_dev)) { 622 err = false; 623 goto out; 624 } 625 626 err = real_dev->xfrmdev_ops->xdo_dev_offload_ok(skb, xs); 627 out: 628 rcu_read_unlock(); 629 return err; 630 } 631 632 static const struct xfrmdev_ops bond_xfrmdev_ops = { 633 .xdo_dev_state_add = bond_ipsec_add_sa, 634 .xdo_dev_state_delete = bond_ipsec_del_sa, 635 .xdo_dev_offload_ok = bond_ipsec_offload_ok, 636 }; 637 #endif /* CONFIG_XFRM_OFFLOAD */ 638 639 /*------------------------------- Link status -------------------------------*/ 640 641 /* Set the carrier state for the master according to the state of its 642 * slaves. If any slaves are up, the master is up. In 802.3ad mode, 643 * do special 802.3ad magic. 644 * 645 * Returns zero if carrier state does not change, nonzero if it does. 646 */ 647 int bond_set_carrier(struct bonding *bond) 648 { 649 struct list_head *iter; 650 struct slave *slave; 651 652 if (!bond_has_slaves(bond)) 653 goto down; 654 655 if (BOND_MODE(bond) == BOND_MODE_8023AD) 656 return bond_3ad_set_carrier(bond); 657 658 bond_for_each_slave(bond, slave, iter) { 659 if (slave->link == BOND_LINK_UP) { 660 if (!netif_carrier_ok(bond->dev)) { 661 netif_carrier_on(bond->dev); 662 return 1; 663 } 664 return 0; 665 } 666 } 667 668 down: 669 if (netif_carrier_ok(bond->dev)) { 670 netif_carrier_off(bond->dev); 671 return 1; 672 } 673 return 0; 674 } 675 676 /* Get link speed and duplex from the slave's base driver 677 * using ethtool. If for some reason the call fails or the 678 * values are invalid, set speed and duplex to -1, 679 * and return. Return 1 if speed or duplex settings are 680 * UNKNOWN; 0 otherwise. 681 */ 682 static int bond_update_speed_duplex(struct slave *slave) 683 { 684 struct net_device *slave_dev = slave->dev; 685 struct ethtool_link_ksettings ecmd; 686 int res; 687 688 slave->speed = SPEED_UNKNOWN; 689 slave->duplex = DUPLEX_UNKNOWN; 690 691 res = __ethtool_get_link_ksettings(slave_dev, &ecmd); 692 if (res < 0) 693 return 1; 694 if (ecmd.base.speed == 0 || ecmd.base.speed == ((__u32)-1)) 695 return 1; 696 switch (ecmd.base.duplex) { 697 case DUPLEX_FULL: 698 case DUPLEX_HALF: 699 break; 700 default: 701 return 1; 702 } 703 704 slave->speed = ecmd.base.speed; 705 slave->duplex = ecmd.base.duplex; 706 707 return 0; 708 } 709 710 const char *bond_slave_link_status(s8 link) 711 { 712 switch (link) { 713 case BOND_LINK_UP: 714 return "up"; 715 case BOND_LINK_FAIL: 716 return "going down"; 717 case BOND_LINK_DOWN: 718 return "down"; 719 case BOND_LINK_BACK: 720 return "going back"; 721 default: 722 return "unknown"; 723 } 724 } 725 726 /* if <dev> supports MII link status reporting, check its link status. 727 * 728 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(), 729 * depending upon the setting of the use_carrier parameter. 730 * 731 * Return either BMSR_LSTATUS, meaning that the link is up (or we 732 * can't tell and just pretend it is), or 0, meaning that the link is 733 * down. 734 * 735 * If reporting is non-zero, instead of faking link up, return -1 if 736 * both ETHTOOL and MII ioctls fail (meaning the device does not 737 * support them). If use_carrier is set, return whatever it says. 738 * It'd be nice if there was a good way to tell if a driver supports 739 * netif_carrier, but there really isn't. 740 */ 741 static int bond_check_dev_link(struct bonding *bond, 742 struct net_device *slave_dev, int reporting) 743 { 744 const struct net_device_ops *slave_ops = slave_dev->netdev_ops; 745 int (*ioctl)(struct net_device *, struct ifreq *, int); 746 struct ifreq ifr; 747 struct mii_ioctl_data *mii; 748 749 if (!reporting && !netif_running(slave_dev)) 750 return 0; 751 752 if (bond->params.use_carrier) 753 return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0; 754 755 /* Try to get link status using Ethtool first. */ 756 if (slave_dev->ethtool_ops->get_link) 757 return slave_dev->ethtool_ops->get_link(slave_dev) ? 758 BMSR_LSTATUS : 0; 759 760 /* Ethtool can't be used, fallback to MII ioctls. */ 761 ioctl = slave_ops->ndo_eth_ioctl; 762 if (ioctl) { 763 /* TODO: set pointer to correct ioctl on a per team member 764 * bases to make this more efficient. that is, once 765 * we determine the correct ioctl, we will always 766 * call it and not the others for that team 767 * member. 768 */ 769 770 /* We cannot assume that SIOCGMIIPHY will also read a 771 * register; not all network drivers (e.g., e100) 772 * support that. 773 */ 774 775 /* Yes, the mii is overlaid on the ifreq.ifr_ifru */ 776 strscpy_pad(ifr.ifr_name, slave_dev->name, IFNAMSIZ); 777 mii = if_mii(&ifr); 778 if (ioctl(slave_dev, &ifr, SIOCGMIIPHY) == 0) { 779 mii->reg_num = MII_BMSR; 780 if (ioctl(slave_dev, &ifr, SIOCGMIIREG) == 0) 781 return mii->val_out & BMSR_LSTATUS; 782 } 783 } 784 785 /* If reporting, report that either there's no ndo_eth_ioctl, 786 * or both SIOCGMIIREG and get_link failed (meaning that we 787 * cannot report link status). If not reporting, pretend 788 * we're ok. 789 */ 790 return reporting ? -1 : BMSR_LSTATUS; 791 } 792 793 /*----------------------------- Multicast list ------------------------------*/ 794 795 /* Push the promiscuity flag down to appropriate slaves */ 796 static int bond_set_promiscuity(struct bonding *bond, int inc) 797 { 798 struct list_head *iter; 799 int err = 0; 800 801 if (bond_uses_primary(bond)) { 802 struct slave *curr_active = rtnl_dereference(bond->curr_active_slave); 803 804 if (curr_active) 805 err = dev_set_promiscuity(curr_active->dev, inc); 806 } else { 807 struct slave *slave; 808 809 bond_for_each_slave(bond, slave, iter) { 810 err = dev_set_promiscuity(slave->dev, inc); 811 if (err) 812 return err; 813 } 814 } 815 return err; 816 } 817 818 /* Push the allmulti flag down to all slaves */ 819 static int bond_set_allmulti(struct bonding *bond, int inc) 820 { 821 struct list_head *iter; 822 int err = 0; 823 824 if (bond_uses_primary(bond)) { 825 struct slave *curr_active = rtnl_dereference(bond->curr_active_slave); 826 827 if (curr_active) 828 err = dev_set_allmulti(curr_active->dev, inc); 829 } else { 830 struct slave *slave; 831 832 bond_for_each_slave(bond, slave, iter) { 833 err = dev_set_allmulti(slave->dev, inc); 834 if (err) 835 return err; 836 } 837 } 838 return err; 839 } 840 841 /* Retrieve the list of registered multicast addresses for the bonding 842 * device and retransmit an IGMP JOIN request to the current active 843 * slave. 844 */ 845 static void bond_resend_igmp_join_requests_delayed(struct work_struct *work) 846 { 847 struct bonding *bond = container_of(work, struct bonding, 848 mcast_work.work); 849 850 if (!rtnl_trylock()) { 851 queue_delayed_work(bond->wq, &bond->mcast_work, 1); 852 return; 853 } 854 call_netdevice_notifiers(NETDEV_RESEND_IGMP, bond->dev); 855 856 if (bond->igmp_retrans > 1) { 857 bond->igmp_retrans--; 858 queue_delayed_work(bond->wq, &bond->mcast_work, HZ/5); 859 } 860 rtnl_unlock(); 861 } 862 863 /* Flush bond's hardware addresses from slave */ 864 static void bond_hw_addr_flush(struct net_device *bond_dev, 865 struct net_device *slave_dev) 866 { 867 struct bonding *bond = netdev_priv(bond_dev); 868 869 dev_uc_unsync(slave_dev, bond_dev); 870 dev_mc_unsync(slave_dev, bond_dev); 871 872 if (BOND_MODE(bond) == BOND_MODE_8023AD) 873 dev_mc_del(slave_dev, lacpdu_mcast_addr); 874 } 875 876 /*--------------------------- Active slave change ---------------------------*/ 877 878 /* Update the hardware address list and promisc/allmulti for the new and 879 * old active slaves (if any). Modes that are not using primary keep all 880 * slaves up date at all times; only the modes that use primary need to call 881 * this function to swap these settings during a failover. 882 */ 883 static void bond_hw_addr_swap(struct bonding *bond, struct slave *new_active, 884 struct slave *old_active) 885 { 886 if (old_active) { 887 if (bond->dev->flags & IFF_PROMISC) 888 dev_set_promiscuity(old_active->dev, -1); 889 890 if (bond->dev->flags & IFF_ALLMULTI) 891 dev_set_allmulti(old_active->dev, -1); 892 893 if (bond->dev->flags & IFF_UP) 894 bond_hw_addr_flush(bond->dev, old_active->dev); 895 } 896 897 if (new_active) { 898 /* FIXME: Signal errors upstream. */ 899 if (bond->dev->flags & IFF_PROMISC) 900 dev_set_promiscuity(new_active->dev, 1); 901 902 if (bond->dev->flags & IFF_ALLMULTI) 903 dev_set_allmulti(new_active->dev, 1); 904 905 if (bond->dev->flags & IFF_UP) { 906 netif_addr_lock_bh(bond->dev); 907 dev_uc_sync(new_active->dev, bond->dev); 908 dev_mc_sync(new_active->dev, bond->dev); 909 netif_addr_unlock_bh(bond->dev); 910 } 911 } 912 } 913 914 /** 915 * bond_set_dev_addr - clone slave's address to bond 916 * @bond_dev: bond net device 917 * @slave_dev: slave net device 918 * 919 * Should be called with RTNL held. 920 */ 921 static int bond_set_dev_addr(struct net_device *bond_dev, 922 struct net_device *slave_dev) 923 { 924 int err; 925 926 slave_dbg(bond_dev, slave_dev, "bond_dev=%p slave_dev=%p slave_dev->addr_len=%d\n", 927 bond_dev, slave_dev, slave_dev->addr_len); 928 err = dev_pre_changeaddr_notify(bond_dev, slave_dev->dev_addr, NULL); 929 if (err) 930 return err; 931 932 __dev_addr_set(bond_dev, slave_dev->dev_addr, slave_dev->addr_len); 933 bond_dev->addr_assign_type = NET_ADDR_STOLEN; 934 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev); 935 return 0; 936 } 937 938 static struct slave *bond_get_old_active(struct bonding *bond, 939 struct slave *new_active) 940 { 941 struct slave *slave; 942 struct list_head *iter; 943 944 bond_for_each_slave(bond, slave, iter) { 945 if (slave == new_active) 946 continue; 947 948 if (ether_addr_equal(bond->dev->dev_addr, slave->dev->dev_addr)) 949 return slave; 950 } 951 952 return NULL; 953 } 954 955 /* bond_do_fail_over_mac 956 * 957 * Perform special MAC address swapping for fail_over_mac settings 958 * 959 * Called with RTNL 960 */ 961 static void bond_do_fail_over_mac(struct bonding *bond, 962 struct slave *new_active, 963 struct slave *old_active) 964 { 965 u8 tmp_mac[MAX_ADDR_LEN]; 966 struct sockaddr_storage ss; 967 int rv; 968 969 switch (bond->params.fail_over_mac) { 970 case BOND_FOM_ACTIVE: 971 if (new_active) { 972 rv = bond_set_dev_addr(bond->dev, new_active->dev); 973 if (rv) 974 slave_err(bond->dev, new_active->dev, "Error %d setting bond MAC from slave\n", 975 -rv); 976 } 977 break; 978 case BOND_FOM_FOLLOW: 979 /* if new_active && old_active, swap them 980 * if just old_active, do nothing (going to no active slave) 981 * if just new_active, set new_active to bond's MAC 982 */ 983 if (!new_active) 984 return; 985 986 if (!old_active) 987 old_active = bond_get_old_active(bond, new_active); 988 989 if (old_active) { 990 bond_hw_addr_copy(tmp_mac, new_active->dev->dev_addr, 991 new_active->dev->addr_len); 992 bond_hw_addr_copy(ss.__data, 993 old_active->dev->dev_addr, 994 old_active->dev->addr_len); 995 ss.ss_family = new_active->dev->type; 996 } else { 997 bond_hw_addr_copy(ss.__data, bond->dev->dev_addr, 998 bond->dev->addr_len); 999 ss.ss_family = bond->dev->type; 1000 } 1001 1002 rv = dev_set_mac_address(new_active->dev, 1003 (struct sockaddr *)&ss, NULL); 1004 if (rv) { 1005 slave_err(bond->dev, new_active->dev, "Error %d setting MAC of new active slave\n", 1006 -rv); 1007 goto out; 1008 } 1009 1010 if (!old_active) 1011 goto out; 1012 1013 bond_hw_addr_copy(ss.__data, tmp_mac, 1014 new_active->dev->addr_len); 1015 ss.ss_family = old_active->dev->type; 1016 1017 rv = dev_set_mac_address(old_active->dev, 1018 (struct sockaddr *)&ss, NULL); 1019 if (rv) 1020 slave_err(bond->dev, old_active->dev, "Error %d setting MAC of old active slave\n", 1021 -rv); 1022 out: 1023 break; 1024 default: 1025 netdev_err(bond->dev, "bond_do_fail_over_mac impossible: bad policy %d\n", 1026 bond->params.fail_over_mac); 1027 break; 1028 } 1029 1030 } 1031 1032 /** 1033 * bond_choose_primary_or_current - select the primary or high priority slave 1034 * @bond: our bonding struct 1035 * 1036 * - Check if there is a primary link. If the primary link was set and is up, 1037 * go on and do link reselection. 1038 * 1039 * - If primary link is not set or down, find the highest priority link. 1040 * If the highest priority link is not current slave, set it as primary 1041 * link and do link reselection. 1042 */ 1043 static struct slave *bond_choose_primary_or_current(struct bonding *bond) 1044 { 1045 struct slave *prim = rtnl_dereference(bond->primary_slave); 1046 struct slave *curr = rtnl_dereference(bond->curr_active_slave); 1047 struct slave *slave, *hprio = NULL; 1048 struct list_head *iter; 1049 1050 if (!prim || prim->link != BOND_LINK_UP) { 1051 bond_for_each_slave(bond, slave, iter) { 1052 if (slave->link == BOND_LINK_UP) { 1053 hprio = hprio ?: slave; 1054 if (slave->prio > hprio->prio) 1055 hprio = slave; 1056 } 1057 } 1058 1059 if (hprio && hprio != curr) { 1060 prim = hprio; 1061 goto link_reselect; 1062 } 1063 1064 if (!curr || curr->link != BOND_LINK_UP) 1065 return NULL; 1066 return curr; 1067 } 1068 1069 if (bond->force_primary) { 1070 bond->force_primary = false; 1071 return prim; 1072 } 1073 1074 link_reselect: 1075 if (!curr || curr->link != BOND_LINK_UP) 1076 return prim; 1077 1078 /* At this point, prim and curr are both up */ 1079 switch (bond->params.primary_reselect) { 1080 case BOND_PRI_RESELECT_ALWAYS: 1081 return prim; 1082 case BOND_PRI_RESELECT_BETTER: 1083 if (prim->speed < curr->speed) 1084 return curr; 1085 if (prim->speed == curr->speed && prim->duplex <= curr->duplex) 1086 return curr; 1087 return prim; 1088 case BOND_PRI_RESELECT_FAILURE: 1089 return curr; 1090 default: 1091 netdev_err(bond->dev, "impossible primary_reselect %d\n", 1092 bond->params.primary_reselect); 1093 return curr; 1094 } 1095 } 1096 1097 /** 1098 * bond_find_best_slave - select the best available slave to be the active one 1099 * @bond: our bonding struct 1100 */ 1101 static struct slave *bond_find_best_slave(struct bonding *bond) 1102 { 1103 struct slave *slave, *bestslave = NULL; 1104 struct list_head *iter; 1105 int mintime = bond->params.updelay; 1106 1107 slave = bond_choose_primary_or_current(bond); 1108 if (slave) 1109 return slave; 1110 1111 bond_for_each_slave(bond, slave, iter) { 1112 if (slave->link == BOND_LINK_UP) 1113 return slave; 1114 if (slave->link == BOND_LINK_BACK && bond_slave_is_up(slave) && 1115 slave->delay < mintime) { 1116 mintime = slave->delay; 1117 bestslave = slave; 1118 } 1119 } 1120 1121 return bestslave; 1122 } 1123 1124 static bool bond_should_notify_peers(struct bonding *bond) 1125 { 1126 struct slave *slave; 1127 1128 rcu_read_lock(); 1129 slave = rcu_dereference(bond->curr_active_slave); 1130 rcu_read_unlock(); 1131 1132 if (!slave || !bond->send_peer_notif || 1133 bond->send_peer_notif % 1134 max(1, bond->params.peer_notif_delay) != 0 || 1135 !netif_carrier_ok(bond->dev) || 1136 test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state)) 1137 return false; 1138 1139 netdev_dbg(bond->dev, "bond_should_notify_peers: slave %s\n", 1140 slave ? slave->dev->name : "NULL"); 1141 1142 return true; 1143 } 1144 1145 /** 1146 * bond_change_active_slave - change the active slave into the specified one 1147 * @bond: our bonding struct 1148 * @new_active: the new slave to make the active one 1149 * 1150 * Set the new slave to the bond's settings and unset them on the old 1151 * curr_active_slave. 1152 * Setting include flags, mc-list, promiscuity, allmulti, etc. 1153 * 1154 * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP, 1155 * because it is apparently the best available slave we have, even though its 1156 * updelay hasn't timed out yet. 1157 * 1158 * Caller must hold RTNL. 1159 */ 1160 void bond_change_active_slave(struct bonding *bond, struct slave *new_active) 1161 { 1162 struct slave *old_active; 1163 1164 ASSERT_RTNL(); 1165 1166 old_active = rtnl_dereference(bond->curr_active_slave); 1167 1168 if (old_active == new_active) 1169 return; 1170 1171 #ifdef CONFIG_XFRM_OFFLOAD 1172 bond_ipsec_del_sa_all(bond); 1173 #endif /* CONFIG_XFRM_OFFLOAD */ 1174 1175 if (new_active) { 1176 new_active->last_link_up = jiffies; 1177 1178 if (new_active->link == BOND_LINK_BACK) { 1179 if (bond_uses_primary(bond)) { 1180 slave_info(bond->dev, new_active->dev, "making interface the new active one %d ms earlier\n", 1181 (bond->params.updelay - new_active->delay) * bond->params.miimon); 1182 } 1183 1184 new_active->delay = 0; 1185 bond_set_slave_link_state(new_active, BOND_LINK_UP, 1186 BOND_SLAVE_NOTIFY_NOW); 1187 1188 if (BOND_MODE(bond) == BOND_MODE_8023AD) 1189 bond_3ad_handle_link_change(new_active, BOND_LINK_UP); 1190 1191 if (bond_is_lb(bond)) 1192 bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP); 1193 } else { 1194 if (bond_uses_primary(bond)) 1195 slave_info(bond->dev, new_active->dev, "making interface the new active one\n"); 1196 } 1197 } 1198 1199 if (bond_uses_primary(bond)) 1200 bond_hw_addr_swap(bond, new_active, old_active); 1201 1202 if (bond_is_lb(bond)) { 1203 bond_alb_handle_active_change(bond, new_active); 1204 if (old_active) 1205 bond_set_slave_inactive_flags(old_active, 1206 BOND_SLAVE_NOTIFY_NOW); 1207 if (new_active) 1208 bond_set_slave_active_flags(new_active, 1209 BOND_SLAVE_NOTIFY_NOW); 1210 } else { 1211 rcu_assign_pointer(bond->curr_active_slave, new_active); 1212 } 1213 1214 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) { 1215 if (old_active) 1216 bond_set_slave_inactive_flags(old_active, 1217 BOND_SLAVE_NOTIFY_NOW); 1218 1219 if (new_active) { 1220 bool should_notify_peers = false; 1221 1222 bond_set_slave_active_flags(new_active, 1223 BOND_SLAVE_NOTIFY_NOW); 1224 1225 if (bond->params.fail_over_mac) 1226 bond_do_fail_over_mac(bond, new_active, 1227 old_active); 1228 1229 if (netif_running(bond->dev)) { 1230 bond->send_peer_notif = 1231 bond->params.num_peer_notif * 1232 max(1, bond->params.peer_notif_delay); 1233 should_notify_peers = 1234 bond_should_notify_peers(bond); 1235 } 1236 1237 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, bond->dev); 1238 if (should_notify_peers) { 1239 bond->send_peer_notif--; 1240 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, 1241 bond->dev); 1242 } 1243 } 1244 } 1245 1246 #ifdef CONFIG_XFRM_OFFLOAD 1247 bond_ipsec_add_sa_all(bond); 1248 #endif /* CONFIG_XFRM_OFFLOAD */ 1249 1250 /* resend IGMP joins since active slave has changed or 1251 * all were sent on curr_active_slave. 1252 * resend only if bond is brought up with the affected 1253 * bonding modes and the retransmission is enabled 1254 */ 1255 if (netif_running(bond->dev) && (bond->params.resend_igmp > 0) && 1256 ((bond_uses_primary(bond) && new_active) || 1257 BOND_MODE(bond) == BOND_MODE_ROUNDROBIN)) { 1258 bond->igmp_retrans = bond->params.resend_igmp; 1259 queue_delayed_work(bond->wq, &bond->mcast_work, 1); 1260 } 1261 } 1262 1263 /** 1264 * bond_select_active_slave - select a new active slave, if needed 1265 * @bond: our bonding struct 1266 * 1267 * This functions should be called when one of the following occurs: 1268 * - The old curr_active_slave has been released or lost its link. 1269 * - The primary_slave has got its link back. 1270 * - A slave has got its link back and there's no old curr_active_slave. 1271 * 1272 * Caller must hold RTNL. 1273 */ 1274 void bond_select_active_slave(struct bonding *bond) 1275 { 1276 struct slave *best_slave; 1277 int rv; 1278 1279 ASSERT_RTNL(); 1280 1281 best_slave = bond_find_best_slave(bond); 1282 if (best_slave != rtnl_dereference(bond->curr_active_slave)) { 1283 bond_change_active_slave(bond, best_slave); 1284 rv = bond_set_carrier(bond); 1285 if (!rv) 1286 return; 1287 1288 if (netif_carrier_ok(bond->dev)) 1289 netdev_info(bond->dev, "active interface up!\n"); 1290 else 1291 netdev_info(bond->dev, "now running without any active interface!\n"); 1292 } 1293 } 1294 1295 #ifdef CONFIG_NET_POLL_CONTROLLER 1296 static inline int slave_enable_netpoll(struct slave *slave) 1297 { 1298 struct netpoll *np; 1299 int err = 0; 1300 1301 np = kzalloc(sizeof(*np), GFP_KERNEL); 1302 err = -ENOMEM; 1303 if (!np) 1304 goto out; 1305 1306 err = __netpoll_setup(np, slave->dev); 1307 if (err) { 1308 kfree(np); 1309 goto out; 1310 } 1311 slave->np = np; 1312 out: 1313 return err; 1314 } 1315 static inline void slave_disable_netpoll(struct slave *slave) 1316 { 1317 struct netpoll *np = slave->np; 1318 1319 if (!np) 1320 return; 1321 1322 slave->np = NULL; 1323 1324 __netpoll_free(np); 1325 } 1326 1327 static void bond_poll_controller(struct net_device *bond_dev) 1328 { 1329 struct bonding *bond = netdev_priv(bond_dev); 1330 struct slave *slave = NULL; 1331 struct list_head *iter; 1332 struct ad_info ad_info; 1333 1334 if (BOND_MODE(bond) == BOND_MODE_8023AD) 1335 if (bond_3ad_get_active_agg_info(bond, &ad_info)) 1336 return; 1337 1338 bond_for_each_slave_rcu(bond, slave, iter) { 1339 if (!bond_slave_is_up(slave)) 1340 continue; 1341 1342 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 1343 struct aggregator *agg = 1344 SLAVE_AD_INFO(slave)->port.aggregator; 1345 1346 if (agg && 1347 agg->aggregator_identifier != ad_info.aggregator_id) 1348 continue; 1349 } 1350 1351 netpoll_poll_dev(slave->dev); 1352 } 1353 } 1354 1355 static void bond_netpoll_cleanup(struct net_device *bond_dev) 1356 { 1357 struct bonding *bond = netdev_priv(bond_dev); 1358 struct list_head *iter; 1359 struct slave *slave; 1360 1361 bond_for_each_slave(bond, slave, iter) 1362 if (bond_slave_is_up(slave)) 1363 slave_disable_netpoll(slave); 1364 } 1365 1366 static int bond_netpoll_setup(struct net_device *dev, struct netpoll_info *ni) 1367 { 1368 struct bonding *bond = netdev_priv(dev); 1369 struct list_head *iter; 1370 struct slave *slave; 1371 int err = 0; 1372 1373 bond_for_each_slave(bond, slave, iter) { 1374 err = slave_enable_netpoll(slave); 1375 if (err) { 1376 bond_netpoll_cleanup(dev); 1377 break; 1378 } 1379 } 1380 return err; 1381 } 1382 #else 1383 static inline int slave_enable_netpoll(struct slave *slave) 1384 { 1385 return 0; 1386 } 1387 static inline void slave_disable_netpoll(struct slave *slave) 1388 { 1389 } 1390 static void bond_netpoll_cleanup(struct net_device *bond_dev) 1391 { 1392 } 1393 #endif 1394 1395 /*---------------------------------- IOCTL ----------------------------------*/ 1396 1397 static netdev_features_t bond_fix_features(struct net_device *dev, 1398 netdev_features_t features) 1399 { 1400 struct bonding *bond = netdev_priv(dev); 1401 struct list_head *iter; 1402 netdev_features_t mask; 1403 struct slave *slave; 1404 1405 mask = features; 1406 1407 features &= ~NETIF_F_ONE_FOR_ALL; 1408 features |= NETIF_F_ALL_FOR_ALL; 1409 1410 bond_for_each_slave(bond, slave, iter) { 1411 features = netdev_increment_features(features, 1412 slave->dev->features, 1413 mask); 1414 } 1415 features = netdev_add_tso_features(features, mask); 1416 1417 return features; 1418 } 1419 1420 #define BOND_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \ 1421 NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE | \ 1422 NETIF_F_HIGHDMA | NETIF_F_LRO) 1423 1424 #define BOND_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \ 1425 NETIF_F_RXCSUM | NETIF_F_GSO_SOFTWARE) 1426 1427 #define BOND_MPLS_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \ 1428 NETIF_F_GSO_SOFTWARE) 1429 1430 1431 static void bond_compute_features(struct bonding *bond) 1432 { 1433 unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE | 1434 IFF_XMIT_DST_RELEASE_PERM; 1435 netdev_features_t vlan_features = BOND_VLAN_FEATURES; 1436 netdev_features_t enc_features = BOND_ENC_FEATURES; 1437 #ifdef CONFIG_XFRM_OFFLOAD 1438 netdev_features_t xfrm_features = BOND_XFRM_FEATURES; 1439 #endif /* CONFIG_XFRM_OFFLOAD */ 1440 netdev_features_t mpls_features = BOND_MPLS_FEATURES; 1441 struct net_device *bond_dev = bond->dev; 1442 struct list_head *iter; 1443 struct slave *slave; 1444 unsigned short max_hard_header_len = ETH_HLEN; 1445 unsigned int tso_max_size = TSO_MAX_SIZE; 1446 u16 tso_max_segs = TSO_MAX_SEGS; 1447 1448 if (!bond_has_slaves(bond)) 1449 goto done; 1450 vlan_features &= NETIF_F_ALL_FOR_ALL; 1451 mpls_features &= NETIF_F_ALL_FOR_ALL; 1452 1453 bond_for_each_slave(bond, slave, iter) { 1454 vlan_features = netdev_increment_features(vlan_features, 1455 slave->dev->vlan_features, BOND_VLAN_FEATURES); 1456 1457 enc_features = netdev_increment_features(enc_features, 1458 slave->dev->hw_enc_features, 1459 BOND_ENC_FEATURES); 1460 1461 #ifdef CONFIG_XFRM_OFFLOAD 1462 xfrm_features = netdev_increment_features(xfrm_features, 1463 slave->dev->hw_enc_features, 1464 BOND_XFRM_FEATURES); 1465 #endif /* CONFIG_XFRM_OFFLOAD */ 1466 1467 mpls_features = netdev_increment_features(mpls_features, 1468 slave->dev->mpls_features, 1469 BOND_MPLS_FEATURES); 1470 1471 dst_release_flag &= slave->dev->priv_flags; 1472 if (slave->dev->hard_header_len > max_hard_header_len) 1473 max_hard_header_len = slave->dev->hard_header_len; 1474 1475 tso_max_size = min(tso_max_size, slave->dev->tso_max_size); 1476 tso_max_segs = min(tso_max_segs, slave->dev->tso_max_segs); 1477 } 1478 bond_dev->hard_header_len = max_hard_header_len; 1479 1480 done: 1481 bond_dev->vlan_features = vlan_features; 1482 bond_dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL | 1483 NETIF_F_HW_VLAN_CTAG_TX | 1484 NETIF_F_HW_VLAN_STAG_TX; 1485 #ifdef CONFIG_XFRM_OFFLOAD 1486 bond_dev->hw_enc_features |= xfrm_features; 1487 #endif /* CONFIG_XFRM_OFFLOAD */ 1488 bond_dev->mpls_features = mpls_features; 1489 netif_set_tso_max_segs(bond_dev, tso_max_segs); 1490 netif_set_tso_max_size(bond_dev, tso_max_size); 1491 1492 bond_dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; 1493 if ((bond_dev->priv_flags & IFF_XMIT_DST_RELEASE_PERM) && 1494 dst_release_flag == (IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM)) 1495 bond_dev->priv_flags |= IFF_XMIT_DST_RELEASE; 1496 1497 netdev_change_features(bond_dev); 1498 } 1499 1500 static void bond_setup_by_slave(struct net_device *bond_dev, 1501 struct net_device *slave_dev) 1502 { 1503 bool was_up = !!(bond_dev->flags & IFF_UP); 1504 1505 dev_close(bond_dev); 1506 1507 bond_dev->header_ops = slave_dev->header_ops; 1508 1509 bond_dev->type = slave_dev->type; 1510 bond_dev->hard_header_len = slave_dev->hard_header_len; 1511 bond_dev->needed_headroom = slave_dev->needed_headroom; 1512 bond_dev->addr_len = slave_dev->addr_len; 1513 1514 memcpy(bond_dev->broadcast, slave_dev->broadcast, 1515 slave_dev->addr_len); 1516 1517 if (slave_dev->flags & IFF_POINTOPOINT) { 1518 bond_dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST); 1519 bond_dev->flags |= (IFF_POINTOPOINT | IFF_NOARP); 1520 } 1521 if (was_up) 1522 dev_open(bond_dev, NULL); 1523 } 1524 1525 /* On bonding slaves other than the currently active slave, suppress 1526 * duplicates except for alb non-mcast/bcast. 1527 */ 1528 static bool bond_should_deliver_exact_match(struct sk_buff *skb, 1529 struct slave *slave, 1530 struct bonding *bond) 1531 { 1532 if (bond_is_slave_inactive(slave)) { 1533 if (BOND_MODE(bond) == BOND_MODE_ALB && 1534 skb->pkt_type != PACKET_BROADCAST && 1535 skb->pkt_type != PACKET_MULTICAST) 1536 return false; 1537 return true; 1538 } 1539 return false; 1540 } 1541 1542 static rx_handler_result_t bond_handle_frame(struct sk_buff **pskb) 1543 { 1544 struct sk_buff *skb = *pskb; 1545 struct slave *slave; 1546 struct bonding *bond; 1547 int (*recv_probe)(const struct sk_buff *, struct bonding *, 1548 struct slave *); 1549 int ret = RX_HANDLER_ANOTHER; 1550 1551 skb = skb_share_check(skb, GFP_ATOMIC); 1552 if (unlikely(!skb)) 1553 return RX_HANDLER_CONSUMED; 1554 1555 *pskb = skb; 1556 1557 slave = bond_slave_get_rcu(skb->dev); 1558 bond = slave->bond; 1559 1560 recv_probe = READ_ONCE(bond->recv_probe); 1561 if (recv_probe) { 1562 ret = recv_probe(skb, bond, slave); 1563 if (ret == RX_HANDLER_CONSUMED) { 1564 consume_skb(skb); 1565 return ret; 1566 } 1567 } 1568 1569 /* 1570 * For packets determined by bond_should_deliver_exact_match() call to 1571 * be suppressed we want to make an exception for link-local packets. 1572 * This is necessary for e.g. LLDP daemons to be able to monitor 1573 * inactive slave links without being forced to bind to them 1574 * explicitly. 1575 * 1576 * At the same time, packets that are passed to the bonding master 1577 * (including link-local ones) can have their originating interface 1578 * determined via PACKET_ORIGDEV socket option. 1579 */ 1580 if (bond_should_deliver_exact_match(skb, slave, bond)) { 1581 if (is_link_local_ether_addr(eth_hdr(skb)->h_dest)) 1582 return RX_HANDLER_PASS; 1583 return RX_HANDLER_EXACT; 1584 } 1585 1586 skb->dev = bond->dev; 1587 1588 if (BOND_MODE(bond) == BOND_MODE_ALB && 1589 netif_is_bridge_port(bond->dev) && 1590 skb->pkt_type == PACKET_HOST) { 1591 1592 if (unlikely(skb_cow_head(skb, 1593 skb->data - skb_mac_header(skb)))) { 1594 kfree_skb(skb); 1595 return RX_HANDLER_CONSUMED; 1596 } 1597 bond_hw_addr_copy(eth_hdr(skb)->h_dest, bond->dev->dev_addr, 1598 bond->dev->addr_len); 1599 } 1600 1601 return ret; 1602 } 1603 1604 static enum netdev_lag_tx_type bond_lag_tx_type(struct bonding *bond) 1605 { 1606 switch (BOND_MODE(bond)) { 1607 case BOND_MODE_ROUNDROBIN: 1608 return NETDEV_LAG_TX_TYPE_ROUNDROBIN; 1609 case BOND_MODE_ACTIVEBACKUP: 1610 return NETDEV_LAG_TX_TYPE_ACTIVEBACKUP; 1611 case BOND_MODE_BROADCAST: 1612 return NETDEV_LAG_TX_TYPE_BROADCAST; 1613 case BOND_MODE_XOR: 1614 case BOND_MODE_8023AD: 1615 return NETDEV_LAG_TX_TYPE_HASH; 1616 default: 1617 return NETDEV_LAG_TX_TYPE_UNKNOWN; 1618 } 1619 } 1620 1621 static enum netdev_lag_hash bond_lag_hash_type(struct bonding *bond, 1622 enum netdev_lag_tx_type type) 1623 { 1624 if (type != NETDEV_LAG_TX_TYPE_HASH) 1625 return NETDEV_LAG_HASH_NONE; 1626 1627 switch (bond->params.xmit_policy) { 1628 case BOND_XMIT_POLICY_LAYER2: 1629 return NETDEV_LAG_HASH_L2; 1630 case BOND_XMIT_POLICY_LAYER34: 1631 return NETDEV_LAG_HASH_L34; 1632 case BOND_XMIT_POLICY_LAYER23: 1633 return NETDEV_LAG_HASH_L23; 1634 case BOND_XMIT_POLICY_ENCAP23: 1635 return NETDEV_LAG_HASH_E23; 1636 case BOND_XMIT_POLICY_ENCAP34: 1637 return NETDEV_LAG_HASH_E34; 1638 case BOND_XMIT_POLICY_VLAN_SRCMAC: 1639 return NETDEV_LAG_HASH_VLAN_SRCMAC; 1640 default: 1641 return NETDEV_LAG_HASH_UNKNOWN; 1642 } 1643 } 1644 1645 static int bond_master_upper_dev_link(struct bonding *bond, struct slave *slave, 1646 struct netlink_ext_ack *extack) 1647 { 1648 struct netdev_lag_upper_info lag_upper_info; 1649 enum netdev_lag_tx_type type; 1650 int err; 1651 1652 type = bond_lag_tx_type(bond); 1653 lag_upper_info.tx_type = type; 1654 lag_upper_info.hash_type = bond_lag_hash_type(bond, type); 1655 1656 err = netdev_master_upper_dev_link(slave->dev, bond->dev, slave, 1657 &lag_upper_info, extack); 1658 if (err) 1659 return err; 1660 1661 slave->dev->flags |= IFF_SLAVE; 1662 return 0; 1663 } 1664 1665 static void bond_upper_dev_unlink(struct bonding *bond, struct slave *slave) 1666 { 1667 netdev_upper_dev_unlink(slave->dev, bond->dev); 1668 slave->dev->flags &= ~IFF_SLAVE; 1669 } 1670 1671 static void slave_kobj_release(struct kobject *kobj) 1672 { 1673 struct slave *slave = to_slave(kobj); 1674 struct bonding *bond = bond_get_bond_by_slave(slave); 1675 1676 cancel_delayed_work_sync(&slave->notify_work); 1677 if (BOND_MODE(bond) == BOND_MODE_8023AD) 1678 kfree(SLAVE_AD_INFO(slave)); 1679 1680 kfree(slave); 1681 } 1682 1683 static struct kobj_type slave_ktype = { 1684 .release = slave_kobj_release, 1685 #ifdef CONFIG_SYSFS 1686 .sysfs_ops = &slave_sysfs_ops, 1687 #endif 1688 }; 1689 1690 static int bond_kobj_init(struct slave *slave) 1691 { 1692 int err; 1693 1694 err = kobject_init_and_add(&slave->kobj, &slave_ktype, 1695 &(slave->dev->dev.kobj), "bonding_slave"); 1696 if (err) 1697 kobject_put(&slave->kobj); 1698 1699 return err; 1700 } 1701 1702 static struct slave *bond_alloc_slave(struct bonding *bond, 1703 struct net_device *slave_dev) 1704 { 1705 struct slave *slave = NULL; 1706 1707 slave = kzalloc(sizeof(*slave), GFP_KERNEL); 1708 if (!slave) 1709 return NULL; 1710 1711 slave->bond = bond; 1712 slave->dev = slave_dev; 1713 INIT_DELAYED_WORK(&slave->notify_work, bond_netdev_notify_work); 1714 1715 if (bond_kobj_init(slave)) 1716 return NULL; 1717 1718 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 1719 SLAVE_AD_INFO(slave) = kzalloc(sizeof(struct ad_slave_info), 1720 GFP_KERNEL); 1721 if (!SLAVE_AD_INFO(slave)) { 1722 kobject_put(&slave->kobj); 1723 return NULL; 1724 } 1725 } 1726 1727 return slave; 1728 } 1729 1730 static void bond_fill_ifbond(struct bonding *bond, struct ifbond *info) 1731 { 1732 info->bond_mode = BOND_MODE(bond); 1733 info->miimon = bond->params.miimon; 1734 info->num_slaves = bond->slave_cnt; 1735 } 1736 1737 static void bond_fill_ifslave(struct slave *slave, struct ifslave *info) 1738 { 1739 strcpy(info->slave_name, slave->dev->name); 1740 info->link = slave->link; 1741 info->state = bond_slave_state(slave); 1742 info->link_failure_count = slave->link_failure_count; 1743 } 1744 1745 static void bond_netdev_notify_work(struct work_struct *_work) 1746 { 1747 struct slave *slave = container_of(_work, struct slave, 1748 notify_work.work); 1749 1750 if (rtnl_trylock()) { 1751 struct netdev_bonding_info binfo; 1752 1753 bond_fill_ifslave(slave, &binfo.slave); 1754 bond_fill_ifbond(slave->bond, &binfo.master); 1755 netdev_bonding_info_change(slave->dev, &binfo); 1756 rtnl_unlock(); 1757 } else { 1758 queue_delayed_work(slave->bond->wq, &slave->notify_work, 1); 1759 } 1760 } 1761 1762 void bond_queue_slave_event(struct slave *slave) 1763 { 1764 queue_delayed_work(slave->bond->wq, &slave->notify_work, 0); 1765 } 1766 1767 void bond_lower_state_changed(struct slave *slave) 1768 { 1769 struct netdev_lag_lower_state_info info; 1770 1771 info.link_up = slave->link == BOND_LINK_UP || 1772 slave->link == BOND_LINK_FAIL; 1773 info.tx_enabled = bond_is_active_slave(slave); 1774 netdev_lower_state_changed(slave->dev, &info); 1775 } 1776 1777 #define BOND_NL_ERR(bond_dev, extack, errmsg) do { \ 1778 if (extack) \ 1779 NL_SET_ERR_MSG(extack, errmsg); \ 1780 else \ 1781 netdev_err(bond_dev, "Error: %s\n", errmsg); \ 1782 } while (0) 1783 1784 #define SLAVE_NL_ERR(bond_dev, slave_dev, extack, errmsg) do { \ 1785 if (extack) \ 1786 NL_SET_ERR_MSG(extack, errmsg); \ 1787 else \ 1788 slave_err(bond_dev, slave_dev, "Error: %s\n", errmsg); \ 1789 } while (0) 1790 1791 /* The bonding driver uses ether_setup() to convert a master bond device 1792 * to ARPHRD_ETHER, that resets the target netdevice's flags so we always 1793 * have to restore the IFF_MASTER flag, and only restore IFF_SLAVE and IFF_UP 1794 * if they were set 1795 */ 1796 static void bond_ether_setup(struct net_device *bond_dev) 1797 { 1798 unsigned int flags = bond_dev->flags & (IFF_SLAVE | IFF_UP); 1799 1800 ether_setup(bond_dev); 1801 bond_dev->flags |= IFF_MASTER | flags; 1802 bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1803 } 1804 1805 void bond_xdp_set_features(struct net_device *bond_dev) 1806 { 1807 struct bonding *bond = netdev_priv(bond_dev); 1808 xdp_features_t val = NETDEV_XDP_ACT_MASK; 1809 struct list_head *iter; 1810 struct slave *slave; 1811 1812 ASSERT_RTNL(); 1813 1814 if (!bond_xdp_check(bond) || !bond_has_slaves(bond)) { 1815 xdp_clear_features_flag(bond_dev); 1816 return; 1817 } 1818 1819 bond_for_each_slave(bond, slave, iter) 1820 val &= slave->dev->xdp_features; 1821 1822 val &= ~NETDEV_XDP_ACT_XSK_ZEROCOPY; 1823 1824 xdp_set_features_flag(bond_dev, val); 1825 } 1826 1827 /* enslave device <slave> to bond device <master> */ 1828 int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev, 1829 struct netlink_ext_ack *extack) 1830 { 1831 struct bonding *bond = netdev_priv(bond_dev); 1832 const struct net_device_ops *slave_ops = slave_dev->netdev_ops; 1833 struct slave *new_slave = NULL, *prev_slave; 1834 struct sockaddr_storage ss; 1835 int link_reporting; 1836 int res = 0, i; 1837 1838 if (slave_dev->flags & IFF_MASTER && 1839 !netif_is_bond_master(slave_dev)) { 1840 BOND_NL_ERR(bond_dev, extack, 1841 "Device type (master device) cannot be enslaved"); 1842 return -EPERM; 1843 } 1844 1845 if (!bond->params.use_carrier && 1846 slave_dev->ethtool_ops->get_link == NULL && 1847 slave_ops->ndo_eth_ioctl == NULL) { 1848 slave_warn(bond_dev, slave_dev, "no link monitoring support\n"); 1849 } 1850 1851 /* already in-use? */ 1852 if (netdev_is_rx_handler_busy(slave_dev)) { 1853 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 1854 "Device is in use and cannot be enslaved"); 1855 return -EBUSY; 1856 } 1857 1858 if (bond_dev == slave_dev) { 1859 BOND_NL_ERR(bond_dev, extack, "Cannot enslave bond to itself."); 1860 return -EPERM; 1861 } 1862 1863 /* vlan challenged mutual exclusion */ 1864 /* no need to lock since we're protected by rtnl_lock */ 1865 if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) { 1866 slave_dbg(bond_dev, slave_dev, "is NETIF_F_VLAN_CHALLENGED\n"); 1867 if (vlan_uses_dev(bond_dev)) { 1868 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 1869 "Can not enslave VLAN challenged device to VLAN enabled bond"); 1870 return -EPERM; 1871 } else { 1872 slave_warn(bond_dev, slave_dev, "enslaved VLAN challenged slave. Adding VLANs will be blocked as long as it is part of bond.\n"); 1873 } 1874 } else { 1875 slave_dbg(bond_dev, slave_dev, "is !NETIF_F_VLAN_CHALLENGED\n"); 1876 } 1877 1878 if (slave_dev->features & NETIF_F_HW_ESP) 1879 slave_dbg(bond_dev, slave_dev, "is esp-hw-offload capable\n"); 1880 1881 /* Old ifenslave binaries are no longer supported. These can 1882 * be identified with moderate accuracy by the state of the slave: 1883 * the current ifenslave will set the interface down prior to 1884 * enslaving it; the old ifenslave will not. 1885 */ 1886 if (slave_dev->flags & IFF_UP) { 1887 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 1888 "Device can not be enslaved while up"); 1889 return -EPERM; 1890 } 1891 1892 /* set bonding device ether type by slave - bonding netdevices are 1893 * created with ether_setup, so when the slave type is not ARPHRD_ETHER 1894 * there is a need to override some of the type dependent attribs/funcs. 1895 * 1896 * bond ether type mutual exclusion - don't allow slaves of dissimilar 1897 * ether type (eg ARPHRD_ETHER and ARPHRD_INFINIBAND) share the same bond 1898 */ 1899 if (!bond_has_slaves(bond)) { 1900 if (bond_dev->type != slave_dev->type) { 1901 slave_dbg(bond_dev, slave_dev, "change device type from %d to %d\n", 1902 bond_dev->type, slave_dev->type); 1903 1904 res = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, 1905 bond_dev); 1906 res = notifier_to_errno(res); 1907 if (res) { 1908 slave_err(bond_dev, slave_dev, "refused to change device type\n"); 1909 return -EBUSY; 1910 } 1911 1912 /* Flush unicast and multicast addresses */ 1913 dev_uc_flush(bond_dev); 1914 dev_mc_flush(bond_dev); 1915 1916 if (slave_dev->type != ARPHRD_ETHER) 1917 bond_setup_by_slave(bond_dev, slave_dev); 1918 else 1919 bond_ether_setup(bond_dev); 1920 1921 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, 1922 bond_dev); 1923 } 1924 } else if (bond_dev->type != slave_dev->type) { 1925 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 1926 "Device type is different from other slaves"); 1927 return -EINVAL; 1928 } 1929 1930 if (slave_dev->type == ARPHRD_INFINIBAND && 1931 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 1932 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 1933 "Only active-backup mode is supported for infiniband slaves"); 1934 res = -EOPNOTSUPP; 1935 goto err_undo_flags; 1936 } 1937 1938 if (!slave_ops->ndo_set_mac_address || 1939 slave_dev->type == ARPHRD_INFINIBAND) { 1940 slave_warn(bond_dev, slave_dev, "The slave device specified does not support setting the MAC address\n"); 1941 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP && 1942 bond->params.fail_over_mac != BOND_FOM_ACTIVE) { 1943 if (!bond_has_slaves(bond)) { 1944 bond->params.fail_over_mac = BOND_FOM_ACTIVE; 1945 slave_warn(bond_dev, slave_dev, "Setting fail_over_mac to active for active-backup mode\n"); 1946 } else { 1947 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 1948 "Slave device does not support setting the MAC address, but fail_over_mac is not set to active"); 1949 res = -EOPNOTSUPP; 1950 goto err_undo_flags; 1951 } 1952 } 1953 } 1954 1955 call_netdevice_notifiers(NETDEV_JOIN, slave_dev); 1956 1957 /* If this is the first slave, then we need to set the master's hardware 1958 * address to be the same as the slave's. 1959 */ 1960 if (!bond_has_slaves(bond) && 1961 bond->dev->addr_assign_type == NET_ADDR_RANDOM) { 1962 res = bond_set_dev_addr(bond->dev, slave_dev); 1963 if (res) 1964 goto err_undo_flags; 1965 } 1966 1967 new_slave = bond_alloc_slave(bond, slave_dev); 1968 if (!new_slave) { 1969 res = -ENOMEM; 1970 goto err_undo_flags; 1971 } 1972 1973 /* Set the new_slave's queue_id to be zero. Queue ID mapping 1974 * is set via sysfs or module option if desired. 1975 */ 1976 new_slave->queue_id = 0; 1977 1978 /* Save slave's original mtu and then set it to match the bond */ 1979 new_slave->original_mtu = slave_dev->mtu; 1980 res = dev_set_mtu(slave_dev, bond->dev->mtu); 1981 if (res) { 1982 slave_err(bond_dev, slave_dev, "Error %d calling dev_set_mtu\n", res); 1983 goto err_free; 1984 } 1985 1986 /* Save slave's original ("permanent") mac address for modes 1987 * that need it, and for restoring it upon release, and then 1988 * set it to the master's address 1989 */ 1990 bond_hw_addr_copy(new_slave->perm_hwaddr, slave_dev->dev_addr, 1991 slave_dev->addr_len); 1992 1993 if (!bond->params.fail_over_mac || 1994 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 1995 /* Set slave to master's mac address. The application already 1996 * set the master's mac address to that of the first slave 1997 */ 1998 memcpy(ss.__data, bond_dev->dev_addr, bond_dev->addr_len); 1999 ss.ss_family = slave_dev->type; 2000 res = dev_set_mac_address(slave_dev, (struct sockaddr *)&ss, 2001 extack); 2002 if (res) { 2003 slave_err(bond_dev, slave_dev, "Error %d calling set_mac_address\n", res); 2004 goto err_restore_mtu; 2005 } 2006 } 2007 2008 /* set no_addrconf flag before open to prevent IPv6 addrconf */ 2009 slave_dev->priv_flags |= IFF_NO_ADDRCONF; 2010 2011 /* open the slave since the application closed it */ 2012 res = dev_open(slave_dev, extack); 2013 if (res) { 2014 slave_err(bond_dev, slave_dev, "Opening slave failed\n"); 2015 goto err_restore_mac; 2016 } 2017 2018 slave_dev->priv_flags |= IFF_BONDING; 2019 /* initialize slave stats */ 2020 dev_get_stats(new_slave->dev, &new_slave->slave_stats); 2021 2022 if (bond_is_lb(bond)) { 2023 /* bond_alb_init_slave() must be called before all other stages since 2024 * it might fail and we do not want to have to undo everything 2025 */ 2026 res = bond_alb_init_slave(bond, new_slave); 2027 if (res) 2028 goto err_close; 2029 } 2030 2031 res = vlan_vids_add_by_dev(slave_dev, bond_dev); 2032 if (res) { 2033 slave_err(bond_dev, slave_dev, "Couldn't add bond vlan ids\n"); 2034 goto err_close; 2035 } 2036 2037 prev_slave = bond_last_slave(bond); 2038 2039 new_slave->delay = 0; 2040 new_slave->link_failure_count = 0; 2041 2042 if (bond_update_speed_duplex(new_slave) && 2043 bond_needs_speed_duplex(bond)) 2044 new_slave->link = BOND_LINK_DOWN; 2045 2046 new_slave->last_rx = jiffies - 2047 (msecs_to_jiffies(bond->params.arp_interval) + 1); 2048 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) 2049 new_slave->target_last_arp_rx[i] = new_slave->last_rx; 2050 2051 new_slave->last_tx = new_slave->last_rx; 2052 2053 if (bond->params.miimon && !bond->params.use_carrier) { 2054 link_reporting = bond_check_dev_link(bond, slave_dev, 1); 2055 2056 if ((link_reporting == -1) && !bond->params.arp_interval) { 2057 /* miimon is set but a bonded network driver 2058 * does not support ETHTOOL/MII and 2059 * arp_interval is not set. Note: if 2060 * use_carrier is enabled, we will never go 2061 * here (because netif_carrier is always 2062 * supported); thus, we don't need to change 2063 * the messages for netif_carrier. 2064 */ 2065 slave_warn(bond_dev, slave_dev, "MII and ETHTOOL support not available for slave, and arp_interval/arp_ip_target module parameters not specified, thus bonding will not detect link failures! see bonding.txt for details\n"); 2066 } else if (link_reporting == -1) { 2067 /* unable get link status using mii/ethtool */ 2068 slave_warn(bond_dev, slave_dev, "can't get link status from slave; 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"); 2069 } 2070 } 2071 2072 /* check for initial state */ 2073 new_slave->link = BOND_LINK_NOCHANGE; 2074 if (bond->params.miimon) { 2075 if (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS) { 2076 if (bond->params.updelay) { 2077 bond_set_slave_link_state(new_slave, 2078 BOND_LINK_BACK, 2079 BOND_SLAVE_NOTIFY_NOW); 2080 new_slave->delay = bond->params.updelay; 2081 } else { 2082 bond_set_slave_link_state(new_slave, 2083 BOND_LINK_UP, 2084 BOND_SLAVE_NOTIFY_NOW); 2085 } 2086 } else { 2087 bond_set_slave_link_state(new_slave, BOND_LINK_DOWN, 2088 BOND_SLAVE_NOTIFY_NOW); 2089 } 2090 } else if (bond->params.arp_interval) { 2091 bond_set_slave_link_state(new_slave, 2092 (netif_carrier_ok(slave_dev) ? 2093 BOND_LINK_UP : BOND_LINK_DOWN), 2094 BOND_SLAVE_NOTIFY_NOW); 2095 } else { 2096 bond_set_slave_link_state(new_slave, BOND_LINK_UP, 2097 BOND_SLAVE_NOTIFY_NOW); 2098 } 2099 2100 if (new_slave->link != BOND_LINK_DOWN) 2101 new_slave->last_link_up = jiffies; 2102 slave_dbg(bond_dev, slave_dev, "Initial state of slave is BOND_LINK_%s\n", 2103 new_slave->link == BOND_LINK_DOWN ? "DOWN" : 2104 (new_slave->link == BOND_LINK_UP ? "UP" : "BACK")); 2105 2106 if (bond_uses_primary(bond) && bond->params.primary[0]) { 2107 /* if there is a primary slave, remember it */ 2108 if (strcmp(bond->params.primary, new_slave->dev->name) == 0) { 2109 rcu_assign_pointer(bond->primary_slave, new_slave); 2110 bond->force_primary = true; 2111 } 2112 } 2113 2114 switch (BOND_MODE(bond)) { 2115 case BOND_MODE_ACTIVEBACKUP: 2116 bond_set_slave_inactive_flags(new_slave, 2117 BOND_SLAVE_NOTIFY_NOW); 2118 break; 2119 case BOND_MODE_8023AD: 2120 /* in 802.3ad mode, the internal mechanism 2121 * will activate the slaves in the selected 2122 * aggregator 2123 */ 2124 bond_set_slave_inactive_flags(new_slave, BOND_SLAVE_NOTIFY_NOW); 2125 /* if this is the first slave */ 2126 if (!prev_slave) { 2127 SLAVE_AD_INFO(new_slave)->id = 1; 2128 /* Initialize AD with the number of times that the AD timer is called in 1 second 2129 * can be called only after the mac address of the bond is set 2130 */ 2131 bond_3ad_initialize(bond); 2132 } else { 2133 SLAVE_AD_INFO(new_slave)->id = 2134 SLAVE_AD_INFO(prev_slave)->id + 1; 2135 } 2136 2137 bond_3ad_bind_slave(new_slave); 2138 break; 2139 case BOND_MODE_TLB: 2140 case BOND_MODE_ALB: 2141 bond_set_active_slave(new_slave); 2142 bond_set_slave_inactive_flags(new_slave, BOND_SLAVE_NOTIFY_NOW); 2143 break; 2144 default: 2145 slave_dbg(bond_dev, slave_dev, "This slave is always active in trunk mode\n"); 2146 2147 /* always active in trunk mode */ 2148 bond_set_active_slave(new_slave); 2149 2150 /* In trunking mode there is little meaning to curr_active_slave 2151 * anyway (it holds no special properties of the bond device), 2152 * so we can change it without calling change_active_interface() 2153 */ 2154 if (!rcu_access_pointer(bond->curr_active_slave) && 2155 new_slave->link == BOND_LINK_UP) 2156 rcu_assign_pointer(bond->curr_active_slave, new_slave); 2157 2158 break; 2159 } /* switch(bond_mode) */ 2160 2161 #ifdef CONFIG_NET_POLL_CONTROLLER 2162 if (bond->dev->npinfo) { 2163 if (slave_enable_netpoll(new_slave)) { 2164 slave_info(bond_dev, slave_dev, "master_dev is using netpoll, but new slave device does not support netpoll\n"); 2165 res = -EBUSY; 2166 goto err_detach; 2167 } 2168 } 2169 #endif 2170 2171 if (!(bond_dev->features & NETIF_F_LRO)) 2172 dev_disable_lro(slave_dev); 2173 2174 res = netdev_rx_handler_register(slave_dev, bond_handle_frame, 2175 new_slave); 2176 if (res) { 2177 slave_dbg(bond_dev, slave_dev, "Error %d calling netdev_rx_handler_register\n", res); 2178 goto err_detach; 2179 } 2180 2181 res = bond_master_upper_dev_link(bond, new_slave, extack); 2182 if (res) { 2183 slave_dbg(bond_dev, slave_dev, "Error %d calling bond_master_upper_dev_link\n", res); 2184 goto err_unregister; 2185 } 2186 2187 bond_lower_state_changed(new_slave); 2188 2189 res = bond_sysfs_slave_add(new_slave); 2190 if (res) { 2191 slave_dbg(bond_dev, slave_dev, "Error %d calling bond_sysfs_slave_add\n", res); 2192 goto err_upper_unlink; 2193 } 2194 2195 /* If the mode uses primary, then the following is handled by 2196 * bond_change_active_slave(). 2197 */ 2198 if (!bond_uses_primary(bond)) { 2199 /* set promiscuity level to new slave */ 2200 if (bond_dev->flags & IFF_PROMISC) { 2201 res = dev_set_promiscuity(slave_dev, 1); 2202 if (res) 2203 goto err_sysfs_del; 2204 } 2205 2206 /* set allmulti level to new slave */ 2207 if (bond_dev->flags & IFF_ALLMULTI) { 2208 res = dev_set_allmulti(slave_dev, 1); 2209 if (res) { 2210 if (bond_dev->flags & IFF_PROMISC) 2211 dev_set_promiscuity(slave_dev, -1); 2212 goto err_sysfs_del; 2213 } 2214 } 2215 2216 if (bond_dev->flags & IFF_UP) { 2217 netif_addr_lock_bh(bond_dev); 2218 dev_mc_sync_multiple(slave_dev, bond_dev); 2219 dev_uc_sync_multiple(slave_dev, bond_dev); 2220 netif_addr_unlock_bh(bond_dev); 2221 2222 if (BOND_MODE(bond) == BOND_MODE_8023AD) 2223 dev_mc_add(slave_dev, lacpdu_mcast_addr); 2224 } 2225 } 2226 2227 bond->slave_cnt++; 2228 bond_compute_features(bond); 2229 bond_set_carrier(bond); 2230 2231 if (bond_uses_primary(bond)) { 2232 block_netpoll_tx(); 2233 bond_select_active_slave(bond); 2234 unblock_netpoll_tx(); 2235 } 2236 2237 if (bond_mode_can_use_xmit_hash(bond)) 2238 bond_update_slave_arr(bond, NULL); 2239 2240 2241 if (!slave_dev->netdev_ops->ndo_bpf || 2242 !slave_dev->netdev_ops->ndo_xdp_xmit) { 2243 if (bond->xdp_prog) { 2244 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 2245 "Slave does not support XDP"); 2246 res = -EOPNOTSUPP; 2247 goto err_sysfs_del; 2248 } 2249 } else if (bond->xdp_prog) { 2250 struct netdev_bpf xdp = { 2251 .command = XDP_SETUP_PROG, 2252 .flags = 0, 2253 .prog = bond->xdp_prog, 2254 .extack = extack, 2255 }; 2256 2257 if (dev_xdp_prog_count(slave_dev) > 0) { 2258 SLAVE_NL_ERR(bond_dev, slave_dev, extack, 2259 "Slave has XDP program loaded, please unload before enslaving"); 2260 res = -EOPNOTSUPP; 2261 goto err_sysfs_del; 2262 } 2263 2264 res = slave_dev->netdev_ops->ndo_bpf(slave_dev, &xdp); 2265 if (res < 0) { 2266 /* ndo_bpf() sets extack error message */ 2267 slave_dbg(bond_dev, slave_dev, "Error %d calling ndo_bpf\n", res); 2268 goto err_sysfs_del; 2269 } 2270 if (bond->xdp_prog) 2271 bpf_prog_inc(bond->xdp_prog); 2272 } 2273 2274 bond_xdp_set_features(bond_dev); 2275 2276 slave_info(bond_dev, slave_dev, "Enslaving as %s interface with %s link\n", 2277 bond_is_active_slave(new_slave) ? "an active" : "a backup", 2278 new_slave->link != BOND_LINK_DOWN ? "an up" : "a down"); 2279 2280 /* enslave is successful */ 2281 bond_queue_slave_event(new_slave); 2282 return 0; 2283 2284 /* Undo stages on error */ 2285 err_sysfs_del: 2286 bond_sysfs_slave_del(new_slave); 2287 2288 err_upper_unlink: 2289 bond_upper_dev_unlink(bond, new_slave); 2290 2291 err_unregister: 2292 netdev_rx_handler_unregister(slave_dev); 2293 2294 err_detach: 2295 vlan_vids_del_by_dev(slave_dev, bond_dev); 2296 if (rcu_access_pointer(bond->primary_slave) == new_slave) 2297 RCU_INIT_POINTER(bond->primary_slave, NULL); 2298 if (rcu_access_pointer(bond->curr_active_slave) == new_slave) { 2299 block_netpoll_tx(); 2300 bond_change_active_slave(bond, NULL); 2301 bond_select_active_slave(bond); 2302 unblock_netpoll_tx(); 2303 } 2304 /* either primary_slave or curr_active_slave might've changed */ 2305 synchronize_rcu(); 2306 slave_disable_netpoll(new_slave); 2307 2308 err_close: 2309 if (!netif_is_bond_master(slave_dev)) 2310 slave_dev->priv_flags &= ~IFF_BONDING; 2311 dev_close(slave_dev); 2312 2313 err_restore_mac: 2314 slave_dev->priv_flags &= ~IFF_NO_ADDRCONF; 2315 if (!bond->params.fail_over_mac || 2316 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 2317 /* XXX TODO - fom follow mode needs to change master's 2318 * MAC if this slave's MAC is in use by the bond, or at 2319 * least print a warning. 2320 */ 2321 bond_hw_addr_copy(ss.__data, new_slave->perm_hwaddr, 2322 new_slave->dev->addr_len); 2323 ss.ss_family = slave_dev->type; 2324 dev_set_mac_address(slave_dev, (struct sockaddr *)&ss, NULL); 2325 } 2326 2327 err_restore_mtu: 2328 dev_set_mtu(slave_dev, new_slave->original_mtu); 2329 2330 err_free: 2331 kobject_put(&new_slave->kobj); 2332 2333 err_undo_flags: 2334 /* Enslave of first slave has failed and we need to fix master's mac */ 2335 if (!bond_has_slaves(bond)) { 2336 if (ether_addr_equal_64bits(bond_dev->dev_addr, 2337 slave_dev->dev_addr)) 2338 eth_hw_addr_random(bond_dev); 2339 if (bond_dev->type != ARPHRD_ETHER) { 2340 dev_close(bond_dev); 2341 bond_ether_setup(bond_dev); 2342 } 2343 } 2344 2345 return res; 2346 } 2347 2348 /* Try to release the slave device <slave> from the bond device <master> 2349 * It is legal to access curr_active_slave without a lock because all the function 2350 * is RTNL-locked. If "all" is true it means that the function is being called 2351 * while destroying a bond interface and all slaves are being released. 2352 * 2353 * The rules for slave state should be: 2354 * for Active/Backup: 2355 * Active stays on all backups go down 2356 * for Bonded connections: 2357 * The first up interface should be left on and all others downed. 2358 */ 2359 static int __bond_release_one(struct net_device *bond_dev, 2360 struct net_device *slave_dev, 2361 bool all, bool unregister) 2362 { 2363 struct bonding *bond = netdev_priv(bond_dev); 2364 struct slave *slave, *oldcurrent; 2365 struct sockaddr_storage ss; 2366 int old_flags = bond_dev->flags; 2367 netdev_features_t old_features = bond_dev->features; 2368 2369 /* slave is not a slave or master is not master of this slave */ 2370 if (!(slave_dev->flags & IFF_SLAVE) || 2371 !netdev_has_upper_dev(slave_dev, bond_dev)) { 2372 slave_dbg(bond_dev, slave_dev, "cannot release slave\n"); 2373 return -EINVAL; 2374 } 2375 2376 block_netpoll_tx(); 2377 2378 slave = bond_get_slave_by_dev(bond, slave_dev); 2379 if (!slave) { 2380 /* not a slave of this bond */ 2381 slave_info(bond_dev, slave_dev, "interface not enslaved\n"); 2382 unblock_netpoll_tx(); 2383 return -EINVAL; 2384 } 2385 2386 bond_set_slave_inactive_flags(slave, BOND_SLAVE_NOTIFY_NOW); 2387 2388 bond_sysfs_slave_del(slave); 2389 2390 /* recompute stats just before removing the slave */ 2391 bond_get_stats(bond->dev, &bond->bond_stats); 2392 2393 if (bond->xdp_prog) { 2394 struct netdev_bpf xdp = { 2395 .command = XDP_SETUP_PROG, 2396 .flags = 0, 2397 .prog = NULL, 2398 .extack = NULL, 2399 }; 2400 if (slave_dev->netdev_ops->ndo_bpf(slave_dev, &xdp)) 2401 slave_warn(bond_dev, slave_dev, "failed to unload XDP program\n"); 2402 } 2403 2404 /* unregister rx_handler early so bond_handle_frame wouldn't be called 2405 * for this slave anymore. 2406 */ 2407 netdev_rx_handler_unregister(slave_dev); 2408 2409 if (BOND_MODE(bond) == BOND_MODE_8023AD) 2410 bond_3ad_unbind_slave(slave); 2411 2412 bond_upper_dev_unlink(bond, slave); 2413 2414 if (bond_mode_can_use_xmit_hash(bond)) 2415 bond_update_slave_arr(bond, slave); 2416 2417 slave_info(bond_dev, slave_dev, "Releasing %s interface\n", 2418 bond_is_active_slave(slave) ? "active" : "backup"); 2419 2420 oldcurrent = rcu_access_pointer(bond->curr_active_slave); 2421 2422 RCU_INIT_POINTER(bond->current_arp_slave, NULL); 2423 2424 if (!all && (!bond->params.fail_over_mac || 2425 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP)) { 2426 if (ether_addr_equal_64bits(bond_dev->dev_addr, slave->perm_hwaddr) && 2427 bond_has_slaves(bond)) 2428 slave_warn(bond_dev, slave_dev, "the permanent HWaddr of slave - %pM - is still in use by bond - set the HWaddr of slave to a different address to avoid conflicts\n", 2429 slave->perm_hwaddr); 2430 } 2431 2432 if (rtnl_dereference(bond->primary_slave) == slave) 2433 RCU_INIT_POINTER(bond->primary_slave, NULL); 2434 2435 if (oldcurrent == slave) 2436 bond_change_active_slave(bond, NULL); 2437 2438 if (bond_is_lb(bond)) { 2439 /* Must be called only after the slave has been 2440 * detached from the list and the curr_active_slave 2441 * has been cleared (if our_slave == old_current), 2442 * but before a new active slave is selected. 2443 */ 2444 bond_alb_deinit_slave(bond, slave); 2445 } 2446 2447 if (all) { 2448 RCU_INIT_POINTER(bond->curr_active_slave, NULL); 2449 } else if (oldcurrent == slave) { 2450 /* Note that we hold RTNL over this sequence, so there 2451 * is no concern that another slave add/remove event 2452 * will interfere. 2453 */ 2454 bond_select_active_slave(bond); 2455 } 2456 2457 bond_set_carrier(bond); 2458 if (!bond_has_slaves(bond)) 2459 eth_hw_addr_random(bond_dev); 2460 2461 unblock_netpoll_tx(); 2462 synchronize_rcu(); 2463 bond->slave_cnt--; 2464 2465 if (!bond_has_slaves(bond)) { 2466 call_netdevice_notifiers(NETDEV_CHANGEADDR, bond->dev); 2467 call_netdevice_notifiers(NETDEV_RELEASE, bond->dev); 2468 } 2469 2470 bond_compute_features(bond); 2471 if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) && 2472 (old_features & NETIF_F_VLAN_CHALLENGED)) 2473 slave_info(bond_dev, slave_dev, "last VLAN challenged slave left bond - VLAN blocking is removed\n"); 2474 2475 vlan_vids_del_by_dev(slave_dev, bond_dev); 2476 2477 /* If the mode uses primary, then this case was handled above by 2478 * bond_change_active_slave(..., NULL) 2479 */ 2480 if (!bond_uses_primary(bond)) { 2481 /* unset promiscuity level from slave 2482 * NOTE: The NETDEV_CHANGEADDR call above may change the value 2483 * of the IFF_PROMISC flag in the bond_dev, but we need the 2484 * value of that flag before that change, as that was the value 2485 * when this slave was attached, so we cache at the start of the 2486 * function and use it here. Same goes for ALLMULTI below 2487 */ 2488 if (old_flags & IFF_PROMISC) 2489 dev_set_promiscuity(slave_dev, -1); 2490 2491 /* unset allmulti level from slave */ 2492 if (old_flags & IFF_ALLMULTI) 2493 dev_set_allmulti(slave_dev, -1); 2494 2495 if (old_flags & IFF_UP) 2496 bond_hw_addr_flush(bond_dev, slave_dev); 2497 } 2498 2499 slave_disable_netpoll(slave); 2500 2501 /* close slave before restoring its mac address */ 2502 dev_close(slave_dev); 2503 2504 slave_dev->priv_flags &= ~IFF_NO_ADDRCONF; 2505 2506 if (bond->params.fail_over_mac != BOND_FOM_ACTIVE || 2507 BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 2508 /* restore original ("permanent") mac address */ 2509 bond_hw_addr_copy(ss.__data, slave->perm_hwaddr, 2510 slave->dev->addr_len); 2511 ss.ss_family = slave_dev->type; 2512 dev_set_mac_address(slave_dev, (struct sockaddr *)&ss, NULL); 2513 } 2514 2515 if (unregister) 2516 __dev_set_mtu(slave_dev, slave->original_mtu); 2517 else 2518 dev_set_mtu(slave_dev, slave->original_mtu); 2519 2520 if (!netif_is_bond_master(slave_dev)) 2521 slave_dev->priv_flags &= ~IFF_BONDING; 2522 2523 bond_xdp_set_features(bond_dev); 2524 kobject_put(&slave->kobj); 2525 2526 return 0; 2527 } 2528 2529 /* A wrapper used because of ndo_del_link */ 2530 int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) 2531 { 2532 return __bond_release_one(bond_dev, slave_dev, false, false); 2533 } 2534 2535 /* First release a slave and then destroy the bond if no more slaves are left. 2536 * Must be under rtnl_lock when this function is called. 2537 */ 2538 static int bond_release_and_destroy(struct net_device *bond_dev, 2539 struct net_device *slave_dev) 2540 { 2541 struct bonding *bond = netdev_priv(bond_dev); 2542 int ret; 2543 2544 ret = __bond_release_one(bond_dev, slave_dev, false, true); 2545 if (ret == 0 && !bond_has_slaves(bond) && 2546 bond_dev->reg_state != NETREG_UNREGISTERING) { 2547 bond_dev->priv_flags |= IFF_DISABLE_NETPOLL; 2548 netdev_info(bond_dev, "Destroying bond\n"); 2549 bond_remove_proc_entry(bond); 2550 unregister_netdevice(bond_dev); 2551 } 2552 return ret; 2553 } 2554 2555 static void bond_info_query(struct net_device *bond_dev, struct ifbond *info) 2556 { 2557 struct bonding *bond = netdev_priv(bond_dev); 2558 2559 bond_fill_ifbond(bond, info); 2560 } 2561 2562 static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info) 2563 { 2564 struct bonding *bond = netdev_priv(bond_dev); 2565 struct list_head *iter; 2566 int i = 0, res = -ENODEV; 2567 struct slave *slave; 2568 2569 bond_for_each_slave(bond, slave, iter) { 2570 if (i++ == (int)info->slave_id) { 2571 res = 0; 2572 bond_fill_ifslave(slave, info); 2573 break; 2574 } 2575 } 2576 2577 return res; 2578 } 2579 2580 /*-------------------------------- Monitoring -------------------------------*/ 2581 2582 /* called with rcu_read_lock() */ 2583 static int bond_miimon_inspect(struct bonding *bond) 2584 { 2585 bool ignore_updelay = false; 2586 int link_state, commit = 0; 2587 struct list_head *iter; 2588 struct slave *slave; 2589 2590 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) { 2591 ignore_updelay = !rcu_dereference(bond->curr_active_slave); 2592 } else { 2593 struct bond_up_slave *usable_slaves; 2594 2595 usable_slaves = rcu_dereference(bond->usable_slaves); 2596 2597 if (usable_slaves && usable_slaves->count == 0) 2598 ignore_updelay = true; 2599 } 2600 2601 bond_for_each_slave_rcu(bond, slave, iter) { 2602 bond_propose_link_state(slave, BOND_LINK_NOCHANGE); 2603 2604 link_state = bond_check_dev_link(bond, slave->dev, 0); 2605 2606 switch (slave->link) { 2607 case BOND_LINK_UP: 2608 if (link_state) 2609 continue; 2610 2611 bond_propose_link_state(slave, BOND_LINK_FAIL); 2612 commit++; 2613 slave->delay = bond->params.downdelay; 2614 if (slave->delay && net_ratelimit()) { 2615 slave_info(bond->dev, slave->dev, "link status down for %sinterface, disabling it in %d ms\n", 2616 (BOND_MODE(bond) == 2617 BOND_MODE_ACTIVEBACKUP) ? 2618 (bond_is_active_slave(slave) ? 2619 "active " : "backup ") : "", 2620 bond->params.downdelay * bond->params.miimon); 2621 } 2622 fallthrough; 2623 case BOND_LINK_FAIL: 2624 if (link_state) { 2625 /* recovered before downdelay expired */ 2626 bond_propose_link_state(slave, BOND_LINK_UP); 2627 slave->last_link_up = jiffies; 2628 if (net_ratelimit()) 2629 slave_info(bond->dev, slave->dev, "link status up again after %d ms\n", 2630 (bond->params.downdelay - slave->delay) * 2631 bond->params.miimon); 2632 commit++; 2633 continue; 2634 } 2635 2636 if (slave->delay <= 0) { 2637 bond_propose_link_state(slave, BOND_LINK_DOWN); 2638 commit++; 2639 continue; 2640 } 2641 2642 slave->delay--; 2643 break; 2644 2645 case BOND_LINK_DOWN: 2646 if (!link_state) 2647 continue; 2648 2649 bond_propose_link_state(slave, BOND_LINK_BACK); 2650 commit++; 2651 slave->delay = bond->params.updelay; 2652 2653 if (slave->delay && net_ratelimit()) { 2654 slave_info(bond->dev, slave->dev, "link status up, enabling it in %d ms\n", 2655 ignore_updelay ? 0 : 2656 bond->params.updelay * 2657 bond->params.miimon); 2658 } 2659 fallthrough; 2660 case BOND_LINK_BACK: 2661 if (!link_state) { 2662 bond_propose_link_state(slave, BOND_LINK_DOWN); 2663 if (net_ratelimit()) 2664 slave_info(bond->dev, slave->dev, "link status down again after %d ms\n", 2665 (bond->params.updelay - slave->delay) * 2666 bond->params.miimon); 2667 commit++; 2668 continue; 2669 } 2670 2671 if (ignore_updelay) 2672 slave->delay = 0; 2673 2674 if (slave->delay <= 0) { 2675 bond_propose_link_state(slave, BOND_LINK_UP); 2676 commit++; 2677 ignore_updelay = false; 2678 continue; 2679 } 2680 2681 slave->delay--; 2682 break; 2683 } 2684 } 2685 2686 return commit; 2687 } 2688 2689 static void bond_miimon_link_change(struct bonding *bond, 2690 struct slave *slave, 2691 char link) 2692 { 2693 switch (BOND_MODE(bond)) { 2694 case BOND_MODE_8023AD: 2695 bond_3ad_handle_link_change(slave, link); 2696 break; 2697 case BOND_MODE_TLB: 2698 case BOND_MODE_ALB: 2699 bond_alb_handle_link_change(bond, slave, link); 2700 break; 2701 case BOND_MODE_XOR: 2702 bond_update_slave_arr(bond, NULL); 2703 break; 2704 } 2705 } 2706 2707 static void bond_miimon_commit(struct bonding *bond) 2708 { 2709 struct slave *slave, *primary, *active; 2710 bool do_failover = false; 2711 struct list_head *iter; 2712 2713 ASSERT_RTNL(); 2714 2715 bond_for_each_slave(bond, slave, iter) { 2716 switch (slave->link_new_state) { 2717 case BOND_LINK_NOCHANGE: 2718 /* For 802.3ad mode, check current slave speed and 2719 * duplex again in case its port was disabled after 2720 * invalid speed/duplex reporting but recovered before 2721 * link monitoring could make a decision on the actual 2722 * link status 2723 */ 2724 if (BOND_MODE(bond) == BOND_MODE_8023AD && 2725 slave->link == BOND_LINK_UP) 2726 bond_3ad_adapter_speed_duplex_changed(slave); 2727 continue; 2728 2729 case BOND_LINK_UP: 2730 if (bond_update_speed_duplex(slave) && 2731 bond_needs_speed_duplex(bond)) { 2732 slave->link = BOND_LINK_DOWN; 2733 if (net_ratelimit()) 2734 slave_warn(bond->dev, slave->dev, 2735 "failed to get link speed/duplex\n"); 2736 continue; 2737 } 2738 bond_set_slave_link_state(slave, BOND_LINK_UP, 2739 BOND_SLAVE_NOTIFY_NOW); 2740 slave->last_link_up = jiffies; 2741 2742 primary = rtnl_dereference(bond->primary_slave); 2743 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 2744 /* prevent it from being the active one */ 2745 bond_set_backup_slave(slave); 2746 } else if (BOND_MODE(bond) != BOND_MODE_ACTIVEBACKUP) { 2747 /* make it immediately active */ 2748 bond_set_active_slave(slave); 2749 } 2750 2751 slave_info(bond->dev, slave->dev, "link status definitely up, %u Mbps %s duplex\n", 2752 slave->speed == SPEED_UNKNOWN ? 0 : slave->speed, 2753 slave->duplex ? "full" : "half"); 2754 2755 bond_miimon_link_change(bond, slave, BOND_LINK_UP); 2756 2757 active = rtnl_dereference(bond->curr_active_slave); 2758 if (!active || slave == primary || slave->prio > active->prio) 2759 do_failover = true; 2760 2761 continue; 2762 2763 case BOND_LINK_DOWN: 2764 if (slave->link_failure_count < UINT_MAX) 2765 slave->link_failure_count++; 2766 2767 bond_set_slave_link_state(slave, BOND_LINK_DOWN, 2768 BOND_SLAVE_NOTIFY_NOW); 2769 2770 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP || 2771 BOND_MODE(bond) == BOND_MODE_8023AD) 2772 bond_set_slave_inactive_flags(slave, 2773 BOND_SLAVE_NOTIFY_NOW); 2774 2775 slave_info(bond->dev, slave->dev, "link status definitely down, disabling slave\n"); 2776 2777 bond_miimon_link_change(bond, slave, BOND_LINK_DOWN); 2778 2779 if (slave == rcu_access_pointer(bond->curr_active_slave)) 2780 do_failover = true; 2781 2782 continue; 2783 2784 default: 2785 slave_err(bond->dev, slave->dev, "invalid new link %d on slave\n", 2786 slave->link_new_state); 2787 bond_propose_link_state(slave, BOND_LINK_NOCHANGE); 2788 2789 continue; 2790 } 2791 } 2792 2793 if (do_failover) { 2794 block_netpoll_tx(); 2795 bond_select_active_slave(bond); 2796 unblock_netpoll_tx(); 2797 } 2798 2799 bond_set_carrier(bond); 2800 } 2801 2802 /* bond_mii_monitor 2803 * 2804 * Really a wrapper that splits the mii monitor into two phases: an 2805 * inspection, then (if inspection indicates something needs to be done) 2806 * an acquisition of appropriate locks followed by a commit phase to 2807 * implement whatever link state changes are indicated. 2808 */ 2809 static void bond_mii_monitor(struct work_struct *work) 2810 { 2811 struct bonding *bond = container_of(work, struct bonding, 2812 mii_work.work); 2813 bool should_notify_peers = false; 2814 bool commit; 2815 unsigned long delay; 2816 struct slave *slave; 2817 struct list_head *iter; 2818 2819 delay = msecs_to_jiffies(bond->params.miimon); 2820 2821 if (!bond_has_slaves(bond)) 2822 goto re_arm; 2823 2824 rcu_read_lock(); 2825 should_notify_peers = bond_should_notify_peers(bond); 2826 commit = !!bond_miimon_inspect(bond); 2827 if (bond->send_peer_notif) { 2828 rcu_read_unlock(); 2829 if (rtnl_trylock()) { 2830 bond->send_peer_notif--; 2831 rtnl_unlock(); 2832 } 2833 } else { 2834 rcu_read_unlock(); 2835 } 2836 2837 if (commit) { 2838 /* Race avoidance with bond_close cancel of workqueue */ 2839 if (!rtnl_trylock()) { 2840 delay = 1; 2841 should_notify_peers = false; 2842 goto re_arm; 2843 } 2844 2845 bond_for_each_slave(bond, slave, iter) { 2846 bond_commit_link_state(slave, BOND_SLAVE_NOTIFY_LATER); 2847 } 2848 bond_miimon_commit(bond); 2849 2850 rtnl_unlock(); /* might sleep, hold no other locks */ 2851 } 2852 2853 re_arm: 2854 if (bond->params.miimon) 2855 queue_delayed_work(bond->wq, &bond->mii_work, delay); 2856 2857 if (should_notify_peers) { 2858 if (!rtnl_trylock()) 2859 return; 2860 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, bond->dev); 2861 rtnl_unlock(); 2862 } 2863 } 2864 2865 static int bond_upper_dev_walk(struct net_device *upper, 2866 struct netdev_nested_priv *priv) 2867 { 2868 __be32 ip = *(__be32 *)priv->data; 2869 2870 return ip == bond_confirm_addr(upper, 0, ip); 2871 } 2872 2873 static bool bond_has_this_ip(struct bonding *bond, __be32 ip) 2874 { 2875 struct netdev_nested_priv priv = { 2876 .data = (void *)&ip, 2877 }; 2878 bool ret = false; 2879 2880 if (ip == bond_confirm_addr(bond->dev, 0, ip)) 2881 return true; 2882 2883 rcu_read_lock(); 2884 if (netdev_walk_all_upper_dev_rcu(bond->dev, bond_upper_dev_walk, &priv)) 2885 ret = true; 2886 rcu_read_unlock(); 2887 2888 return ret; 2889 } 2890 2891 #define BOND_VLAN_PROTO_NONE cpu_to_be16(0xffff) 2892 2893 static bool bond_handle_vlan(struct slave *slave, struct bond_vlan_tag *tags, 2894 struct sk_buff *skb) 2895 { 2896 struct net_device *bond_dev = slave->bond->dev; 2897 struct net_device *slave_dev = slave->dev; 2898 struct bond_vlan_tag *outer_tag = tags; 2899 2900 if (!tags || tags->vlan_proto == BOND_VLAN_PROTO_NONE) 2901 return true; 2902 2903 tags++; 2904 2905 /* Go through all the tags backwards and add them to the packet */ 2906 while (tags->vlan_proto != BOND_VLAN_PROTO_NONE) { 2907 if (!tags->vlan_id) { 2908 tags++; 2909 continue; 2910 } 2911 2912 slave_dbg(bond_dev, slave_dev, "inner tag: proto %X vid %X\n", 2913 ntohs(outer_tag->vlan_proto), tags->vlan_id); 2914 skb = vlan_insert_tag_set_proto(skb, tags->vlan_proto, 2915 tags->vlan_id); 2916 if (!skb) { 2917 net_err_ratelimited("failed to insert inner VLAN tag\n"); 2918 return false; 2919 } 2920 2921 tags++; 2922 } 2923 /* Set the outer tag */ 2924 if (outer_tag->vlan_id) { 2925 slave_dbg(bond_dev, slave_dev, "outer tag: proto %X vid %X\n", 2926 ntohs(outer_tag->vlan_proto), outer_tag->vlan_id); 2927 __vlan_hwaccel_put_tag(skb, outer_tag->vlan_proto, 2928 outer_tag->vlan_id); 2929 } 2930 2931 return true; 2932 } 2933 2934 /* We go to the (large) trouble of VLAN tagging ARP frames because 2935 * switches in VLAN mode (especially if ports are configured as 2936 * "native" to a VLAN) might not pass non-tagged frames. 2937 */ 2938 static void bond_arp_send(struct slave *slave, int arp_op, __be32 dest_ip, 2939 __be32 src_ip, struct bond_vlan_tag *tags) 2940 { 2941 struct net_device *bond_dev = slave->bond->dev; 2942 struct net_device *slave_dev = slave->dev; 2943 struct sk_buff *skb; 2944 2945 slave_dbg(bond_dev, slave_dev, "arp %d on slave: dst %pI4 src %pI4\n", 2946 arp_op, &dest_ip, &src_ip); 2947 2948 skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip, 2949 NULL, slave_dev->dev_addr, NULL); 2950 2951 if (!skb) { 2952 net_err_ratelimited("ARP packet allocation failed\n"); 2953 return; 2954 } 2955 2956 if (bond_handle_vlan(slave, tags, skb)) { 2957 slave_update_last_tx(slave); 2958 arp_xmit(skb); 2959 } 2960 2961 return; 2962 } 2963 2964 /* Validate the device path between the @start_dev and the @end_dev. 2965 * The path is valid if the @end_dev is reachable through device 2966 * stacking. 2967 * When the path is validated, collect any vlan information in the 2968 * path. 2969 */ 2970 struct bond_vlan_tag *bond_verify_device_path(struct net_device *start_dev, 2971 struct net_device *end_dev, 2972 int level) 2973 { 2974 struct bond_vlan_tag *tags; 2975 struct net_device *upper; 2976 struct list_head *iter; 2977 2978 if (start_dev == end_dev) { 2979 tags = kcalloc(level + 1, sizeof(*tags), GFP_ATOMIC); 2980 if (!tags) 2981 return ERR_PTR(-ENOMEM); 2982 tags[level].vlan_proto = BOND_VLAN_PROTO_NONE; 2983 return tags; 2984 } 2985 2986 netdev_for_each_upper_dev_rcu(start_dev, upper, iter) { 2987 tags = bond_verify_device_path(upper, end_dev, level + 1); 2988 if (IS_ERR_OR_NULL(tags)) { 2989 if (IS_ERR(tags)) 2990 return tags; 2991 continue; 2992 } 2993 if (is_vlan_dev(upper)) { 2994 tags[level].vlan_proto = vlan_dev_vlan_proto(upper); 2995 tags[level].vlan_id = vlan_dev_vlan_id(upper); 2996 } 2997 2998 return tags; 2999 } 3000 3001 return NULL; 3002 } 3003 3004 static void bond_arp_send_all(struct bonding *bond, struct slave *slave) 3005 { 3006 struct rtable *rt; 3007 struct bond_vlan_tag *tags; 3008 __be32 *targets = bond->params.arp_targets, addr; 3009 int i; 3010 3011 for (i = 0; i < BOND_MAX_ARP_TARGETS && targets[i]; i++) { 3012 slave_dbg(bond->dev, slave->dev, "%s: target %pI4\n", 3013 __func__, &targets[i]); 3014 tags = NULL; 3015 3016 /* Find out through which dev should the packet go */ 3017 rt = ip_route_output(dev_net(bond->dev), targets[i], 0, 0, 0, 3018 RT_SCOPE_LINK); 3019 if (IS_ERR(rt)) { 3020 /* there's no route to target - try to send arp 3021 * probe to generate any traffic (arp_validate=0) 3022 */ 3023 if (bond->params.arp_validate) 3024 pr_warn_once("%s: no route to arp_ip_target %pI4 and arp_validate is set\n", 3025 bond->dev->name, 3026 &targets[i]); 3027 bond_arp_send(slave, ARPOP_REQUEST, targets[i], 3028 0, tags); 3029 continue; 3030 } 3031 3032 /* bond device itself */ 3033 if (rt->dst.dev == bond->dev) 3034 goto found; 3035 3036 rcu_read_lock(); 3037 tags = bond_verify_device_path(bond->dev, rt->dst.dev, 0); 3038 rcu_read_unlock(); 3039 3040 if (!IS_ERR_OR_NULL(tags)) 3041 goto found; 3042 3043 /* Not our device - skip */ 3044 slave_dbg(bond->dev, slave->dev, "no path to arp_ip_target %pI4 via rt.dev %s\n", 3045 &targets[i], rt->dst.dev ? rt->dst.dev->name : "NULL"); 3046 3047 ip_rt_put(rt); 3048 continue; 3049 3050 found: 3051 addr = bond_confirm_addr(rt->dst.dev, targets[i], 0); 3052 ip_rt_put(rt); 3053 bond_arp_send(slave, ARPOP_REQUEST, targets[i], addr, tags); 3054 kfree(tags); 3055 } 3056 } 3057 3058 static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip) 3059 { 3060 int i; 3061 3062 if (!sip || !bond_has_this_ip(bond, tip)) { 3063 slave_dbg(bond->dev, slave->dev, "%s: sip %pI4 tip %pI4 not found\n", 3064 __func__, &sip, &tip); 3065 return; 3066 } 3067 3068 i = bond_get_targets_ip(bond->params.arp_targets, sip); 3069 if (i == -1) { 3070 slave_dbg(bond->dev, slave->dev, "%s: sip %pI4 not found in targets\n", 3071 __func__, &sip); 3072 return; 3073 } 3074 slave->last_rx = jiffies; 3075 slave->target_last_arp_rx[i] = jiffies; 3076 } 3077 3078 static int bond_arp_rcv(const struct sk_buff *skb, struct bonding *bond, 3079 struct slave *slave) 3080 { 3081 struct arphdr *arp = (struct arphdr *)skb->data; 3082 struct slave *curr_active_slave, *curr_arp_slave; 3083 unsigned char *arp_ptr; 3084 __be32 sip, tip; 3085 unsigned int alen; 3086 3087 alen = arp_hdr_len(bond->dev); 3088 3089 if (alen > skb_headlen(skb)) { 3090 arp = kmalloc(alen, GFP_ATOMIC); 3091 if (!arp) 3092 goto out_unlock; 3093 if (skb_copy_bits(skb, 0, arp, alen) < 0) 3094 goto out_unlock; 3095 } 3096 3097 if (arp->ar_hln != bond->dev->addr_len || 3098 skb->pkt_type == PACKET_OTHERHOST || 3099 skb->pkt_type == PACKET_LOOPBACK || 3100 arp->ar_hrd != htons(ARPHRD_ETHER) || 3101 arp->ar_pro != htons(ETH_P_IP) || 3102 arp->ar_pln != 4) 3103 goto out_unlock; 3104 3105 arp_ptr = (unsigned char *)(arp + 1); 3106 arp_ptr += bond->dev->addr_len; 3107 memcpy(&sip, arp_ptr, 4); 3108 arp_ptr += 4 + bond->dev->addr_len; 3109 memcpy(&tip, arp_ptr, 4); 3110 3111 slave_dbg(bond->dev, slave->dev, "%s: %s/%d av %d sv %d sip %pI4 tip %pI4\n", 3112 __func__, slave->dev->name, bond_slave_state(slave), 3113 bond->params.arp_validate, slave_do_arp_validate(bond, slave), 3114 &sip, &tip); 3115 3116 curr_active_slave = rcu_dereference(bond->curr_active_slave); 3117 curr_arp_slave = rcu_dereference(bond->current_arp_slave); 3118 3119 /* We 'trust' the received ARP enough to validate it if: 3120 * 3121 * (a) the slave receiving the ARP is active (which includes the 3122 * current ARP slave, if any), or 3123 * 3124 * (b) the receiving slave isn't active, but there is a currently 3125 * active slave and it received valid arp reply(s) after it became 3126 * the currently active slave, or 3127 * 3128 * (c) there is an ARP slave that sent an ARP during the prior ARP 3129 * interval, and we receive an ARP reply on any slave. We accept 3130 * these because switch FDB update delays may deliver the ARP 3131 * reply to a slave other than the sender of the ARP request. 3132 * 3133 * Note: for (b), backup slaves are receiving the broadcast ARP 3134 * request, not a reply. This request passes from the sending 3135 * slave through the L2 switch(es) to the receiving slave. Since 3136 * this is checking the request, sip/tip are swapped for 3137 * validation. 3138 * 3139 * This is done to avoid endless looping when we can't reach the 3140 * arp_ip_target and fool ourselves with our own arp requests. 3141 */ 3142 if (bond_is_active_slave(slave)) 3143 bond_validate_arp(bond, slave, sip, tip); 3144 else if (curr_active_slave && 3145 time_after(slave_last_rx(bond, curr_active_slave), 3146 curr_active_slave->last_link_up)) 3147 bond_validate_arp(bond, slave, tip, sip); 3148 else if (curr_arp_slave && (arp->ar_op == htons(ARPOP_REPLY)) && 3149 bond_time_in_interval(bond, slave_last_tx(curr_arp_slave), 1)) 3150 bond_validate_arp(bond, slave, sip, tip); 3151 3152 out_unlock: 3153 if (arp != (struct arphdr *)skb->data) 3154 kfree(arp); 3155 return RX_HANDLER_ANOTHER; 3156 } 3157 3158 #if IS_ENABLED(CONFIG_IPV6) 3159 static void bond_ns_send(struct slave *slave, const struct in6_addr *daddr, 3160 const struct in6_addr *saddr, struct bond_vlan_tag *tags) 3161 { 3162 struct net_device *bond_dev = slave->bond->dev; 3163 struct net_device *slave_dev = slave->dev; 3164 struct in6_addr mcaddr; 3165 struct sk_buff *skb; 3166 3167 slave_dbg(bond_dev, slave_dev, "NS on slave: dst %pI6c src %pI6c\n", 3168 daddr, saddr); 3169 3170 skb = ndisc_ns_create(slave_dev, daddr, saddr, 0); 3171 if (!skb) { 3172 net_err_ratelimited("NS packet allocation failed\n"); 3173 return; 3174 } 3175 3176 addrconf_addr_solict_mult(daddr, &mcaddr); 3177 if (bond_handle_vlan(slave, tags, skb)) { 3178 slave_update_last_tx(slave); 3179 ndisc_send_skb(skb, &mcaddr, saddr); 3180 } 3181 } 3182 3183 static void bond_ns_send_all(struct bonding *bond, struct slave *slave) 3184 { 3185 struct in6_addr *targets = bond->params.ns_targets; 3186 struct bond_vlan_tag *tags; 3187 struct dst_entry *dst; 3188 struct in6_addr saddr; 3189 struct flowi6 fl6; 3190 int i; 3191 3192 for (i = 0; i < BOND_MAX_NS_TARGETS && !ipv6_addr_any(&targets[i]); i++) { 3193 slave_dbg(bond->dev, slave->dev, "%s: target %pI6c\n", 3194 __func__, &targets[i]); 3195 tags = NULL; 3196 3197 /* Find out through which dev should the packet go */ 3198 memset(&fl6, 0, sizeof(struct flowi6)); 3199 fl6.daddr = targets[i]; 3200 fl6.flowi6_oif = bond->dev->ifindex; 3201 3202 dst = ip6_route_output(dev_net(bond->dev), NULL, &fl6); 3203 if (dst->error) { 3204 dst_release(dst); 3205 /* there's no route to target - try to send arp 3206 * probe to generate any traffic (arp_validate=0) 3207 */ 3208 if (bond->params.arp_validate) 3209 pr_warn_once("%s: no route to ns_ip6_target %pI6c and arp_validate is set\n", 3210 bond->dev->name, 3211 &targets[i]); 3212 bond_ns_send(slave, &targets[i], &in6addr_any, tags); 3213 continue; 3214 } 3215 3216 /* bond device itself */ 3217 if (dst->dev == bond->dev) 3218 goto found; 3219 3220 rcu_read_lock(); 3221 tags = bond_verify_device_path(bond->dev, dst->dev, 0); 3222 rcu_read_unlock(); 3223 3224 if (!IS_ERR_OR_NULL(tags)) 3225 goto found; 3226 3227 /* Not our device - skip */ 3228 slave_dbg(bond->dev, slave->dev, "no path to ns_ip6_target %pI6c via dst->dev %s\n", 3229 &targets[i], dst->dev ? dst->dev->name : "NULL"); 3230 3231 dst_release(dst); 3232 continue; 3233 3234 found: 3235 if (!ipv6_dev_get_saddr(dev_net(dst->dev), dst->dev, &targets[i], 0, &saddr)) 3236 bond_ns_send(slave, &targets[i], &saddr, tags); 3237 else 3238 bond_ns_send(slave, &targets[i], &in6addr_any, tags); 3239 3240 dst_release(dst); 3241 kfree(tags); 3242 } 3243 } 3244 3245 static int bond_confirm_addr6(struct net_device *dev, 3246 struct netdev_nested_priv *priv) 3247 { 3248 struct in6_addr *addr = (struct in6_addr *)priv->data; 3249 3250 return ipv6_chk_addr(dev_net(dev), addr, dev, 0); 3251 } 3252 3253 static bool bond_has_this_ip6(struct bonding *bond, struct in6_addr *addr) 3254 { 3255 struct netdev_nested_priv priv = { 3256 .data = addr, 3257 }; 3258 int ret = false; 3259 3260 if (bond_confirm_addr6(bond->dev, &priv)) 3261 return true; 3262 3263 rcu_read_lock(); 3264 if (netdev_walk_all_upper_dev_rcu(bond->dev, bond_confirm_addr6, &priv)) 3265 ret = true; 3266 rcu_read_unlock(); 3267 3268 return ret; 3269 } 3270 3271 static void bond_validate_na(struct bonding *bond, struct slave *slave, 3272 struct in6_addr *saddr, struct in6_addr *daddr) 3273 { 3274 int i; 3275 3276 /* Ignore NAs that: 3277 * 1. Source address is unspecified address. 3278 * 2. Dest address is neither all-nodes multicast address nor 3279 * exist on bond interface. 3280 */ 3281 if (ipv6_addr_any(saddr) || 3282 (!ipv6_addr_equal(daddr, &in6addr_linklocal_allnodes) && 3283 !bond_has_this_ip6(bond, daddr))) { 3284 slave_dbg(bond->dev, slave->dev, "%s: sip %pI6c tip %pI6c not found\n", 3285 __func__, saddr, daddr); 3286 return; 3287 } 3288 3289 i = bond_get_targets_ip6(bond->params.ns_targets, saddr); 3290 if (i == -1) { 3291 slave_dbg(bond->dev, slave->dev, "%s: sip %pI6c not found in targets\n", 3292 __func__, saddr); 3293 return; 3294 } 3295 slave->last_rx = jiffies; 3296 slave->target_last_arp_rx[i] = jiffies; 3297 } 3298 3299 static int bond_na_rcv(const struct sk_buff *skb, struct bonding *bond, 3300 struct slave *slave) 3301 { 3302 struct slave *curr_active_slave, *curr_arp_slave; 3303 struct in6_addr *saddr, *daddr; 3304 struct { 3305 struct ipv6hdr ip6; 3306 struct icmp6hdr icmp6; 3307 } *combined, _combined; 3308 3309 if (skb->pkt_type == PACKET_OTHERHOST || 3310 skb->pkt_type == PACKET_LOOPBACK) 3311 goto out; 3312 3313 combined = skb_header_pointer(skb, 0, sizeof(_combined), &_combined); 3314 if (!combined || combined->ip6.nexthdr != NEXTHDR_ICMP || 3315 (combined->icmp6.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION && 3316 combined->icmp6.icmp6_type != NDISC_NEIGHBOUR_ADVERTISEMENT)) 3317 goto out; 3318 3319 saddr = &combined->ip6.saddr; 3320 daddr = &combined->ip6.daddr; 3321 3322 slave_dbg(bond->dev, slave->dev, "%s: %s/%d av %d sv %d sip %pI6c tip %pI6c\n", 3323 __func__, slave->dev->name, bond_slave_state(slave), 3324 bond->params.arp_validate, slave_do_arp_validate(bond, slave), 3325 saddr, daddr); 3326 3327 curr_active_slave = rcu_dereference(bond->curr_active_slave); 3328 curr_arp_slave = rcu_dereference(bond->current_arp_slave); 3329 3330 /* We 'trust' the received ARP enough to validate it if: 3331 * see bond_arp_rcv(). 3332 */ 3333 if (bond_is_active_slave(slave)) 3334 bond_validate_na(bond, slave, saddr, daddr); 3335 else if (curr_active_slave && 3336 time_after(slave_last_rx(bond, curr_active_slave), 3337 curr_active_slave->last_link_up)) 3338 bond_validate_na(bond, slave, daddr, saddr); 3339 else if (curr_arp_slave && 3340 bond_time_in_interval(bond, slave_last_tx(curr_arp_slave), 1)) 3341 bond_validate_na(bond, slave, saddr, daddr); 3342 3343 out: 3344 return RX_HANDLER_ANOTHER; 3345 } 3346 #endif 3347 3348 int bond_rcv_validate(const struct sk_buff *skb, struct bonding *bond, 3349 struct slave *slave) 3350 { 3351 #if IS_ENABLED(CONFIG_IPV6) 3352 bool is_ipv6 = skb->protocol == __cpu_to_be16(ETH_P_IPV6); 3353 #endif 3354 bool is_arp = skb->protocol == __cpu_to_be16(ETH_P_ARP); 3355 3356 slave_dbg(bond->dev, slave->dev, "%s: skb->dev %s\n", 3357 __func__, skb->dev->name); 3358 3359 /* Use arp validate logic for both ARP and NS */ 3360 if (!slave_do_arp_validate(bond, slave)) { 3361 if ((slave_do_arp_validate_only(bond) && is_arp) || 3362 #if IS_ENABLED(CONFIG_IPV6) 3363 (slave_do_arp_validate_only(bond) && is_ipv6) || 3364 #endif 3365 !slave_do_arp_validate_only(bond)) 3366 slave->last_rx = jiffies; 3367 return RX_HANDLER_ANOTHER; 3368 } else if (is_arp) { 3369 return bond_arp_rcv(skb, bond, slave); 3370 #if IS_ENABLED(CONFIG_IPV6) 3371 } else if (is_ipv6) { 3372 return bond_na_rcv(skb, bond, slave); 3373 #endif 3374 } else { 3375 return RX_HANDLER_ANOTHER; 3376 } 3377 } 3378 3379 static void bond_send_validate(struct bonding *bond, struct slave *slave) 3380 { 3381 bond_arp_send_all(bond, slave); 3382 #if IS_ENABLED(CONFIG_IPV6) 3383 bond_ns_send_all(bond, slave); 3384 #endif 3385 } 3386 3387 /* function to verify if we're in the arp_interval timeslice, returns true if 3388 * (last_act - arp_interval) <= jiffies <= (last_act + mod * arp_interval + 3389 * arp_interval/2) . the arp_interval/2 is needed for really fast networks. 3390 */ 3391 static bool bond_time_in_interval(struct bonding *bond, unsigned long last_act, 3392 int mod) 3393 { 3394 int delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval); 3395 3396 return time_in_range(jiffies, 3397 last_act - delta_in_ticks, 3398 last_act + mod * delta_in_ticks + delta_in_ticks/2); 3399 } 3400 3401 /* This function is called regularly to monitor each slave's link 3402 * ensuring that traffic is being sent and received when arp monitoring 3403 * is used in load-balancing mode. if the adapter has been dormant, then an 3404 * arp is transmitted to generate traffic. see activebackup_arp_monitor for 3405 * arp monitoring in active backup mode. 3406 */ 3407 static void bond_loadbalance_arp_mon(struct bonding *bond) 3408 { 3409 struct slave *slave, *oldcurrent; 3410 struct list_head *iter; 3411 int do_failover = 0, slave_state_changed = 0; 3412 3413 if (!bond_has_slaves(bond)) 3414 goto re_arm; 3415 3416 rcu_read_lock(); 3417 3418 oldcurrent = rcu_dereference(bond->curr_active_slave); 3419 /* see if any of the previous devices are up now (i.e. they have 3420 * xmt and rcv traffic). the curr_active_slave does not come into 3421 * the picture unless it is null. also, slave->last_link_up is not 3422 * needed here because we send an arp on each slave and give a slave 3423 * as long as it needs to get the tx/rx within the delta. 3424 * TODO: what about up/down delay in arp mode? it wasn't here before 3425 * so it can wait 3426 */ 3427 bond_for_each_slave_rcu(bond, slave, iter) { 3428 unsigned long last_tx = slave_last_tx(slave); 3429 3430 bond_propose_link_state(slave, BOND_LINK_NOCHANGE); 3431 3432 if (slave->link != BOND_LINK_UP) { 3433 if (bond_time_in_interval(bond, last_tx, 1) && 3434 bond_time_in_interval(bond, slave->last_rx, 1)) { 3435 3436 bond_propose_link_state(slave, BOND_LINK_UP); 3437 slave_state_changed = 1; 3438 3439 /* primary_slave has no meaning in round-robin 3440 * mode. the window of a slave being up and 3441 * curr_active_slave being null after enslaving 3442 * is closed. 3443 */ 3444 if (!oldcurrent) { 3445 slave_info(bond->dev, slave->dev, "link status definitely up\n"); 3446 do_failover = 1; 3447 } else { 3448 slave_info(bond->dev, slave->dev, "interface is now up\n"); 3449 } 3450 } 3451 } else { 3452 /* slave->link == BOND_LINK_UP */ 3453 3454 /* not all switches will respond to an arp request 3455 * when the source ip is 0, so don't take the link down 3456 * if we don't know our ip yet 3457 */ 3458 if (!bond_time_in_interval(bond, last_tx, bond->params.missed_max) || 3459 !bond_time_in_interval(bond, slave->last_rx, bond->params.missed_max)) { 3460 3461 bond_propose_link_state(slave, BOND_LINK_DOWN); 3462 slave_state_changed = 1; 3463 3464 if (slave->link_failure_count < UINT_MAX) 3465 slave->link_failure_count++; 3466 3467 slave_info(bond->dev, slave->dev, "interface is now down\n"); 3468 3469 if (slave == oldcurrent) 3470 do_failover = 1; 3471 } 3472 } 3473 3474 /* note: if switch is in round-robin mode, all links 3475 * must tx arp to ensure all links rx an arp - otherwise 3476 * links may oscillate or not come up at all; if switch is 3477 * in something like xor mode, there is nothing we can 3478 * do - all replies will be rx'ed on same link causing slaves 3479 * to be unstable during low/no traffic periods 3480 */ 3481 if (bond_slave_is_up(slave)) 3482 bond_send_validate(bond, slave); 3483 } 3484 3485 rcu_read_unlock(); 3486 3487 if (do_failover || slave_state_changed) { 3488 if (!rtnl_trylock()) 3489 goto re_arm; 3490 3491 bond_for_each_slave(bond, slave, iter) { 3492 if (slave->link_new_state != BOND_LINK_NOCHANGE) 3493 slave->link = slave->link_new_state; 3494 } 3495 3496 if (slave_state_changed) { 3497 bond_slave_state_change(bond); 3498 if (BOND_MODE(bond) == BOND_MODE_XOR) 3499 bond_update_slave_arr(bond, NULL); 3500 } 3501 if (do_failover) { 3502 block_netpoll_tx(); 3503 bond_select_active_slave(bond); 3504 unblock_netpoll_tx(); 3505 } 3506 rtnl_unlock(); 3507 } 3508 3509 re_arm: 3510 if (bond->params.arp_interval) 3511 queue_delayed_work(bond->wq, &bond->arp_work, 3512 msecs_to_jiffies(bond->params.arp_interval)); 3513 } 3514 3515 /* Called to inspect slaves for active-backup mode ARP monitor link state 3516 * changes. Sets proposed link state in slaves to specify what action 3517 * should take place for the slave. Returns 0 if no changes are found, >0 3518 * if changes to link states must be committed. 3519 * 3520 * Called with rcu_read_lock held. 3521 */ 3522 static int bond_ab_arp_inspect(struct bonding *bond) 3523 { 3524 unsigned long last_tx, last_rx; 3525 struct list_head *iter; 3526 struct slave *slave; 3527 int commit = 0; 3528 3529 bond_for_each_slave_rcu(bond, slave, iter) { 3530 bond_propose_link_state(slave, BOND_LINK_NOCHANGE); 3531 last_rx = slave_last_rx(bond, slave); 3532 3533 if (slave->link != BOND_LINK_UP) { 3534 if (bond_time_in_interval(bond, last_rx, 1)) { 3535 bond_propose_link_state(slave, BOND_LINK_UP); 3536 commit++; 3537 } else if (slave->link == BOND_LINK_BACK) { 3538 bond_propose_link_state(slave, BOND_LINK_FAIL); 3539 commit++; 3540 } 3541 continue; 3542 } 3543 3544 /* Give slaves 2*delta after being enslaved or made 3545 * active. This avoids bouncing, as the last receive 3546 * times need a full ARP monitor cycle to be updated. 3547 */ 3548 if (bond_time_in_interval(bond, slave->last_link_up, 2)) 3549 continue; 3550 3551 /* Backup slave is down if: 3552 * - No current_arp_slave AND 3553 * - more than (missed_max+1)*delta since last receive AND 3554 * - the bond has an IP address 3555 * 3556 * Note: a non-null current_arp_slave indicates 3557 * the curr_active_slave went down and we are 3558 * searching for a new one; under this condition 3559 * we only take the curr_active_slave down - this 3560 * gives each slave a chance to tx/rx traffic 3561 * before being taken out 3562 */ 3563 if (!bond_is_active_slave(slave) && 3564 !rcu_access_pointer(bond->current_arp_slave) && 3565 !bond_time_in_interval(bond, last_rx, bond->params.missed_max + 1)) { 3566 bond_propose_link_state(slave, BOND_LINK_DOWN); 3567 commit++; 3568 } 3569 3570 /* Active slave is down if: 3571 * - more than missed_max*delta since transmitting OR 3572 * - (more than missed_max*delta since receive AND 3573 * the bond has an IP address) 3574 */ 3575 last_tx = slave_last_tx(slave); 3576 if (bond_is_active_slave(slave) && 3577 (!bond_time_in_interval(bond, last_tx, bond->params.missed_max) || 3578 !bond_time_in_interval(bond, last_rx, bond->params.missed_max))) { 3579 bond_propose_link_state(slave, BOND_LINK_DOWN); 3580 commit++; 3581 } 3582 } 3583 3584 return commit; 3585 } 3586 3587 /* Called to commit link state changes noted by inspection step of 3588 * active-backup mode ARP monitor. 3589 * 3590 * Called with RTNL hold. 3591 */ 3592 static void bond_ab_arp_commit(struct bonding *bond) 3593 { 3594 bool do_failover = false; 3595 struct list_head *iter; 3596 unsigned long last_tx; 3597 struct slave *slave; 3598 3599 bond_for_each_slave(bond, slave, iter) { 3600 switch (slave->link_new_state) { 3601 case BOND_LINK_NOCHANGE: 3602 continue; 3603 3604 case BOND_LINK_UP: 3605 last_tx = slave_last_tx(slave); 3606 if (rtnl_dereference(bond->curr_active_slave) != slave || 3607 (!rtnl_dereference(bond->curr_active_slave) && 3608 bond_time_in_interval(bond, last_tx, 1))) { 3609 struct slave *current_arp_slave; 3610 3611 current_arp_slave = rtnl_dereference(bond->current_arp_slave); 3612 bond_set_slave_link_state(slave, BOND_LINK_UP, 3613 BOND_SLAVE_NOTIFY_NOW); 3614 if (current_arp_slave) { 3615 bond_set_slave_inactive_flags( 3616 current_arp_slave, 3617 BOND_SLAVE_NOTIFY_NOW); 3618 RCU_INIT_POINTER(bond->current_arp_slave, NULL); 3619 } 3620 3621 slave_info(bond->dev, slave->dev, "link status definitely up\n"); 3622 3623 if (!rtnl_dereference(bond->curr_active_slave) || 3624 slave == rtnl_dereference(bond->primary_slave) || 3625 slave->prio > rtnl_dereference(bond->curr_active_slave)->prio) 3626 do_failover = true; 3627 3628 } 3629 3630 continue; 3631 3632 case BOND_LINK_DOWN: 3633 if (slave->link_failure_count < UINT_MAX) 3634 slave->link_failure_count++; 3635 3636 bond_set_slave_link_state(slave, BOND_LINK_DOWN, 3637 BOND_SLAVE_NOTIFY_NOW); 3638 bond_set_slave_inactive_flags(slave, 3639 BOND_SLAVE_NOTIFY_NOW); 3640 3641 slave_info(bond->dev, slave->dev, "link status definitely down, disabling slave\n"); 3642 3643 if (slave == rtnl_dereference(bond->curr_active_slave)) { 3644 RCU_INIT_POINTER(bond->current_arp_slave, NULL); 3645 do_failover = true; 3646 } 3647 3648 continue; 3649 3650 case BOND_LINK_FAIL: 3651 bond_set_slave_link_state(slave, BOND_LINK_FAIL, 3652 BOND_SLAVE_NOTIFY_NOW); 3653 bond_set_slave_inactive_flags(slave, 3654 BOND_SLAVE_NOTIFY_NOW); 3655 3656 /* A slave has just been enslaved and has become 3657 * the current active slave. 3658 */ 3659 if (rtnl_dereference(bond->curr_active_slave)) 3660 RCU_INIT_POINTER(bond->current_arp_slave, NULL); 3661 continue; 3662 3663 default: 3664 slave_err(bond->dev, slave->dev, 3665 "impossible: link_new_state %d on slave\n", 3666 slave->link_new_state); 3667 continue; 3668 } 3669 } 3670 3671 if (do_failover) { 3672 block_netpoll_tx(); 3673 bond_select_active_slave(bond); 3674 unblock_netpoll_tx(); 3675 } 3676 3677 bond_set_carrier(bond); 3678 } 3679 3680 /* Send ARP probes for active-backup mode ARP monitor. 3681 * 3682 * Called with rcu_read_lock held. 3683 */ 3684 static bool bond_ab_arp_probe(struct bonding *bond) 3685 { 3686 struct slave *slave, *before = NULL, *new_slave = NULL, 3687 *curr_arp_slave = rcu_dereference(bond->current_arp_slave), 3688 *curr_active_slave = rcu_dereference(bond->curr_active_slave); 3689 struct list_head *iter; 3690 bool found = false; 3691 bool should_notify_rtnl = BOND_SLAVE_NOTIFY_LATER; 3692 3693 if (curr_arp_slave && curr_active_slave) 3694 netdev_info(bond->dev, "PROBE: c_arp %s && cas %s BAD\n", 3695 curr_arp_slave->dev->name, 3696 curr_active_slave->dev->name); 3697 3698 if (curr_active_slave) { 3699 bond_send_validate(bond, curr_active_slave); 3700 return should_notify_rtnl; 3701 } 3702 3703 /* if we don't have a curr_active_slave, search for the next available 3704 * backup slave from the current_arp_slave and make it the candidate 3705 * for becoming the curr_active_slave 3706 */ 3707 3708 if (!curr_arp_slave) { 3709 curr_arp_slave = bond_first_slave_rcu(bond); 3710 if (!curr_arp_slave) 3711 return should_notify_rtnl; 3712 } 3713 3714 bond_for_each_slave_rcu(bond, slave, iter) { 3715 if (!found && !before && bond_slave_is_up(slave)) 3716 before = slave; 3717 3718 if (found && !new_slave && bond_slave_is_up(slave)) 3719 new_slave = slave; 3720 /* if the link state is up at this point, we 3721 * mark it down - this can happen if we have 3722 * simultaneous link failures and 3723 * reselect_active_interface doesn't make this 3724 * one the current slave so it is still marked 3725 * up when it is actually down 3726 */ 3727 if (!bond_slave_is_up(slave) && slave->link == BOND_LINK_UP) { 3728 bond_set_slave_link_state(slave, BOND_LINK_DOWN, 3729 BOND_SLAVE_NOTIFY_LATER); 3730 if (slave->link_failure_count < UINT_MAX) 3731 slave->link_failure_count++; 3732 3733 bond_set_slave_inactive_flags(slave, 3734 BOND_SLAVE_NOTIFY_LATER); 3735 3736 slave_info(bond->dev, slave->dev, "backup interface is now down\n"); 3737 } 3738 if (slave == curr_arp_slave) 3739 found = true; 3740 } 3741 3742 if (!new_slave && before) 3743 new_slave = before; 3744 3745 if (!new_slave) 3746 goto check_state; 3747 3748 bond_set_slave_link_state(new_slave, BOND_LINK_BACK, 3749 BOND_SLAVE_NOTIFY_LATER); 3750 bond_set_slave_active_flags(new_slave, BOND_SLAVE_NOTIFY_LATER); 3751 bond_send_validate(bond, new_slave); 3752 new_slave->last_link_up = jiffies; 3753 rcu_assign_pointer(bond->current_arp_slave, new_slave); 3754 3755 check_state: 3756 bond_for_each_slave_rcu(bond, slave, iter) { 3757 if (slave->should_notify || slave->should_notify_link) { 3758 should_notify_rtnl = BOND_SLAVE_NOTIFY_NOW; 3759 break; 3760 } 3761 } 3762 return should_notify_rtnl; 3763 } 3764 3765 static void bond_activebackup_arp_mon(struct bonding *bond) 3766 { 3767 bool should_notify_peers = false; 3768 bool should_notify_rtnl = false; 3769 int delta_in_ticks; 3770 3771 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval); 3772 3773 if (!bond_has_slaves(bond)) 3774 goto re_arm; 3775 3776 rcu_read_lock(); 3777 3778 should_notify_peers = bond_should_notify_peers(bond); 3779 3780 if (bond_ab_arp_inspect(bond)) { 3781 rcu_read_unlock(); 3782 3783 /* Race avoidance with bond_close flush of workqueue */ 3784 if (!rtnl_trylock()) { 3785 delta_in_ticks = 1; 3786 should_notify_peers = false; 3787 goto re_arm; 3788 } 3789 3790 bond_ab_arp_commit(bond); 3791 3792 rtnl_unlock(); 3793 rcu_read_lock(); 3794 } 3795 3796 should_notify_rtnl = bond_ab_arp_probe(bond); 3797 rcu_read_unlock(); 3798 3799 re_arm: 3800 if (bond->params.arp_interval) 3801 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks); 3802 3803 if (should_notify_peers || should_notify_rtnl) { 3804 if (!rtnl_trylock()) 3805 return; 3806 3807 if (should_notify_peers) { 3808 bond->send_peer_notif--; 3809 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, 3810 bond->dev); 3811 } 3812 if (should_notify_rtnl) { 3813 bond_slave_state_notify(bond); 3814 bond_slave_link_notify(bond); 3815 } 3816 3817 rtnl_unlock(); 3818 } 3819 } 3820 3821 static void bond_arp_monitor(struct work_struct *work) 3822 { 3823 struct bonding *bond = container_of(work, struct bonding, 3824 arp_work.work); 3825 3826 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) 3827 bond_activebackup_arp_mon(bond); 3828 else 3829 bond_loadbalance_arp_mon(bond); 3830 } 3831 3832 /*-------------------------- netdev event handling --------------------------*/ 3833 3834 /* Change device name */ 3835 static int bond_event_changename(struct bonding *bond) 3836 { 3837 bond_remove_proc_entry(bond); 3838 bond_create_proc_entry(bond); 3839 3840 bond_debug_reregister(bond); 3841 3842 return NOTIFY_DONE; 3843 } 3844 3845 static int bond_master_netdev_event(unsigned long event, 3846 struct net_device *bond_dev) 3847 { 3848 struct bonding *event_bond = netdev_priv(bond_dev); 3849 3850 netdev_dbg(bond_dev, "%s called\n", __func__); 3851 3852 switch (event) { 3853 case NETDEV_CHANGENAME: 3854 return bond_event_changename(event_bond); 3855 case NETDEV_UNREGISTER: 3856 bond_remove_proc_entry(event_bond); 3857 #ifdef CONFIG_XFRM_OFFLOAD 3858 xfrm_dev_state_flush(dev_net(bond_dev), bond_dev, true); 3859 #endif /* CONFIG_XFRM_OFFLOAD */ 3860 break; 3861 case NETDEV_REGISTER: 3862 bond_create_proc_entry(event_bond); 3863 break; 3864 default: 3865 break; 3866 } 3867 3868 return NOTIFY_DONE; 3869 } 3870 3871 static int bond_slave_netdev_event(unsigned long event, 3872 struct net_device *slave_dev) 3873 { 3874 struct slave *slave = bond_slave_get_rtnl(slave_dev), *primary; 3875 struct bonding *bond; 3876 struct net_device *bond_dev; 3877 3878 /* A netdev event can be generated while enslaving a device 3879 * before netdev_rx_handler_register is called in which case 3880 * slave will be NULL 3881 */ 3882 if (!slave) { 3883 netdev_dbg(slave_dev, "%s called on NULL slave\n", __func__); 3884 return NOTIFY_DONE; 3885 } 3886 3887 bond_dev = slave->bond->dev; 3888 bond = slave->bond; 3889 primary = rtnl_dereference(bond->primary_slave); 3890 3891 slave_dbg(bond_dev, slave_dev, "%s called\n", __func__); 3892 3893 switch (event) { 3894 case NETDEV_UNREGISTER: 3895 if (bond_dev->type != ARPHRD_ETHER) 3896 bond_release_and_destroy(bond_dev, slave_dev); 3897 else 3898 __bond_release_one(bond_dev, slave_dev, false, true); 3899 break; 3900 case NETDEV_UP: 3901 case NETDEV_CHANGE: 3902 /* For 802.3ad mode only: 3903 * Getting invalid Speed/Duplex values here will put slave 3904 * in weird state. Mark it as link-fail if the link was 3905 * previously up or link-down if it hasn't yet come up, and 3906 * let link-monitoring (miimon) set it right when correct 3907 * speeds/duplex are available. 3908 */ 3909 if (bond_update_speed_duplex(slave) && 3910 BOND_MODE(bond) == BOND_MODE_8023AD) { 3911 if (slave->last_link_up) 3912 slave->link = BOND_LINK_FAIL; 3913 else 3914 slave->link = BOND_LINK_DOWN; 3915 } 3916 3917 if (BOND_MODE(bond) == BOND_MODE_8023AD) 3918 bond_3ad_adapter_speed_duplex_changed(slave); 3919 fallthrough; 3920 case NETDEV_DOWN: 3921 /* Refresh slave-array if applicable! 3922 * If the setup does not use miimon or arpmon (mode-specific!), 3923 * then these events will not cause the slave-array to be 3924 * refreshed. This will cause xmit to use a slave that is not 3925 * usable. Avoid such situation by refeshing the array at these 3926 * events. If these (miimon/arpmon) parameters are configured 3927 * then array gets refreshed twice and that should be fine! 3928 */ 3929 if (bond_mode_can_use_xmit_hash(bond)) 3930 bond_update_slave_arr(bond, NULL); 3931 break; 3932 case NETDEV_CHANGEMTU: 3933 /* TODO: Should slaves be allowed to 3934 * independently alter their MTU? For 3935 * an active-backup bond, slaves need 3936 * not be the same type of device, so 3937 * MTUs may vary. For other modes, 3938 * slaves arguably should have the 3939 * same MTUs. To do this, we'd need to 3940 * take over the slave's change_mtu 3941 * function for the duration of their 3942 * servitude. 3943 */ 3944 break; 3945 case NETDEV_CHANGENAME: 3946 /* we don't care if we don't have primary set */ 3947 if (!bond_uses_primary(bond) || 3948 !bond->params.primary[0]) 3949 break; 3950 3951 if (slave == primary) { 3952 /* slave's name changed - he's no longer primary */ 3953 RCU_INIT_POINTER(bond->primary_slave, NULL); 3954 } else if (!strcmp(slave_dev->name, bond->params.primary)) { 3955 /* we have a new primary slave */ 3956 rcu_assign_pointer(bond->primary_slave, slave); 3957 } else { /* we didn't change primary - exit */ 3958 break; 3959 } 3960 3961 netdev_info(bond->dev, "Primary slave changed to %s, reselecting active slave\n", 3962 primary ? slave_dev->name : "none"); 3963 3964 block_netpoll_tx(); 3965 bond_select_active_slave(bond); 3966 unblock_netpoll_tx(); 3967 break; 3968 case NETDEV_FEAT_CHANGE: 3969 if (!bond->notifier_ctx) { 3970 bond->notifier_ctx = true; 3971 bond_compute_features(bond); 3972 bond->notifier_ctx = false; 3973 } 3974 break; 3975 case NETDEV_RESEND_IGMP: 3976 /* Propagate to master device */ 3977 call_netdevice_notifiers(event, slave->bond->dev); 3978 break; 3979 case NETDEV_XDP_FEAT_CHANGE: 3980 bond_xdp_set_features(bond_dev); 3981 break; 3982 default: 3983 break; 3984 } 3985 3986 return NOTIFY_DONE; 3987 } 3988 3989 /* bond_netdev_event: handle netdev notifier chain events. 3990 * 3991 * This function receives events for the netdev chain. The caller (an 3992 * ioctl handler calling blocking_notifier_call_chain) holds the necessary 3993 * locks for us to safely manipulate the slave devices (RTNL lock, 3994 * dev_probe_lock). 3995 */ 3996 static int bond_netdev_event(struct notifier_block *this, 3997 unsigned long event, void *ptr) 3998 { 3999 struct net_device *event_dev = netdev_notifier_info_to_dev(ptr); 4000 4001 netdev_dbg(event_dev, "%s received %s\n", 4002 __func__, netdev_cmd_to_name(event)); 4003 4004 if (!(event_dev->priv_flags & IFF_BONDING)) 4005 return NOTIFY_DONE; 4006 4007 if (event_dev->flags & IFF_MASTER) { 4008 int ret; 4009 4010 ret = bond_master_netdev_event(event, event_dev); 4011 if (ret != NOTIFY_DONE) 4012 return ret; 4013 } 4014 4015 if (event_dev->flags & IFF_SLAVE) 4016 return bond_slave_netdev_event(event, event_dev); 4017 4018 return NOTIFY_DONE; 4019 } 4020 4021 static struct notifier_block bond_netdev_notifier = { 4022 .notifier_call = bond_netdev_event, 4023 }; 4024 4025 /*---------------------------- Hashing Policies -----------------------------*/ 4026 4027 /* Helper to access data in a packet, with or without a backing skb. 4028 * If skb is given the data is linearized if necessary via pskb_may_pull. 4029 */ 4030 static inline const void *bond_pull_data(struct sk_buff *skb, 4031 const void *data, int hlen, int n) 4032 { 4033 if (likely(n <= hlen)) 4034 return data; 4035 else if (skb && likely(pskb_may_pull(skb, n))) 4036 return skb->data; 4037 4038 return NULL; 4039 } 4040 4041 /* L2 hash helper */ 4042 static inline u32 bond_eth_hash(struct sk_buff *skb, const void *data, int mhoff, int hlen) 4043 { 4044 struct ethhdr *ep; 4045 4046 data = bond_pull_data(skb, data, hlen, mhoff + sizeof(struct ethhdr)); 4047 if (!data) 4048 return 0; 4049 4050 ep = (struct ethhdr *)(data + mhoff); 4051 return ep->h_dest[5] ^ ep->h_source[5] ^ be16_to_cpu(ep->h_proto); 4052 } 4053 4054 static bool bond_flow_ip(struct sk_buff *skb, struct flow_keys *fk, const void *data, 4055 int hlen, __be16 l2_proto, int *nhoff, int *ip_proto, bool l34) 4056 { 4057 const struct ipv6hdr *iph6; 4058 const struct iphdr *iph; 4059 4060 if (l2_proto == htons(ETH_P_IP)) { 4061 data = bond_pull_data(skb, data, hlen, *nhoff + sizeof(*iph)); 4062 if (!data) 4063 return false; 4064 4065 iph = (const struct iphdr *)(data + *nhoff); 4066 iph_to_flow_copy_v4addrs(fk, iph); 4067 *nhoff += iph->ihl << 2; 4068 if (!ip_is_fragment(iph)) 4069 *ip_proto = iph->protocol; 4070 } else if (l2_proto == htons(ETH_P_IPV6)) { 4071 data = bond_pull_data(skb, data, hlen, *nhoff + sizeof(*iph6)); 4072 if (!data) 4073 return false; 4074 4075 iph6 = (const struct ipv6hdr *)(data + *nhoff); 4076 iph_to_flow_copy_v6addrs(fk, iph6); 4077 *nhoff += sizeof(*iph6); 4078 *ip_proto = iph6->nexthdr; 4079 } else { 4080 return false; 4081 } 4082 4083 if (l34 && *ip_proto >= 0) 4084 fk->ports.ports = __skb_flow_get_ports(skb, *nhoff, *ip_proto, data, hlen); 4085 4086 return true; 4087 } 4088 4089 static u32 bond_vlan_srcmac_hash(struct sk_buff *skb, const void *data, int mhoff, int hlen) 4090 { 4091 u32 srcmac_vendor = 0, srcmac_dev = 0; 4092 struct ethhdr *mac_hdr; 4093 u16 vlan = 0; 4094 int i; 4095 4096 data = bond_pull_data(skb, data, hlen, mhoff + sizeof(struct ethhdr)); 4097 if (!data) 4098 return 0; 4099 mac_hdr = (struct ethhdr *)(data + mhoff); 4100 4101 for (i = 0; i < 3; i++) 4102 srcmac_vendor = (srcmac_vendor << 8) | mac_hdr->h_source[i]; 4103 4104 for (i = 3; i < ETH_ALEN; i++) 4105 srcmac_dev = (srcmac_dev << 8) | mac_hdr->h_source[i]; 4106 4107 if (skb && skb_vlan_tag_present(skb)) 4108 vlan = skb_vlan_tag_get(skb); 4109 4110 return vlan ^ srcmac_vendor ^ srcmac_dev; 4111 } 4112 4113 /* Extract the appropriate headers based on bond's xmit policy */ 4114 static bool bond_flow_dissect(struct bonding *bond, struct sk_buff *skb, const void *data, 4115 __be16 l2_proto, int nhoff, int hlen, struct flow_keys *fk) 4116 { 4117 bool l34 = bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34; 4118 int ip_proto = -1; 4119 4120 switch (bond->params.xmit_policy) { 4121 case BOND_XMIT_POLICY_ENCAP23: 4122 case BOND_XMIT_POLICY_ENCAP34: 4123 memset(fk, 0, sizeof(*fk)); 4124 return __skb_flow_dissect(NULL, skb, &flow_keys_bonding, 4125 fk, data, l2_proto, nhoff, hlen, 0); 4126 default: 4127 break; 4128 } 4129 4130 fk->ports.ports = 0; 4131 memset(&fk->icmp, 0, sizeof(fk->icmp)); 4132 if (!bond_flow_ip(skb, fk, data, hlen, l2_proto, &nhoff, &ip_proto, l34)) 4133 return false; 4134 4135 /* ICMP error packets contains at least 8 bytes of the header 4136 * of the packet which generated the error. Use this information 4137 * to correlate ICMP error packets within the same flow which 4138 * generated the error. 4139 */ 4140 if (ip_proto == IPPROTO_ICMP || ip_proto == IPPROTO_ICMPV6) { 4141 skb_flow_get_icmp_tci(skb, &fk->icmp, data, nhoff, hlen); 4142 if (ip_proto == IPPROTO_ICMP) { 4143 if (!icmp_is_err(fk->icmp.type)) 4144 return true; 4145 4146 nhoff += sizeof(struct icmphdr); 4147 } else if (ip_proto == IPPROTO_ICMPV6) { 4148 if (!icmpv6_is_err(fk->icmp.type)) 4149 return true; 4150 4151 nhoff += sizeof(struct icmp6hdr); 4152 } 4153 return bond_flow_ip(skb, fk, data, hlen, l2_proto, &nhoff, &ip_proto, l34); 4154 } 4155 4156 return true; 4157 } 4158 4159 static u32 bond_ip_hash(u32 hash, struct flow_keys *flow, int xmit_policy) 4160 { 4161 hash ^= (__force u32)flow_get_u32_dst(flow) ^ 4162 (__force u32)flow_get_u32_src(flow); 4163 hash ^= (hash >> 16); 4164 hash ^= (hash >> 8); 4165 4166 /* discard lowest hash bit to deal with the common even ports pattern */ 4167 if (xmit_policy == BOND_XMIT_POLICY_LAYER34 || 4168 xmit_policy == BOND_XMIT_POLICY_ENCAP34) 4169 return hash >> 1; 4170 4171 return hash; 4172 } 4173 4174 /* Generate hash based on xmit policy. If @skb is given it is used to linearize 4175 * the data as required, but this function can be used without it if the data is 4176 * known to be linear (e.g. with xdp_buff). 4177 */ 4178 static u32 __bond_xmit_hash(struct bonding *bond, struct sk_buff *skb, const void *data, 4179 __be16 l2_proto, int mhoff, int nhoff, int hlen) 4180 { 4181 struct flow_keys flow; 4182 u32 hash; 4183 4184 if (bond->params.xmit_policy == BOND_XMIT_POLICY_VLAN_SRCMAC) 4185 return bond_vlan_srcmac_hash(skb, data, mhoff, hlen); 4186 4187 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER2 || 4188 !bond_flow_dissect(bond, skb, data, l2_proto, nhoff, hlen, &flow)) 4189 return bond_eth_hash(skb, data, mhoff, hlen); 4190 4191 if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER23 || 4192 bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP23) { 4193 hash = bond_eth_hash(skb, data, mhoff, hlen); 4194 } else { 4195 if (flow.icmp.id) 4196 memcpy(&hash, &flow.icmp, sizeof(hash)); 4197 else 4198 memcpy(&hash, &flow.ports.ports, sizeof(hash)); 4199 } 4200 4201 return bond_ip_hash(hash, &flow, bond->params.xmit_policy); 4202 } 4203 4204 /** 4205 * bond_xmit_hash - generate a hash value based on the xmit policy 4206 * @bond: bonding device 4207 * @skb: buffer to use for headers 4208 * 4209 * This function will extract the necessary headers from the skb buffer and use 4210 * them to generate a hash based on the xmit_policy set in the bonding device 4211 */ 4212 u32 bond_xmit_hash(struct bonding *bond, struct sk_buff *skb) 4213 { 4214 if (bond->params.xmit_policy == BOND_XMIT_POLICY_ENCAP34 && 4215 skb->l4_hash) 4216 return skb->hash; 4217 4218 return __bond_xmit_hash(bond, skb, skb->data, skb->protocol, 4219 0, skb_network_offset(skb), 4220 skb_headlen(skb)); 4221 } 4222 4223 /** 4224 * bond_xmit_hash_xdp - generate a hash value based on the xmit policy 4225 * @bond: bonding device 4226 * @xdp: buffer to use for headers 4227 * 4228 * The XDP variant of bond_xmit_hash. 4229 */ 4230 static u32 bond_xmit_hash_xdp(struct bonding *bond, struct xdp_buff *xdp) 4231 { 4232 struct ethhdr *eth; 4233 4234 if (xdp->data + sizeof(struct ethhdr) > xdp->data_end) 4235 return 0; 4236 4237 eth = (struct ethhdr *)xdp->data; 4238 4239 return __bond_xmit_hash(bond, NULL, xdp->data, eth->h_proto, 0, 4240 sizeof(struct ethhdr), xdp->data_end - xdp->data); 4241 } 4242 4243 /*-------------------------- Device entry points ----------------------------*/ 4244 4245 void bond_work_init_all(struct bonding *bond) 4246 { 4247 INIT_DELAYED_WORK(&bond->mcast_work, 4248 bond_resend_igmp_join_requests_delayed); 4249 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor); 4250 INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor); 4251 INIT_DELAYED_WORK(&bond->arp_work, bond_arp_monitor); 4252 INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler); 4253 INIT_DELAYED_WORK(&bond->slave_arr_work, bond_slave_arr_handler); 4254 } 4255 4256 static void bond_work_cancel_all(struct bonding *bond) 4257 { 4258 cancel_delayed_work_sync(&bond->mii_work); 4259 cancel_delayed_work_sync(&bond->arp_work); 4260 cancel_delayed_work_sync(&bond->alb_work); 4261 cancel_delayed_work_sync(&bond->ad_work); 4262 cancel_delayed_work_sync(&bond->mcast_work); 4263 cancel_delayed_work_sync(&bond->slave_arr_work); 4264 } 4265 4266 static int bond_open(struct net_device *bond_dev) 4267 { 4268 struct bonding *bond = netdev_priv(bond_dev); 4269 struct list_head *iter; 4270 struct slave *slave; 4271 4272 if (BOND_MODE(bond) == BOND_MODE_ROUNDROBIN && !bond->rr_tx_counter) { 4273 bond->rr_tx_counter = alloc_percpu(u32); 4274 if (!bond->rr_tx_counter) 4275 return -ENOMEM; 4276 } 4277 4278 /* reset slave->backup and slave->inactive */ 4279 if (bond_has_slaves(bond)) { 4280 bond_for_each_slave(bond, slave, iter) { 4281 if (bond_uses_primary(bond) && 4282 slave != rcu_access_pointer(bond->curr_active_slave)) { 4283 bond_set_slave_inactive_flags(slave, 4284 BOND_SLAVE_NOTIFY_NOW); 4285 } else if (BOND_MODE(bond) != BOND_MODE_8023AD) { 4286 bond_set_slave_active_flags(slave, 4287 BOND_SLAVE_NOTIFY_NOW); 4288 } 4289 } 4290 } 4291 4292 if (bond_is_lb(bond)) { 4293 /* bond_alb_initialize must be called before the timer 4294 * is started. 4295 */ 4296 if (bond_alb_initialize(bond, (BOND_MODE(bond) == BOND_MODE_ALB))) 4297 return -ENOMEM; 4298 if (bond->params.tlb_dynamic_lb || BOND_MODE(bond) == BOND_MODE_ALB) 4299 queue_delayed_work(bond->wq, &bond->alb_work, 0); 4300 } 4301 4302 if (bond->params.miimon) /* link check interval, in milliseconds. */ 4303 queue_delayed_work(bond->wq, &bond->mii_work, 0); 4304 4305 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */ 4306 queue_delayed_work(bond->wq, &bond->arp_work, 0); 4307 bond->recv_probe = bond_rcv_validate; 4308 } 4309 4310 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 4311 queue_delayed_work(bond->wq, &bond->ad_work, 0); 4312 /* register to receive LACPDUs */ 4313 bond->recv_probe = bond_3ad_lacpdu_recv; 4314 bond_3ad_initiate_agg_selection(bond, 1); 4315 4316 bond_for_each_slave(bond, slave, iter) 4317 dev_mc_add(slave->dev, lacpdu_mcast_addr); 4318 } 4319 4320 if (bond_mode_can_use_xmit_hash(bond)) 4321 bond_update_slave_arr(bond, NULL); 4322 4323 return 0; 4324 } 4325 4326 static int bond_close(struct net_device *bond_dev) 4327 { 4328 struct bonding *bond = netdev_priv(bond_dev); 4329 struct slave *slave; 4330 4331 bond_work_cancel_all(bond); 4332 bond->send_peer_notif = 0; 4333 if (bond_is_lb(bond)) 4334 bond_alb_deinitialize(bond); 4335 bond->recv_probe = NULL; 4336 4337 if (bond_uses_primary(bond)) { 4338 rcu_read_lock(); 4339 slave = rcu_dereference(bond->curr_active_slave); 4340 if (slave) 4341 bond_hw_addr_flush(bond_dev, slave->dev); 4342 rcu_read_unlock(); 4343 } else { 4344 struct list_head *iter; 4345 4346 bond_for_each_slave(bond, slave, iter) 4347 bond_hw_addr_flush(bond_dev, slave->dev); 4348 } 4349 4350 return 0; 4351 } 4352 4353 /* fold stats, assuming all rtnl_link_stats64 fields are u64, but 4354 * that some drivers can provide 32bit values only. 4355 */ 4356 static void bond_fold_stats(struct rtnl_link_stats64 *_res, 4357 const struct rtnl_link_stats64 *_new, 4358 const struct rtnl_link_stats64 *_old) 4359 { 4360 const u64 *new = (const u64 *)_new; 4361 const u64 *old = (const u64 *)_old; 4362 u64 *res = (u64 *)_res; 4363 int i; 4364 4365 for (i = 0; i < sizeof(*_res) / sizeof(u64); i++) { 4366 u64 nv = new[i]; 4367 u64 ov = old[i]; 4368 s64 delta = nv - ov; 4369 4370 /* detects if this particular field is 32bit only */ 4371 if (((nv | ov) >> 32) == 0) 4372 delta = (s64)(s32)((u32)nv - (u32)ov); 4373 4374 /* filter anomalies, some drivers reset their stats 4375 * at down/up events. 4376 */ 4377 if (delta > 0) 4378 res[i] += delta; 4379 } 4380 } 4381 4382 #ifdef CONFIG_LOCKDEP 4383 static int bond_get_lowest_level_rcu(struct net_device *dev) 4384 { 4385 struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1]; 4386 struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1]; 4387 int cur = 0, max = 0; 4388 4389 now = dev; 4390 iter = &dev->adj_list.lower; 4391 4392 while (1) { 4393 next = NULL; 4394 while (1) { 4395 ldev = netdev_next_lower_dev_rcu(now, &iter); 4396 if (!ldev) 4397 break; 4398 4399 next = ldev; 4400 niter = &ldev->adj_list.lower; 4401 dev_stack[cur] = now; 4402 iter_stack[cur++] = iter; 4403 if (max <= cur) 4404 max = cur; 4405 break; 4406 } 4407 4408 if (!next) { 4409 if (!cur) 4410 return max; 4411 next = dev_stack[--cur]; 4412 niter = iter_stack[cur]; 4413 } 4414 4415 now = next; 4416 iter = niter; 4417 } 4418 4419 return max; 4420 } 4421 #endif 4422 4423 static void bond_get_stats(struct net_device *bond_dev, 4424 struct rtnl_link_stats64 *stats) 4425 { 4426 struct bonding *bond = netdev_priv(bond_dev); 4427 struct rtnl_link_stats64 temp; 4428 struct list_head *iter; 4429 struct slave *slave; 4430 int nest_level = 0; 4431 4432 4433 rcu_read_lock(); 4434 #ifdef CONFIG_LOCKDEP 4435 nest_level = bond_get_lowest_level_rcu(bond_dev); 4436 #endif 4437 4438 spin_lock_nested(&bond->stats_lock, nest_level); 4439 memcpy(stats, &bond->bond_stats, sizeof(*stats)); 4440 4441 bond_for_each_slave_rcu(bond, slave, iter) { 4442 const struct rtnl_link_stats64 *new = 4443 dev_get_stats(slave->dev, &temp); 4444 4445 bond_fold_stats(stats, new, &slave->slave_stats); 4446 4447 /* save off the slave stats for the next run */ 4448 memcpy(&slave->slave_stats, new, sizeof(*new)); 4449 } 4450 4451 memcpy(&bond->bond_stats, stats, sizeof(*stats)); 4452 spin_unlock(&bond->stats_lock); 4453 rcu_read_unlock(); 4454 } 4455 4456 static int bond_eth_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd) 4457 { 4458 struct bonding *bond = netdev_priv(bond_dev); 4459 struct mii_ioctl_data *mii = NULL; 4460 4461 netdev_dbg(bond_dev, "bond_eth_ioctl: cmd=%d\n", cmd); 4462 4463 switch (cmd) { 4464 case SIOCGMIIPHY: 4465 mii = if_mii(ifr); 4466 if (!mii) 4467 return -EINVAL; 4468 4469 mii->phy_id = 0; 4470 fallthrough; 4471 case SIOCGMIIREG: 4472 /* We do this again just in case we were called by SIOCGMIIREG 4473 * instead of SIOCGMIIPHY. 4474 */ 4475 mii = if_mii(ifr); 4476 if (!mii) 4477 return -EINVAL; 4478 4479 if (mii->reg_num == 1) { 4480 mii->val_out = 0; 4481 if (netif_carrier_ok(bond->dev)) 4482 mii->val_out = BMSR_LSTATUS; 4483 } 4484 4485 break; 4486 default: 4487 return -EOPNOTSUPP; 4488 } 4489 4490 return 0; 4491 } 4492 4493 static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd) 4494 { 4495 struct bonding *bond = netdev_priv(bond_dev); 4496 struct net_device *slave_dev = NULL; 4497 struct ifbond k_binfo; 4498 struct ifbond __user *u_binfo = NULL; 4499 struct ifslave k_sinfo; 4500 struct ifslave __user *u_sinfo = NULL; 4501 struct bond_opt_value newval; 4502 struct net *net; 4503 int res = 0; 4504 4505 netdev_dbg(bond_dev, "bond_ioctl: cmd=%d\n", cmd); 4506 4507 switch (cmd) { 4508 case SIOCBONDINFOQUERY: 4509 u_binfo = (struct ifbond __user *)ifr->ifr_data; 4510 4511 if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) 4512 return -EFAULT; 4513 4514 bond_info_query(bond_dev, &k_binfo); 4515 if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) 4516 return -EFAULT; 4517 4518 return 0; 4519 case SIOCBONDSLAVEINFOQUERY: 4520 u_sinfo = (struct ifslave __user *)ifr->ifr_data; 4521 4522 if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) 4523 return -EFAULT; 4524 4525 res = bond_slave_info_query(bond_dev, &k_sinfo); 4526 if (res == 0 && 4527 copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) 4528 return -EFAULT; 4529 4530 return res; 4531 default: 4532 break; 4533 } 4534 4535 net = dev_net(bond_dev); 4536 4537 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 4538 return -EPERM; 4539 4540 slave_dev = __dev_get_by_name(net, ifr->ifr_slave); 4541 4542 slave_dbg(bond_dev, slave_dev, "slave_dev=%p:\n", slave_dev); 4543 4544 if (!slave_dev) 4545 return -ENODEV; 4546 4547 switch (cmd) { 4548 case SIOCBONDENSLAVE: 4549 res = bond_enslave(bond_dev, slave_dev, NULL); 4550 break; 4551 case SIOCBONDRELEASE: 4552 res = bond_release(bond_dev, slave_dev); 4553 break; 4554 case SIOCBONDSETHWADDR: 4555 res = bond_set_dev_addr(bond_dev, slave_dev); 4556 break; 4557 case SIOCBONDCHANGEACTIVE: 4558 bond_opt_initstr(&newval, slave_dev->name); 4559 res = __bond_opt_set_notify(bond, BOND_OPT_ACTIVE_SLAVE, 4560 &newval); 4561 break; 4562 default: 4563 res = -EOPNOTSUPP; 4564 } 4565 4566 return res; 4567 } 4568 4569 static int bond_siocdevprivate(struct net_device *bond_dev, struct ifreq *ifr, 4570 void __user *data, int cmd) 4571 { 4572 struct ifreq ifrdata = { .ifr_data = data }; 4573 4574 switch (cmd) { 4575 case BOND_INFO_QUERY_OLD: 4576 return bond_do_ioctl(bond_dev, &ifrdata, SIOCBONDINFOQUERY); 4577 case BOND_SLAVE_INFO_QUERY_OLD: 4578 return bond_do_ioctl(bond_dev, &ifrdata, SIOCBONDSLAVEINFOQUERY); 4579 case BOND_ENSLAVE_OLD: 4580 return bond_do_ioctl(bond_dev, ifr, SIOCBONDENSLAVE); 4581 case BOND_RELEASE_OLD: 4582 return bond_do_ioctl(bond_dev, ifr, SIOCBONDRELEASE); 4583 case BOND_SETHWADDR_OLD: 4584 return bond_do_ioctl(bond_dev, ifr, SIOCBONDSETHWADDR); 4585 case BOND_CHANGE_ACTIVE_OLD: 4586 return bond_do_ioctl(bond_dev, ifr, SIOCBONDCHANGEACTIVE); 4587 } 4588 4589 return -EOPNOTSUPP; 4590 } 4591 4592 static void bond_change_rx_flags(struct net_device *bond_dev, int change) 4593 { 4594 struct bonding *bond = netdev_priv(bond_dev); 4595 4596 if (change & IFF_PROMISC) 4597 bond_set_promiscuity(bond, 4598 bond_dev->flags & IFF_PROMISC ? 1 : -1); 4599 4600 if (change & IFF_ALLMULTI) 4601 bond_set_allmulti(bond, 4602 bond_dev->flags & IFF_ALLMULTI ? 1 : -1); 4603 } 4604 4605 static void bond_set_rx_mode(struct net_device *bond_dev) 4606 { 4607 struct bonding *bond = netdev_priv(bond_dev); 4608 struct list_head *iter; 4609 struct slave *slave; 4610 4611 rcu_read_lock(); 4612 if (bond_uses_primary(bond)) { 4613 slave = rcu_dereference(bond->curr_active_slave); 4614 if (slave) { 4615 dev_uc_sync(slave->dev, bond_dev); 4616 dev_mc_sync(slave->dev, bond_dev); 4617 } 4618 } else { 4619 bond_for_each_slave_rcu(bond, slave, iter) { 4620 dev_uc_sync_multiple(slave->dev, bond_dev); 4621 dev_mc_sync_multiple(slave->dev, bond_dev); 4622 } 4623 } 4624 rcu_read_unlock(); 4625 } 4626 4627 static int bond_neigh_init(struct neighbour *n) 4628 { 4629 struct bonding *bond = netdev_priv(n->dev); 4630 const struct net_device_ops *slave_ops; 4631 struct neigh_parms parms; 4632 struct slave *slave; 4633 int ret = 0; 4634 4635 rcu_read_lock(); 4636 slave = bond_first_slave_rcu(bond); 4637 if (!slave) 4638 goto out; 4639 slave_ops = slave->dev->netdev_ops; 4640 if (!slave_ops->ndo_neigh_setup) 4641 goto out; 4642 4643 /* TODO: find another way [1] to implement this. 4644 * Passing a zeroed structure is fragile, 4645 * but at least we do not pass garbage. 4646 * 4647 * [1] One way would be that ndo_neigh_setup() never touch 4648 * struct neigh_parms, but propagate the new neigh_setup() 4649 * back to ___neigh_create() / neigh_parms_alloc() 4650 */ 4651 memset(&parms, 0, sizeof(parms)); 4652 ret = slave_ops->ndo_neigh_setup(slave->dev, &parms); 4653 4654 if (ret) 4655 goto out; 4656 4657 if (parms.neigh_setup) 4658 ret = parms.neigh_setup(n); 4659 out: 4660 rcu_read_unlock(); 4661 return ret; 4662 } 4663 4664 /* The bonding ndo_neigh_setup is called at init time beofre any 4665 * slave exists. So we must declare proxy setup function which will 4666 * be used at run time to resolve the actual slave neigh param setup. 4667 * 4668 * It's also called by master devices (such as vlans) to setup their 4669 * underlying devices. In that case - do nothing, we're already set up from 4670 * our init. 4671 */ 4672 static int bond_neigh_setup(struct net_device *dev, 4673 struct neigh_parms *parms) 4674 { 4675 /* modify only our neigh_parms */ 4676 if (parms->dev == dev) 4677 parms->neigh_setup = bond_neigh_init; 4678 4679 return 0; 4680 } 4681 4682 /* Change the MTU of all of a master's slaves to match the master */ 4683 static int bond_change_mtu(struct net_device *bond_dev, int new_mtu) 4684 { 4685 struct bonding *bond = netdev_priv(bond_dev); 4686 struct slave *slave, *rollback_slave; 4687 struct list_head *iter; 4688 int res = 0; 4689 4690 netdev_dbg(bond_dev, "bond=%p, new_mtu=%d\n", bond, new_mtu); 4691 4692 bond_for_each_slave(bond, slave, iter) { 4693 slave_dbg(bond_dev, slave->dev, "s %p c_m %p\n", 4694 slave, slave->dev->netdev_ops->ndo_change_mtu); 4695 4696 res = dev_set_mtu(slave->dev, new_mtu); 4697 4698 if (res) { 4699 /* If we failed to set the slave's mtu to the new value 4700 * we must abort the operation even in ACTIVE_BACKUP 4701 * mode, because if we allow the backup slaves to have 4702 * different mtu values than the active slave we'll 4703 * need to change their mtu when doing a failover. That 4704 * means changing their mtu from timer context, which 4705 * is probably not a good idea. 4706 */ 4707 slave_dbg(bond_dev, slave->dev, "err %d setting mtu to %d\n", 4708 res, new_mtu); 4709 goto unwind; 4710 } 4711 } 4712 4713 bond_dev->mtu = new_mtu; 4714 4715 return 0; 4716 4717 unwind: 4718 /* unwind from head to the slave that failed */ 4719 bond_for_each_slave(bond, rollback_slave, iter) { 4720 int tmp_res; 4721 4722 if (rollback_slave == slave) 4723 break; 4724 4725 tmp_res = dev_set_mtu(rollback_slave->dev, bond_dev->mtu); 4726 if (tmp_res) 4727 slave_dbg(bond_dev, rollback_slave->dev, "unwind err %d\n", 4728 tmp_res); 4729 } 4730 4731 return res; 4732 } 4733 4734 /* Change HW address 4735 * 4736 * Note that many devices must be down to change the HW address, and 4737 * downing the master releases all slaves. We can make bonds full of 4738 * bonding devices to test this, however. 4739 */ 4740 static int bond_set_mac_address(struct net_device *bond_dev, void *addr) 4741 { 4742 struct bonding *bond = netdev_priv(bond_dev); 4743 struct slave *slave, *rollback_slave; 4744 struct sockaddr_storage *ss = addr, tmp_ss; 4745 struct list_head *iter; 4746 int res = 0; 4747 4748 if (BOND_MODE(bond) == BOND_MODE_ALB) 4749 return bond_alb_set_mac_address(bond_dev, addr); 4750 4751 4752 netdev_dbg(bond_dev, "%s: bond=%p\n", __func__, bond); 4753 4754 /* If fail_over_mac is enabled, do nothing and return success. 4755 * Returning an error causes ifenslave to fail. 4756 */ 4757 if (bond->params.fail_over_mac && 4758 BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) 4759 return 0; 4760 4761 if (!is_valid_ether_addr(ss->__data)) 4762 return -EADDRNOTAVAIL; 4763 4764 bond_for_each_slave(bond, slave, iter) { 4765 slave_dbg(bond_dev, slave->dev, "%s: slave=%p\n", 4766 __func__, slave); 4767 res = dev_set_mac_address(slave->dev, addr, NULL); 4768 if (res) { 4769 /* TODO: consider downing the slave 4770 * and retry ? 4771 * User should expect communications 4772 * breakage anyway until ARP finish 4773 * updating, so... 4774 */ 4775 slave_dbg(bond_dev, slave->dev, "%s: err %d\n", 4776 __func__, res); 4777 goto unwind; 4778 } 4779 } 4780 4781 /* success */ 4782 dev_addr_set(bond_dev, ss->__data); 4783 return 0; 4784 4785 unwind: 4786 memcpy(tmp_ss.__data, bond_dev->dev_addr, bond_dev->addr_len); 4787 tmp_ss.ss_family = bond_dev->type; 4788 4789 /* unwind from head to the slave that failed */ 4790 bond_for_each_slave(bond, rollback_slave, iter) { 4791 int tmp_res; 4792 4793 if (rollback_slave == slave) 4794 break; 4795 4796 tmp_res = dev_set_mac_address(rollback_slave->dev, 4797 (struct sockaddr *)&tmp_ss, NULL); 4798 if (tmp_res) { 4799 slave_dbg(bond_dev, rollback_slave->dev, "%s: unwind err %d\n", 4800 __func__, tmp_res); 4801 } 4802 } 4803 4804 return res; 4805 } 4806 4807 /** 4808 * bond_get_slave_by_id - get xmit slave with slave_id 4809 * @bond: bonding device that is transmitting 4810 * @slave_id: slave id up to slave_cnt-1 through which to transmit 4811 * 4812 * This function tries to get slave with slave_id but in case 4813 * it fails, it tries to find the first available slave for transmission. 4814 */ 4815 static struct slave *bond_get_slave_by_id(struct bonding *bond, 4816 int slave_id) 4817 { 4818 struct list_head *iter; 4819 struct slave *slave; 4820 int i = slave_id; 4821 4822 /* Here we start from the slave with slave_id */ 4823 bond_for_each_slave_rcu(bond, slave, iter) { 4824 if (--i < 0) { 4825 if (bond_slave_can_tx(slave)) 4826 return slave; 4827 } 4828 } 4829 4830 /* Here we start from the first slave up to slave_id */ 4831 i = slave_id; 4832 bond_for_each_slave_rcu(bond, slave, iter) { 4833 if (--i < 0) 4834 break; 4835 if (bond_slave_can_tx(slave)) 4836 return slave; 4837 } 4838 /* no slave that can tx has been found */ 4839 return NULL; 4840 } 4841 4842 /** 4843 * bond_rr_gen_slave_id - generate slave id based on packets_per_slave 4844 * @bond: bonding device to use 4845 * 4846 * Based on the value of the bonding device's packets_per_slave parameter 4847 * this function generates a slave id, which is usually used as the next 4848 * slave to transmit through. 4849 */ 4850 static u32 bond_rr_gen_slave_id(struct bonding *bond) 4851 { 4852 u32 slave_id; 4853 struct reciprocal_value reciprocal_packets_per_slave; 4854 int packets_per_slave = bond->params.packets_per_slave; 4855 4856 switch (packets_per_slave) { 4857 case 0: 4858 slave_id = get_random_u32(); 4859 break; 4860 case 1: 4861 slave_id = this_cpu_inc_return(*bond->rr_tx_counter); 4862 break; 4863 default: 4864 reciprocal_packets_per_slave = 4865 bond->params.reciprocal_packets_per_slave; 4866 slave_id = this_cpu_inc_return(*bond->rr_tx_counter); 4867 slave_id = reciprocal_divide(slave_id, 4868 reciprocal_packets_per_slave); 4869 break; 4870 } 4871 4872 return slave_id; 4873 } 4874 4875 static struct slave *bond_xmit_roundrobin_slave_get(struct bonding *bond, 4876 struct sk_buff *skb) 4877 { 4878 struct slave *slave; 4879 int slave_cnt; 4880 u32 slave_id; 4881 4882 /* Start with the curr_active_slave that joined the bond as the 4883 * default for sending IGMP traffic. For failover purposes one 4884 * needs to maintain some consistency for the interface that will 4885 * send the join/membership reports. The curr_active_slave found 4886 * will send all of this type of traffic. 4887 */ 4888 if (skb->protocol == htons(ETH_P_IP)) { 4889 int noff = skb_network_offset(skb); 4890 struct iphdr *iph; 4891 4892 if (unlikely(!pskb_may_pull(skb, noff + sizeof(*iph)))) 4893 goto non_igmp; 4894 4895 iph = ip_hdr(skb); 4896 if (iph->protocol == IPPROTO_IGMP) { 4897 slave = rcu_dereference(bond->curr_active_slave); 4898 if (slave) 4899 return slave; 4900 return bond_get_slave_by_id(bond, 0); 4901 } 4902 } 4903 4904 non_igmp: 4905 slave_cnt = READ_ONCE(bond->slave_cnt); 4906 if (likely(slave_cnt)) { 4907 slave_id = bond_rr_gen_slave_id(bond) % slave_cnt; 4908 return bond_get_slave_by_id(bond, slave_id); 4909 } 4910 return NULL; 4911 } 4912 4913 static struct slave *bond_xdp_xmit_roundrobin_slave_get(struct bonding *bond, 4914 struct xdp_buff *xdp) 4915 { 4916 struct slave *slave; 4917 int slave_cnt; 4918 u32 slave_id; 4919 const struct ethhdr *eth; 4920 void *data = xdp->data; 4921 4922 if (data + sizeof(struct ethhdr) > xdp->data_end) 4923 goto non_igmp; 4924 4925 eth = (struct ethhdr *)data; 4926 data += sizeof(struct ethhdr); 4927 4928 /* See comment on IGMP in bond_xmit_roundrobin_slave_get() */ 4929 if (eth->h_proto == htons(ETH_P_IP)) { 4930 const struct iphdr *iph; 4931 4932 if (data + sizeof(struct iphdr) > xdp->data_end) 4933 goto non_igmp; 4934 4935 iph = (struct iphdr *)data; 4936 4937 if (iph->protocol == IPPROTO_IGMP) { 4938 slave = rcu_dereference(bond->curr_active_slave); 4939 if (slave) 4940 return slave; 4941 return bond_get_slave_by_id(bond, 0); 4942 } 4943 } 4944 4945 non_igmp: 4946 slave_cnt = READ_ONCE(bond->slave_cnt); 4947 if (likely(slave_cnt)) { 4948 slave_id = bond_rr_gen_slave_id(bond) % slave_cnt; 4949 return bond_get_slave_by_id(bond, slave_id); 4950 } 4951 return NULL; 4952 } 4953 4954 static netdev_tx_t bond_xmit_roundrobin(struct sk_buff *skb, 4955 struct net_device *bond_dev) 4956 { 4957 struct bonding *bond = netdev_priv(bond_dev); 4958 struct slave *slave; 4959 4960 slave = bond_xmit_roundrobin_slave_get(bond, skb); 4961 if (likely(slave)) 4962 return bond_dev_queue_xmit(bond, skb, slave->dev); 4963 4964 return bond_tx_drop(bond_dev, skb); 4965 } 4966 4967 static struct slave *bond_xmit_activebackup_slave_get(struct bonding *bond) 4968 { 4969 return rcu_dereference(bond->curr_active_slave); 4970 } 4971 4972 /* In active-backup mode, we know that bond->curr_active_slave is always valid if 4973 * the bond has a usable interface. 4974 */ 4975 static netdev_tx_t bond_xmit_activebackup(struct sk_buff *skb, 4976 struct net_device *bond_dev) 4977 { 4978 struct bonding *bond = netdev_priv(bond_dev); 4979 struct slave *slave; 4980 4981 slave = bond_xmit_activebackup_slave_get(bond); 4982 if (slave) 4983 return bond_dev_queue_xmit(bond, skb, slave->dev); 4984 4985 return bond_tx_drop(bond_dev, skb); 4986 } 4987 4988 /* Use this to update slave_array when (a) it's not appropriate to update 4989 * slave_array right away (note that update_slave_array() may sleep) 4990 * and / or (b) RTNL is not held. 4991 */ 4992 void bond_slave_arr_work_rearm(struct bonding *bond, unsigned long delay) 4993 { 4994 queue_delayed_work(bond->wq, &bond->slave_arr_work, delay); 4995 } 4996 4997 /* Slave array work handler. Holds only RTNL */ 4998 static void bond_slave_arr_handler(struct work_struct *work) 4999 { 5000 struct bonding *bond = container_of(work, struct bonding, 5001 slave_arr_work.work); 5002 int ret; 5003 5004 if (!rtnl_trylock()) 5005 goto err; 5006 5007 ret = bond_update_slave_arr(bond, NULL); 5008 rtnl_unlock(); 5009 if (ret) { 5010 pr_warn_ratelimited("Failed to update slave array from WT\n"); 5011 goto err; 5012 } 5013 return; 5014 5015 err: 5016 bond_slave_arr_work_rearm(bond, 1); 5017 } 5018 5019 static void bond_skip_slave(struct bond_up_slave *slaves, 5020 struct slave *skipslave) 5021 { 5022 int idx; 5023 5024 /* Rare situation where caller has asked to skip a specific 5025 * slave but allocation failed (most likely!). BTW this is 5026 * only possible when the call is initiated from 5027 * __bond_release_one(). In this situation; overwrite the 5028 * skipslave entry in the array with the last entry from the 5029 * array to avoid a situation where the xmit path may choose 5030 * this to-be-skipped slave to send a packet out. 5031 */ 5032 for (idx = 0; slaves && idx < slaves->count; idx++) { 5033 if (skipslave == slaves->arr[idx]) { 5034 slaves->arr[idx] = 5035 slaves->arr[slaves->count - 1]; 5036 slaves->count--; 5037 break; 5038 } 5039 } 5040 } 5041 5042 static void bond_set_slave_arr(struct bonding *bond, 5043 struct bond_up_slave *usable_slaves, 5044 struct bond_up_slave *all_slaves) 5045 { 5046 struct bond_up_slave *usable, *all; 5047 5048 usable = rtnl_dereference(bond->usable_slaves); 5049 rcu_assign_pointer(bond->usable_slaves, usable_slaves); 5050 kfree_rcu(usable, rcu); 5051 5052 all = rtnl_dereference(bond->all_slaves); 5053 rcu_assign_pointer(bond->all_slaves, all_slaves); 5054 kfree_rcu(all, rcu); 5055 } 5056 5057 static void bond_reset_slave_arr(struct bonding *bond) 5058 { 5059 bond_set_slave_arr(bond, NULL, NULL); 5060 } 5061 5062 /* Build the usable slaves array in control path for modes that use xmit-hash 5063 * to determine the slave interface - 5064 * (a) BOND_MODE_8023AD 5065 * (b) BOND_MODE_XOR 5066 * (c) (BOND_MODE_TLB || BOND_MODE_ALB) && tlb_dynamic_lb == 0 5067 * 5068 * The caller is expected to hold RTNL only and NO other lock! 5069 */ 5070 int bond_update_slave_arr(struct bonding *bond, struct slave *skipslave) 5071 { 5072 struct bond_up_slave *usable_slaves = NULL, *all_slaves = NULL; 5073 struct slave *slave; 5074 struct list_head *iter; 5075 int agg_id = 0; 5076 int ret = 0; 5077 5078 might_sleep(); 5079 5080 usable_slaves = kzalloc(struct_size(usable_slaves, arr, 5081 bond->slave_cnt), GFP_KERNEL); 5082 all_slaves = kzalloc(struct_size(all_slaves, arr, 5083 bond->slave_cnt), GFP_KERNEL); 5084 if (!usable_slaves || !all_slaves) { 5085 ret = -ENOMEM; 5086 goto out; 5087 } 5088 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 5089 struct ad_info ad_info; 5090 5091 spin_lock_bh(&bond->mode_lock); 5092 if (bond_3ad_get_active_agg_info(bond, &ad_info)) { 5093 spin_unlock_bh(&bond->mode_lock); 5094 pr_debug("bond_3ad_get_active_agg_info failed\n"); 5095 /* No active aggragator means it's not safe to use 5096 * the previous array. 5097 */ 5098 bond_reset_slave_arr(bond); 5099 goto out; 5100 } 5101 spin_unlock_bh(&bond->mode_lock); 5102 agg_id = ad_info.aggregator_id; 5103 } 5104 bond_for_each_slave(bond, slave, iter) { 5105 if (skipslave == slave) 5106 continue; 5107 5108 all_slaves->arr[all_slaves->count++] = slave; 5109 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 5110 struct aggregator *agg; 5111 5112 agg = SLAVE_AD_INFO(slave)->port.aggregator; 5113 if (!agg || agg->aggregator_identifier != agg_id) 5114 continue; 5115 } 5116 if (!bond_slave_can_tx(slave)) 5117 continue; 5118 5119 slave_dbg(bond->dev, slave->dev, "Adding slave to tx hash array[%d]\n", 5120 usable_slaves->count); 5121 5122 usable_slaves->arr[usable_slaves->count++] = slave; 5123 } 5124 5125 bond_set_slave_arr(bond, usable_slaves, all_slaves); 5126 return ret; 5127 out: 5128 if (ret != 0 && skipslave) { 5129 bond_skip_slave(rtnl_dereference(bond->all_slaves), 5130 skipslave); 5131 bond_skip_slave(rtnl_dereference(bond->usable_slaves), 5132 skipslave); 5133 } 5134 kfree_rcu(all_slaves, rcu); 5135 kfree_rcu(usable_slaves, rcu); 5136 5137 return ret; 5138 } 5139 5140 static struct slave *bond_xmit_3ad_xor_slave_get(struct bonding *bond, 5141 struct sk_buff *skb, 5142 struct bond_up_slave *slaves) 5143 { 5144 struct slave *slave; 5145 unsigned int count; 5146 u32 hash; 5147 5148 hash = bond_xmit_hash(bond, skb); 5149 count = slaves ? READ_ONCE(slaves->count) : 0; 5150 if (unlikely(!count)) 5151 return NULL; 5152 5153 slave = slaves->arr[hash % count]; 5154 return slave; 5155 } 5156 5157 static struct slave *bond_xdp_xmit_3ad_xor_slave_get(struct bonding *bond, 5158 struct xdp_buff *xdp) 5159 { 5160 struct bond_up_slave *slaves; 5161 unsigned int count; 5162 u32 hash; 5163 5164 hash = bond_xmit_hash_xdp(bond, xdp); 5165 slaves = rcu_dereference(bond->usable_slaves); 5166 count = slaves ? READ_ONCE(slaves->count) : 0; 5167 if (unlikely(!count)) 5168 return NULL; 5169 5170 return slaves->arr[hash % count]; 5171 } 5172 5173 /* Use this Xmit function for 3AD as well as XOR modes. The current 5174 * usable slave array is formed in the control path. The xmit function 5175 * just calculates hash and sends the packet out. 5176 */ 5177 static netdev_tx_t bond_3ad_xor_xmit(struct sk_buff *skb, 5178 struct net_device *dev) 5179 { 5180 struct bonding *bond = netdev_priv(dev); 5181 struct bond_up_slave *slaves; 5182 struct slave *slave; 5183 5184 slaves = rcu_dereference(bond->usable_slaves); 5185 slave = bond_xmit_3ad_xor_slave_get(bond, skb, slaves); 5186 if (likely(slave)) 5187 return bond_dev_queue_xmit(bond, skb, slave->dev); 5188 5189 return bond_tx_drop(dev, skb); 5190 } 5191 5192 /* in broadcast mode, we send everything to all usable interfaces. */ 5193 static netdev_tx_t bond_xmit_broadcast(struct sk_buff *skb, 5194 struct net_device *bond_dev) 5195 { 5196 struct bonding *bond = netdev_priv(bond_dev); 5197 struct slave *slave = NULL; 5198 struct list_head *iter; 5199 bool xmit_suc = false; 5200 bool skb_used = false; 5201 5202 bond_for_each_slave_rcu(bond, slave, iter) { 5203 struct sk_buff *skb2; 5204 5205 if (!(bond_slave_is_up(slave) && slave->link == BOND_LINK_UP)) 5206 continue; 5207 5208 if (bond_is_last_slave(bond, slave)) { 5209 skb2 = skb; 5210 skb_used = true; 5211 } else { 5212 skb2 = skb_clone(skb, GFP_ATOMIC); 5213 if (!skb2) { 5214 net_err_ratelimited("%s: Error: %s: skb_clone() failed\n", 5215 bond_dev->name, __func__); 5216 continue; 5217 } 5218 } 5219 5220 if (bond_dev_queue_xmit(bond, skb2, slave->dev) == NETDEV_TX_OK) 5221 xmit_suc = true; 5222 } 5223 5224 if (!skb_used) 5225 dev_kfree_skb_any(skb); 5226 5227 if (xmit_suc) 5228 return NETDEV_TX_OK; 5229 5230 dev_core_stats_tx_dropped_inc(bond_dev); 5231 return NET_XMIT_DROP; 5232 } 5233 5234 /*------------------------- Device initialization ---------------------------*/ 5235 5236 /* Lookup the slave that corresponds to a qid */ 5237 static inline int bond_slave_override(struct bonding *bond, 5238 struct sk_buff *skb) 5239 { 5240 struct slave *slave = NULL; 5241 struct list_head *iter; 5242 5243 if (!skb_rx_queue_recorded(skb)) 5244 return 1; 5245 5246 /* Find out if any slaves have the same mapping as this skb. */ 5247 bond_for_each_slave_rcu(bond, slave, iter) { 5248 if (READ_ONCE(slave->queue_id) == skb_get_queue_mapping(skb)) { 5249 if (bond_slave_is_up(slave) && 5250 slave->link == BOND_LINK_UP) { 5251 bond_dev_queue_xmit(bond, skb, slave->dev); 5252 return 0; 5253 } 5254 /* If the slave isn't UP, use default transmit policy. */ 5255 break; 5256 } 5257 } 5258 5259 return 1; 5260 } 5261 5262 5263 static u16 bond_select_queue(struct net_device *dev, struct sk_buff *skb, 5264 struct net_device *sb_dev) 5265 { 5266 /* This helper function exists to help dev_pick_tx get the correct 5267 * destination queue. Using a helper function skips a call to 5268 * skb_tx_hash and will put the skbs in the queue we expect on their 5269 * way down to the bonding driver. 5270 */ 5271 u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0; 5272 5273 /* Save the original txq to restore before passing to the driver */ 5274 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb_get_queue_mapping(skb); 5275 5276 if (unlikely(txq >= dev->real_num_tx_queues)) { 5277 do { 5278 txq -= dev->real_num_tx_queues; 5279 } while (txq >= dev->real_num_tx_queues); 5280 } 5281 return txq; 5282 } 5283 5284 static struct net_device *bond_xmit_get_slave(struct net_device *master_dev, 5285 struct sk_buff *skb, 5286 bool all_slaves) 5287 { 5288 struct bonding *bond = netdev_priv(master_dev); 5289 struct bond_up_slave *slaves; 5290 struct slave *slave = NULL; 5291 5292 switch (BOND_MODE(bond)) { 5293 case BOND_MODE_ROUNDROBIN: 5294 slave = bond_xmit_roundrobin_slave_get(bond, skb); 5295 break; 5296 case BOND_MODE_ACTIVEBACKUP: 5297 slave = bond_xmit_activebackup_slave_get(bond); 5298 break; 5299 case BOND_MODE_8023AD: 5300 case BOND_MODE_XOR: 5301 if (all_slaves) 5302 slaves = rcu_dereference(bond->all_slaves); 5303 else 5304 slaves = rcu_dereference(bond->usable_slaves); 5305 slave = bond_xmit_3ad_xor_slave_get(bond, skb, slaves); 5306 break; 5307 case BOND_MODE_BROADCAST: 5308 break; 5309 case BOND_MODE_ALB: 5310 slave = bond_xmit_alb_slave_get(bond, skb); 5311 break; 5312 case BOND_MODE_TLB: 5313 slave = bond_xmit_tlb_slave_get(bond, skb); 5314 break; 5315 default: 5316 /* Should never happen, mode already checked */ 5317 WARN_ONCE(true, "Unknown bonding mode"); 5318 break; 5319 } 5320 5321 if (slave) 5322 return slave->dev; 5323 return NULL; 5324 } 5325 5326 static void bond_sk_to_flow(struct sock *sk, struct flow_keys *flow) 5327 { 5328 switch (sk->sk_family) { 5329 #if IS_ENABLED(CONFIG_IPV6) 5330 case AF_INET6: 5331 if (ipv6_only_sock(sk) || 5332 ipv6_addr_type(&sk->sk_v6_daddr) != IPV6_ADDR_MAPPED) { 5333 flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS; 5334 flow->addrs.v6addrs.src = inet6_sk(sk)->saddr; 5335 flow->addrs.v6addrs.dst = sk->sk_v6_daddr; 5336 break; 5337 } 5338 fallthrough; 5339 #endif 5340 default: /* AF_INET */ 5341 flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS; 5342 flow->addrs.v4addrs.src = inet_sk(sk)->inet_rcv_saddr; 5343 flow->addrs.v4addrs.dst = inet_sk(sk)->inet_daddr; 5344 break; 5345 } 5346 5347 flow->ports.src = inet_sk(sk)->inet_sport; 5348 flow->ports.dst = inet_sk(sk)->inet_dport; 5349 } 5350 5351 /** 5352 * bond_sk_hash_l34 - generate a hash value based on the socket's L3 and L4 fields 5353 * @sk: socket to use for headers 5354 * 5355 * This function will extract the necessary field from the socket and use 5356 * them to generate a hash based on the LAYER34 xmit_policy. 5357 * Assumes that sk is a TCP or UDP socket. 5358 */ 5359 static u32 bond_sk_hash_l34(struct sock *sk) 5360 { 5361 struct flow_keys flow; 5362 u32 hash; 5363 5364 bond_sk_to_flow(sk, &flow); 5365 5366 /* L4 */ 5367 memcpy(&hash, &flow.ports.ports, sizeof(hash)); 5368 /* L3 */ 5369 return bond_ip_hash(hash, &flow, BOND_XMIT_POLICY_LAYER34); 5370 } 5371 5372 static struct net_device *__bond_sk_get_lower_dev(struct bonding *bond, 5373 struct sock *sk) 5374 { 5375 struct bond_up_slave *slaves; 5376 struct slave *slave; 5377 unsigned int count; 5378 u32 hash; 5379 5380 slaves = rcu_dereference(bond->usable_slaves); 5381 count = slaves ? READ_ONCE(slaves->count) : 0; 5382 if (unlikely(!count)) 5383 return NULL; 5384 5385 hash = bond_sk_hash_l34(sk); 5386 slave = slaves->arr[hash % count]; 5387 5388 return slave->dev; 5389 } 5390 5391 static struct net_device *bond_sk_get_lower_dev(struct net_device *dev, 5392 struct sock *sk) 5393 { 5394 struct bonding *bond = netdev_priv(dev); 5395 struct net_device *lower = NULL; 5396 5397 rcu_read_lock(); 5398 if (bond_sk_check(bond)) 5399 lower = __bond_sk_get_lower_dev(bond, sk); 5400 rcu_read_unlock(); 5401 5402 return lower; 5403 } 5404 5405 #if IS_ENABLED(CONFIG_TLS_DEVICE) 5406 static netdev_tx_t bond_tls_device_xmit(struct bonding *bond, struct sk_buff *skb, 5407 struct net_device *dev) 5408 { 5409 struct net_device *tls_netdev = rcu_dereference(tls_get_ctx(skb->sk)->netdev); 5410 5411 /* tls_netdev might become NULL, even if tls_is_skb_tx_device_offloaded 5412 * was true, if tls_device_down is running in parallel, but it's OK, 5413 * because bond_get_slave_by_dev has a NULL check. 5414 */ 5415 if (likely(bond_get_slave_by_dev(bond, tls_netdev))) 5416 return bond_dev_queue_xmit(bond, skb, tls_netdev); 5417 return bond_tx_drop(dev, skb); 5418 } 5419 #endif 5420 5421 static netdev_tx_t __bond_start_xmit(struct sk_buff *skb, struct net_device *dev) 5422 { 5423 struct bonding *bond = netdev_priv(dev); 5424 5425 if (bond_should_override_tx_queue(bond) && 5426 !bond_slave_override(bond, skb)) 5427 return NETDEV_TX_OK; 5428 5429 #if IS_ENABLED(CONFIG_TLS_DEVICE) 5430 if (tls_is_skb_tx_device_offloaded(skb)) 5431 return bond_tls_device_xmit(bond, skb, dev); 5432 #endif 5433 5434 switch (BOND_MODE(bond)) { 5435 case BOND_MODE_ROUNDROBIN: 5436 return bond_xmit_roundrobin(skb, dev); 5437 case BOND_MODE_ACTIVEBACKUP: 5438 return bond_xmit_activebackup(skb, dev); 5439 case BOND_MODE_8023AD: 5440 case BOND_MODE_XOR: 5441 return bond_3ad_xor_xmit(skb, dev); 5442 case BOND_MODE_BROADCAST: 5443 return bond_xmit_broadcast(skb, dev); 5444 case BOND_MODE_ALB: 5445 return bond_alb_xmit(skb, dev); 5446 case BOND_MODE_TLB: 5447 return bond_tlb_xmit(skb, dev); 5448 default: 5449 /* Should never happen, mode already checked */ 5450 netdev_err(dev, "Unknown bonding mode %d\n", BOND_MODE(bond)); 5451 WARN_ON_ONCE(1); 5452 return bond_tx_drop(dev, skb); 5453 } 5454 } 5455 5456 static netdev_tx_t bond_start_xmit(struct sk_buff *skb, struct net_device *dev) 5457 { 5458 struct bonding *bond = netdev_priv(dev); 5459 netdev_tx_t ret = NETDEV_TX_OK; 5460 5461 /* If we risk deadlock from transmitting this in the 5462 * netpoll path, tell netpoll to queue the frame for later tx 5463 */ 5464 if (unlikely(is_netpoll_tx_blocked(dev))) 5465 return NETDEV_TX_BUSY; 5466 5467 rcu_read_lock(); 5468 if (bond_has_slaves(bond)) 5469 ret = __bond_start_xmit(skb, dev); 5470 else 5471 ret = bond_tx_drop(dev, skb); 5472 rcu_read_unlock(); 5473 5474 return ret; 5475 } 5476 5477 static struct net_device * 5478 bond_xdp_get_xmit_slave(struct net_device *bond_dev, struct xdp_buff *xdp) 5479 { 5480 struct bonding *bond = netdev_priv(bond_dev); 5481 struct slave *slave; 5482 5483 /* Caller needs to hold rcu_read_lock() */ 5484 5485 switch (BOND_MODE(bond)) { 5486 case BOND_MODE_ROUNDROBIN: 5487 slave = bond_xdp_xmit_roundrobin_slave_get(bond, xdp); 5488 break; 5489 5490 case BOND_MODE_ACTIVEBACKUP: 5491 slave = bond_xmit_activebackup_slave_get(bond); 5492 break; 5493 5494 case BOND_MODE_8023AD: 5495 case BOND_MODE_XOR: 5496 slave = bond_xdp_xmit_3ad_xor_slave_get(bond, xdp); 5497 break; 5498 5499 default: 5500 /* Should never happen. Mode guarded by bond_xdp_check() */ 5501 netdev_err(bond_dev, "Unknown bonding mode %d for xdp xmit\n", BOND_MODE(bond)); 5502 WARN_ON_ONCE(1); 5503 return NULL; 5504 } 5505 5506 if (slave) 5507 return slave->dev; 5508 5509 return NULL; 5510 } 5511 5512 static int bond_xdp_xmit(struct net_device *bond_dev, 5513 int n, struct xdp_frame **frames, u32 flags) 5514 { 5515 int nxmit, err = -ENXIO; 5516 5517 rcu_read_lock(); 5518 5519 for (nxmit = 0; nxmit < n; nxmit++) { 5520 struct xdp_frame *frame = frames[nxmit]; 5521 struct xdp_frame *frames1[] = {frame}; 5522 struct net_device *slave_dev; 5523 struct xdp_buff xdp; 5524 5525 xdp_convert_frame_to_buff(frame, &xdp); 5526 5527 slave_dev = bond_xdp_get_xmit_slave(bond_dev, &xdp); 5528 if (!slave_dev) { 5529 err = -ENXIO; 5530 break; 5531 } 5532 5533 err = slave_dev->netdev_ops->ndo_xdp_xmit(slave_dev, 1, frames1, flags); 5534 if (err < 1) 5535 break; 5536 } 5537 5538 rcu_read_unlock(); 5539 5540 /* If error happened on the first frame then we can pass the error up, otherwise 5541 * report the number of frames that were xmitted. 5542 */ 5543 if (err < 0) 5544 return (nxmit == 0 ? err : nxmit); 5545 5546 return nxmit; 5547 } 5548 5549 static int bond_xdp_set(struct net_device *dev, struct bpf_prog *prog, 5550 struct netlink_ext_ack *extack) 5551 { 5552 struct bonding *bond = netdev_priv(dev); 5553 struct list_head *iter; 5554 struct slave *slave, *rollback_slave; 5555 struct bpf_prog *old_prog; 5556 struct netdev_bpf xdp = { 5557 .command = XDP_SETUP_PROG, 5558 .flags = 0, 5559 .prog = prog, 5560 .extack = extack, 5561 }; 5562 int err; 5563 5564 ASSERT_RTNL(); 5565 5566 if (!bond_xdp_check(bond)) 5567 return -EOPNOTSUPP; 5568 5569 old_prog = bond->xdp_prog; 5570 bond->xdp_prog = prog; 5571 5572 bond_for_each_slave(bond, slave, iter) { 5573 struct net_device *slave_dev = slave->dev; 5574 5575 if (!slave_dev->netdev_ops->ndo_bpf || 5576 !slave_dev->netdev_ops->ndo_xdp_xmit) { 5577 SLAVE_NL_ERR(dev, slave_dev, extack, 5578 "Slave device does not support XDP"); 5579 err = -EOPNOTSUPP; 5580 goto err; 5581 } 5582 5583 if (dev_xdp_prog_count(slave_dev) > 0) { 5584 SLAVE_NL_ERR(dev, slave_dev, extack, 5585 "Slave has XDP program loaded, please unload before enslaving"); 5586 err = -EOPNOTSUPP; 5587 goto err; 5588 } 5589 5590 err = slave_dev->netdev_ops->ndo_bpf(slave_dev, &xdp); 5591 if (err < 0) { 5592 /* ndo_bpf() sets extack error message */ 5593 slave_err(dev, slave_dev, "Error %d calling ndo_bpf\n", err); 5594 goto err; 5595 } 5596 if (prog) 5597 bpf_prog_inc(prog); 5598 } 5599 5600 if (prog) { 5601 static_branch_inc(&bpf_master_redirect_enabled_key); 5602 } else if (old_prog) { 5603 bpf_prog_put(old_prog); 5604 static_branch_dec(&bpf_master_redirect_enabled_key); 5605 } 5606 5607 return 0; 5608 5609 err: 5610 /* unwind the program changes */ 5611 bond->xdp_prog = old_prog; 5612 xdp.prog = old_prog; 5613 xdp.extack = NULL; /* do not overwrite original error */ 5614 5615 bond_for_each_slave(bond, rollback_slave, iter) { 5616 struct net_device *slave_dev = rollback_slave->dev; 5617 int err_unwind; 5618 5619 if (slave == rollback_slave) 5620 break; 5621 5622 err_unwind = slave_dev->netdev_ops->ndo_bpf(slave_dev, &xdp); 5623 if (err_unwind < 0) 5624 slave_err(dev, slave_dev, 5625 "Error %d when unwinding XDP program change\n", err_unwind); 5626 else if (xdp.prog) 5627 bpf_prog_inc(xdp.prog); 5628 } 5629 return err; 5630 } 5631 5632 static int bond_xdp(struct net_device *dev, struct netdev_bpf *xdp) 5633 { 5634 switch (xdp->command) { 5635 case XDP_SETUP_PROG: 5636 return bond_xdp_set(dev, xdp->prog, xdp->extack); 5637 default: 5638 return -EINVAL; 5639 } 5640 } 5641 5642 static u32 bond_mode_bcast_speed(struct slave *slave, u32 speed) 5643 { 5644 if (speed == 0 || speed == SPEED_UNKNOWN) 5645 speed = slave->speed; 5646 else 5647 speed = min(speed, slave->speed); 5648 5649 return speed; 5650 } 5651 5652 /* Set the BOND_PHC_INDEX flag to notify user space */ 5653 static int bond_set_phc_index_flag(struct kernel_hwtstamp_config *kernel_cfg) 5654 { 5655 struct ifreq *ifr = kernel_cfg->ifr; 5656 struct hwtstamp_config cfg; 5657 5658 if (kernel_cfg->copied_to_user) { 5659 /* Lower device has a legacy implementation */ 5660 if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg))) 5661 return -EFAULT; 5662 5663 cfg.flags |= HWTSTAMP_FLAG_BONDED_PHC_INDEX; 5664 if (copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg))) 5665 return -EFAULT; 5666 } else { 5667 kernel_cfg->flags |= HWTSTAMP_FLAG_BONDED_PHC_INDEX; 5668 } 5669 5670 return 0; 5671 } 5672 5673 static int bond_hwtstamp_get(struct net_device *dev, 5674 struct kernel_hwtstamp_config *cfg) 5675 { 5676 struct bonding *bond = netdev_priv(dev); 5677 struct net_device *real_dev; 5678 int err; 5679 5680 real_dev = bond_option_active_slave_get_rcu(bond); 5681 if (!real_dev) 5682 return -EOPNOTSUPP; 5683 5684 err = generic_hwtstamp_get_lower(real_dev, cfg); 5685 if (err) 5686 return err; 5687 5688 return bond_set_phc_index_flag(cfg); 5689 } 5690 5691 static int bond_hwtstamp_set(struct net_device *dev, 5692 struct kernel_hwtstamp_config *cfg, 5693 struct netlink_ext_ack *extack) 5694 { 5695 struct bonding *bond = netdev_priv(dev); 5696 struct net_device *real_dev; 5697 int err; 5698 5699 if (!(cfg->flags & HWTSTAMP_FLAG_BONDED_PHC_INDEX)) 5700 return -EOPNOTSUPP; 5701 5702 real_dev = bond_option_active_slave_get_rcu(bond); 5703 if (!real_dev) 5704 return -EOPNOTSUPP; 5705 5706 err = generic_hwtstamp_set_lower(real_dev, cfg, extack); 5707 if (err) 5708 return err; 5709 5710 return bond_set_phc_index_flag(cfg); 5711 } 5712 5713 static int bond_ethtool_get_link_ksettings(struct net_device *bond_dev, 5714 struct ethtool_link_ksettings *cmd) 5715 { 5716 struct bonding *bond = netdev_priv(bond_dev); 5717 struct list_head *iter; 5718 struct slave *slave; 5719 u32 speed = 0; 5720 5721 cmd->base.duplex = DUPLEX_UNKNOWN; 5722 cmd->base.port = PORT_OTHER; 5723 5724 /* Since bond_slave_can_tx returns false for all inactive or down slaves, we 5725 * do not need to check mode. Though link speed might not represent 5726 * the true receive or transmit bandwidth (not all modes are symmetric) 5727 * this is an accurate maximum. 5728 */ 5729 bond_for_each_slave(bond, slave, iter) { 5730 if (bond_slave_can_tx(slave)) { 5731 bond_update_speed_duplex(slave); 5732 if (slave->speed != SPEED_UNKNOWN) { 5733 if (BOND_MODE(bond) == BOND_MODE_BROADCAST) 5734 speed = bond_mode_bcast_speed(slave, 5735 speed); 5736 else 5737 speed += slave->speed; 5738 } 5739 if (cmd->base.duplex == DUPLEX_UNKNOWN && 5740 slave->duplex != DUPLEX_UNKNOWN) 5741 cmd->base.duplex = slave->duplex; 5742 } 5743 } 5744 cmd->base.speed = speed ? : SPEED_UNKNOWN; 5745 5746 return 0; 5747 } 5748 5749 static void bond_ethtool_get_drvinfo(struct net_device *bond_dev, 5750 struct ethtool_drvinfo *drvinfo) 5751 { 5752 strscpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver)); 5753 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%d", 5754 BOND_ABI_VERSION); 5755 } 5756 5757 static int bond_ethtool_get_ts_info(struct net_device *bond_dev, 5758 struct ethtool_ts_info *info) 5759 { 5760 struct bonding *bond = netdev_priv(bond_dev); 5761 struct ethtool_ts_info ts_info; 5762 struct net_device *real_dev; 5763 bool sw_tx_support = false; 5764 struct list_head *iter; 5765 struct slave *slave; 5766 int ret = 0; 5767 5768 rcu_read_lock(); 5769 real_dev = bond_option_active_slave_get_rcu(bond); 5770 dev_hold(real_dev); 5771 rcu_read_unlock(); 5772 5773 if (real_dev) { 5774 ret = ethtool_get_ts_info_by_layer(real_dev, info); 5775 } else { 5776 /* Check if all slaves support software tx timestamping */ 5777 rcu_read_lock(); 5778 bond_for_each_slave_rcu(bond, slave, iter) { 5779 ret = ethtool_get_ts_info_by_layer(slave->dev, &ts_info); 5780 if (!ret && (ts_info.so_timestamping & SOF_TIMESTAMPING_TX_SOFTWARE)) { 5781 sw_tx_support = true; 5782 continue; 5783 } 5784 5785 sw_tx_support = false; 5786 break; 5787 } 5788 rcu_read_unlock(); 5789 } 5790 5791 if (sw_tx_support) 5792 info->so_timestamping |= SOF_TIMESTAMPING_TX_SOFTWARE; 5793 5794 dev_put(real_dev); 5795 return ret; 5796 } 5797 5798 static const struct ethtool_ops bond_ethtool_ops = { 5799 .get_drvinfo = bond_ethtool_get_drvinfo, 5800 .get_link = ethtool_op_get_link, 5801 .get_link_ksettings = bond_ethtool_get_link_ksettings, 5802 .get_ts_info = bond_ethtool_get_ts_info, 5803 }; 5804 5805 static const struct net_device_ops bond_netdev_ops = { 5806 .ndo_init = bond_init, 5807 .ndo_uninit = bond_uninit, 5808 .ndo_open = bond_open, 5809 .ndo_stop = bond_close, 5810 .ndo_start_xmit = bond_start_xmit, 5811 .ndo_select_queue = bond_select_queue, 5812 .ndo_get_stats64 = bond_get_stats, 5813 .ndo_eth_ioctl = bond_eth_ioctl, 5814 .ndo_siocbond = bond_do_ioctl, 5815 .ndo_siocdevprivate = bond_siocdevprivate, 5816 .ndo_change_rx_flags = bond_change_rx_flags, 5817 .ndo_set_rx_mode = bond_set_rx_mode, 5818 .ndo_change_mtu = bond_change_mtu, 5819 .ndo_set_mac_address = bond_set_mac_address, 5820 .ndo_neigh_setup = bond_neigh_setup, 5821 .ndo_vlan_rx_add_vid = bond_vlan_rx_add_vid, 5822 .ndo_vlan_rx_kill_vid = bond_vlan_rx_kill_vid, 5823 #ifdef CONFIG_NET_POLL_CONTROLLER 5824 .ndo_netpoll_setup = bond_netpoll_setup, 5825 .ndo_netpoll_cleanup = bond_netpoll_cleanup, 5826 .ndo_poll_controller = bond_poll_controller, 5827 #endif 5828 .ndo_add_slave = bond_enslave, 5829 .ndo_del_slave = bond_release, 5830 .ndo_fix_features = bond_fix_features, 5831 .ndo_features_check = passthru_features_check, 5832 .ndo_get_xmit_slave = bond_xmit_get_slave, 5833 .ndo_sk_get_lower_dev = bond_sk_get_lower_dev, 5834 .ndo_bpf = bond_xdp, 5835 .ndo_xdp_xmit = bond_xdp_xmit, 5836 .ndo_xdp_get_xmit_slave = bond_xdp_get_xmit_slave, 5837 .ndo_hwtstamp_get = bond_hwtstamp_get, 5838 .ndo_hwtstamp_set = bond_hwtstamp_set, 5839 }; 5840 5841 static const struct device_type bond_type = { 5842 .name = "bond", 5843 }; 5844 5845 static void bond_destructor(struct net_device *bond_dev) 5846 { 5847 struct bonding *bond = netdev_priv(bond_dev); 5848 5849 if (bond->wq) 5850 destroy_workqueue(bond->wq); 5851 5852 free_percpu(bond->rr_tx_counter); 5853 } 5854 5855 void bond_setup(struct net_device *bond_dev) 5856 { 5857 struct bonding *bond = netdev_priv(bond_dev); 5858 5859 spin_lock_init(&bond->mode_lock); 5860 bond->params = bonding_defaults; 5861 5862 /* Initialize pointers */ 5863 bond->dev = bond_dev; 5864 5865 /* Initialize the device entry points */ 5866 ether_setup(bond_dev); 5867 bond_dev->max_mtu = ETH_MAX_MTU; 5868 bond_dev->netdev_ops = &bond_netdev_ops; 5869 bond_dev->ethtool_ops = &bond_ethtool_ops; 5870 5871 bond_dev->needs_free_netdev = true; 5872 bond_dev->priv_destructor = bond_destructor; 5873 5874 SET_NETDEV_DEVTYPE(bond_dev, &bond_type); 5875 5876 /* Initialize the device options */ 5877 bond_dev->flags |= IFF_MASTER; 5878 bond_dev->priv_flags |= IFF_BONDING | IFF_UNICAST_FLT | IFF_NO_QUEUE; 5879 bond_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING); 5880 5881 #ifdef CONFIG_XFRM_OFFLOAD 5882 /* set up xfrm device ops (only supported in active-backup right now) */ 5883 bond_dev->xfrmdev_ops = &bond_xfrmdev_ops; 5884 INIT_LIST_HEAD(&bond->ipsec_list); 5885 spin_lock_init(&bond->ipsec_lock); 5886 #endif /* CONFIG_XFRM_OFFLOAD */ 5887 5888 /* don't acquire bond device's netif_tx_lock when transmitting */ 5889 bond_dev->features |= NETIF_F_LLTX; 5890 5891 /* By default, we declare the bond to be fully 5892 * VLAN hardware accelerated capable. Special 5893 * care is taken in the various xmit functions 5894 * when there are slaves that are not hw accel 5895 * capable 5896 */ 5897 5898 /* Don't allow bond devices to change network namespaces. */ 5899 bond_dev->features |= NETIF_F_NETNS_LOCAL; 5900 5901 bond_dev->hw_features = BOND_VLAN_FEATURES | 5902 NETIF_F_HW_VLAN_CTAG_RX | 5903 NETIF_F_HW_VLAN_CTAG_FILTER | 5904 NETIF_F_HW_VLAN_STAG_RX | 5905 NETIF_F_HW_VLAN_STAG_FILTER; 5906 5907 bond_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL; 5908 bond_dev->features |= bond_dev->hw_features; 5909 bond_dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX; 5910 #ifdef CONFIG_XFRM_OFFLOAD 5911 bond_dev->hw_features |= BOND_XFRM_FEATURES; 5912 /* Only enable XFRM features if this is an active-backup config */ 5913 if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) 5914 bond_dev->features |= BOND_XFRM_FEATURES; 5915 #endif /* CONFIG_XFRM_OFFLOAD */ 5916 } 5917 5918 /* Destroy a bonding device. 5919 * Must be under rtnl_lock when this function is called. 5920 */ 5921 static void bond_uninit(struct net_device *bond_dev) 5922 { 5923 struct bonding *bond = netdev_priv(bond_dev); 5924 struct list_head *iter; 5925 struct slave *slave; 5926 5927 bond_netpoll_cleanup(bond_dev); 5928 5929 /* Release the bonded slaves */ 5930 bond_for_each_slave(bond, slave, iter) 5931 __bond_release_one(bond_dev, slave->dev, true, true); 5932 netdev_info(bond_dev, "Released all slaves\n"); 5933 5934 bond_set_slave_arr(bond, NULL, NULL); 5935 5936 list_del_rcu(&bond->bond_list); 5937 5938 bond_debug_unregister(bond); 5939 } 5940 5941 /*------------------------- Module initialization ---------------------------*/ 5942 5943 static int __init bond_check_params(struct bond_params *params) 5944 { 5945 int arp_validate_value, fail_over_mac_value, primary_reselect_value, i; 5946 struct bond_opt_value newval; 5947 const struct bond_opt_value *valptr; 5948 int arp_all_targets_value = 0; 5949 u16 ad_actor_sys_prio = 0; 5950 u16 ad_user_port_key = 0; 5951 __be32 arp_target[BOND_MAX_ARP_TARGETS] = { 0 }; 5952 int arp_ip_count; 5953 int bond_mode = BOND_MODE_ROUNDROBIN; 5954 int xmit_hashtype = BOND_XMIT_POLICY_LAYER2; 5955 int lacp_fast = 0; 5956 int tlb_dynamic_lb; 5957 5958 /* Convert string parameters. */ 5959 if (mode) { 5960 bond_opt_initstr(&newval, mode); 5961 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_MODE), &newval); 5962 if (!valptr) { 5963 pr_err("Error: Invalid bonding mode \"%s\"\n", mode); 5964 return -EINVAL; 5965 } 5966 bond_mode = valptr->value; 5967 } 5968 5969 if (xmit_hash_policy) { 5970 if (bond_mode == BOND_MODE_ROUNDROBIN || 5971 bond_mode == BOND_MODE_ACTIVEBACKUP || 5972 bond_mode == BOND_MODE_BROADCAST) { 5973 pr_info("xmit_hash_policy param is irrelevant in mode %s\n", 5974 bond_mode_name(bond_mode)); 5975 } else { 5976 bond_opt_initstr(&newval, xmit_hash_policy); 5977 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_XMIT_HASH), 5978 &newval); 5979 if (!valptr) { 5980 pr_err("Error: Invalid xmit_hash_policy \"%s\"\n", 5981 xmit_hash_policy); 5982 return -EINVAL; 5983 } 5984 xmit_hashtype = valptr->value; 5985 } 5986 } 5987 5988 if (lacp_rate) { 5989 if (bond_mode != BOND_MODE_8023AD) { 5990 pr_info("lacp_rate param is irrelevant in mode %s\n", 5991 bond_mode_name(bond_mode)); 5992 } else { 5993 bond_opt_initstr(&newval, lacp_rate); 5994 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_LACP_RATE), 5995 &newval); 5996 if (!valptr) { 5997 pr_err("Error: Invalid lacp rate \"%s\"\n", 5998 lacp_rate); 5999 return -EINVAL; 6000 } 6001 lacp_fast = valptr->value; 6002 } 6003 } 6004 6005 if (ad_select) { 6006 bond_opt_initstr(&newval, ad_select); 6007 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_AD_SELECT), 6008 &newval); 6009 if (!valptr) { 6010 pr_err("Error: Invalid ad_select \"%s\"\n", ad_select); 6011 return -EINVAL; 6012 } 6013 params->ad_select = valptr->value; 6014 if (bond_mode != BOND_MODE_8023AD) 6015 pr_warn("ad_select param only affects 802.3ad mode\n"); 6016 } else { 6017 params->ad_select = BOND_AD_STABLE; 6018 } 6019 6020 if (max_bonds < 0) { 6021 pr_warn("Warning: max_bonds (%d) not in range %d-%d, so it was reset to BOND_DEFAULT_MAX_BONDS (%d)\n", 6022 max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS); 6023 max_bonds = BOND_DEFAULT_MAX_BONDS; 6024 } 6025 6026 if (miimon < 0) { 6027 pr_warn("Warning: miimon module parameter (%d), not in range 0-%d, so it was reset to 0\n", 6028 miimon, INT_MAX); 6029 miimon = 0; 6030 } 6031 6032 if (updelay < 0) { 6033 pr_warn("Warning: updelay module parameter (%d), not in range 0-%d, so it was reset to 0\n", 6034 updelay, INT_MAX); 6035 updelay = 0; 6036 } 6037 6038 if (downdelay < 0) { 6039 pr_warn("Warning: downdelay module parameter (%d), not in range 0-%d, so it was reset to 0\n", 6040 downdelay, INT_MAX); 6041 downdelay = 0; 6042 } 6043 6044 if ((use_carrier != 0) && (use_carrier != 1)) { 6045 pr_warn("Warning: use_carrier module parameter (%d), not of valid value (0/1), so it was set to 1\n", 6046 use_carrier); 6047 use_carrier = 1; 6048 } 6049 6050 if (num_peer_notif < 0 || num_peer_notif > 255) { 6051 pr_warn("Warning: num_grat_arp/num_unsol_na (%d) not in range 0-255 so it was reset to 1\n", 6052 num_peer_notif); 6053 num_peer_notif = 1; 6054 } 6055 6056 /* reset values for 802.3ad/TLB/ALB */ 6057 if (!bond_mode_uses_arp(bond_mode)) { 6058 if (!miimon) { 6059 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"); 6060 pr_warn("Forcing miimon to 100msec\n"); 6061 miimon = BOND_DEFAULT_MIIMON; 6062 } 6063 } 6064 6065 if (tx_queues < 1 || tx_queues > 255) { 6066 pr_warn("Warning: tx_queues (%d) should be between 1 and 255, resetting to %d\n", 6067 tx_queues, BOND_DEFAULT_TX_QUEUES); 6068 tx_queues = BOND_DEFAULT_TX_QUEUES; 6069 } 6070 6071 if ((all_slaves_active != 0) && (all_slaves_active != 1)) { 6072 pr_warn("Warning: all_slaves_active module parameter (%d), not of valid value (0/1), so it was set to 0\n", 6073 all_slaves_active); 6074 all_slaves_active = 0; 6075 } 6076 6077 if (resend_igmp < 0 || resend_igmp > 255) { 6078 pr_warn("Warning: resend_igmp (%d) should be between 0 and 255, resetting to %d\n", 6079 resend_igmp, BOND_DEFAULT_RESEND_IGMP); 6080 resend_igmp = BOND_DEFAULT_RESEND_IGMP; 6081 } 6082 6083 bond_opt_initval(&newval, packets_per_slave); 6084 if (!bond_opt_parse(bond_opt_get(BOND_OPT_PACKETS_PER_SLAVE), &newval)) { 6085 pr_warn("Warning: packets_per_slave (%d) should be between 0 and %u resetting to 1\n", 6086 packets_per_slave, USHRT_MAX); 6087 packets_per_slave = 1; 6088 } 6089 6090 if (bond_mode == BOND_MODE_ALB) { 6091 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", 6092 updelay); 6093 } 6094 6095 if (!miimon) { 6096 if (updelay || downdelay) { 6097 /* just warn the user the up/down delay will have 6098 * no effect since miimon is zero... 6099 */ 6100 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", 6101 updelay, downdelay); 6102 } 6103 } else { 6104 /* don't allow arp monitoring */ 6105 if (arp_interval) { 6106 pr_warn("Warning: miimon (%d) and arp_interval (%d) can't be used simultaneously, disabling ARP monitoring\n", 6107 miimon, arp_interval); 6108 arp_interval = 0; 6109 } 6110 6111 if ((updelay % miimon) != 0) { 6112 pr_warn("Warning: updelay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n", 6113 updelay, miimon, (updelay / miimon) * miimon); 6114 } 6115 6116 updelay /= miimon; 6117 6118 if ((downdelay % miimon) != 0) { 6119 pr_warn("Warning: downdelay (%d) is not a multiple of miimon (%d), downdelay rounded to %d ms\n", 6120 downdelay, miimon, 6121 (downdelay / miimon) * miimon); 6122 } 6123 6124 downdelay /= miimon; 6125 } 6126 6127 if (arp_interval < 0) { 6128 pr_warn("Warning: arp_interval module parameter (%d), not in range 0-%d, so it was reset to 0\n", 6129 arp_interval, INT_MAX); 6130 arp_interval = 0; 6131 } 6132 6133 for (arp_ip_count = 0, i = 0; 6134 (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[i]; i++) { 6135 __be32 ip; 6136 6137 /* not a complete check, but good enough to catch mistakes */ 6138 if (!in4_pton(arp_ip_target[i], -1, (u8 *)&ip, -1, NULL) || 6139 !bond_is_ip_target_ok(ip)) { 6140 pr_warn("Warning: bad arp_ip_target module parameter (%s), ARP monitoring will not be performed\n", 6141 arp_ip_target[i]); 6142 arp_interval = 0; 6143 } else { 6144 if (bond_get_targets_ip(arp_target, ip) == -1) 6145 arp_target[arp_ip_count++] = ip; 6146 else 6147 pr_warn("Warning: duplicate address %pI4 in arp_ip_target, skipping\n", 6148 &ip); 6149 } 6150 } 6151 6152 if (arp_interval && !arp_ip_count) { 6153 /* don't allow arping if no arp_ip_target given... */ 6154 pr_warn("Warning: arp_interval module parameter (%d) specified without providing an arp_ip_target parameter, arp_interval was reset to 0\n", 6155 arp_interval); 6156 arp_interval = 0; 6157 } 6158 6159 if (arp_validate) { 6160 if (!arp_interval) { 6161 pr_err("arp_validate requires arp_interval\n"); 6162 return -EINVAL; 6163 } 6164 6165 bond_opt_initstr(&newval, arp_validate); 6166 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_ARP_VALIDATE), 6167 &newval); 6168 if (!valptr) { 6169 pr_err("Error: invalid arp_validate \"%s\"\n", 6170 arp_validate); 6171 return -EINVAL; 6172 } 6173 arp_validate_value = valptr->value; 6174 } else { 6175 arp_validate_value = 0; 6176 } 6177 6178 if (arp_all_targets) { 6179 bond_opt_initstr(&newval, arp_all_targets); 6180 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_ARP_ALL_TARGETS), 6181 &newval); 6182 if (!valptr) { 6183 pr_err("Error: invalid arp_all_targets_value \"%s\"\n", 6184 arp_all_targets); 6185 arp_all_targets_value = 0; 6186 } else { 6187 arp_all_targets_value = valptr->value; 6188 } 6189 } 6190 6191 if (miimon) { 6192 pr_info("MII link monitoring set to %d ms\n", miimon); 6193 } else if (arp_interval) { 6194 valptr = bond_opt_get_val(BOND_OPT_ARP_VALIDATE, 6195 arp_validate_value); 6196 pr_info("ARP monitoring set to %d ms, validate %s, with %d target(s):", 6197 arp_interval, valptr->string, arp_ip_count); 6198 6199 for (i = 0; i < arp_ip_count; i++) 6200 pr_cont(" %s", arp_ip_target[i]); 6201 6202 pr_cont("\n"); 6203 6204 } else if (max_bonds) { 6205 /* miimon and arp_interval not set, we need one so things 6206 * work as expected, see bonding.txt for details 6207 */ 6208 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"); 6209 } 6210 6211 if (primary && !bond_mode_uses_primary(bond_mode)) { 6212 /* currently, using a primary only makes sense 6213 * in active backup, TLB or ALB modes 6214 */ 6215 pr_warn("Warning: %s primary device specified but has no effect in %s mode\n", 6216 primary, bond_mode_name(bond_mode)); 6217 primary = NULL; 6218 } 6219 6220 if (primary && primary_reselect) { 6221 bond_opt_initstr(&newval, primary_reselect); 6222 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_PRIMARY_RESELECT), 6223 &newval); 6224 if (!valptr) { 6225 pr_err("Error: Invalid primary_reselect \"%s\"\n", 6226 primary_reselect); 6227 return -EINVAL; 6228 } 6229 primary_reselect_value = valptr->value; 6230 } else { 6231 primary_reselect_value = BOND_PRI_RESELECT_ALWAYS; 6232 } 6233 6234 if (fail_over_mac) { 6235 bond_opt_initstr(&newval, fail_over_mac); 6236 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_FAIL_OVER_MAC), 6237 &newval); 6238 if (!valptr) { 6239 pr_err("Error: invalid fail_over_mac \"%s\"\n", 6240 fail_over_mac); 6241 return -EINVAL; 6242 } 6243 fail_over_mac_value = valptr->value; 6244 if (bond_mode != BOND_MODE_ACTIVEBACKUP) 6245 pr_warn("Warning: fail_over_mac only affects active-backup mode\n"); 6246 } else { 6247 fail_over_mac_value = BOND_FOM_NONE; 6248 } 6249 6250 bond_opt_initstr(&newval, "default"); 6251 valptr = bond_opt_parse( 6252 bond_opt_get(BOND_OPT_AD_ACTOR_SYS_PRIO), 6253 &newval); 6254 if (!valptr) { 6255 pr_err("Error: No ad_actor_sys_prio default value"); 6256 return -EINVAL; 6257 } 6258 ad_actor_sys_prio = valptr->value; 6259 6260 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_AD_USER_PORT_KEY), 6261 &newval); 6262 if (!valptr) { 6263 pr_err("Error: No ad_user_port_key default value"); 6264 return -EINVAL; 6265 } 6266 ad_user_port_key = valptr->value; 6267 6268 bond_opt_initstr(&newval, "default"); 6269 valptr = bond_opt_parse(bond_opt_get(BOND_OPT_TLB_DYNAMIC_LB), &newval); 6270 if (!valptr) { 6271 pr_err("Error: No tlb_dynamic_lb default value"); 6272 return -EINVAL; 6273 } 6274 tlb_dynamic_lb = valptr->value; 6275 6276 if (lp_interval == 0) { 6277 pr_warn("Warning: ip_interval must be between 1 and %d, so it was reset to %d\n", 6278 INT_MAX, BOND_ALB_DEFAULT_LP_INTERVAL); 6279 lp_interval = BOND_ALB_DEFAULT_LP_INTERVAL; 6280 } 6281 6282 /* fill params struct with the proper values */ 6283 params->mode = bond_mode; 6284 params->xmit_policy = xmit_hashtype; 6285 params->miimon = miimon; 6286 params->num_peer_notif = num_peer_notif; 6287 params->arp_interval = arp_interval; 6288 params->arp_validate = arp_validate_value; 6289 params->arp_all_targets = arp_all_targets_value; 6290 params->missed_max = 2; 6291 params->updelay = updelay; 6292 params->downdelay = downdelay; 6293 params->peer_notif_delay = 0; 6294 params->use_carrier = use_carrier; 6295 params->lacp_active = 1; 6296 params->lacp_fast = lacp_fast; 6297 params->primary[0] = 0; 6298 params->primary_reselect = primary_reselect_value; 6299 params->fail_over_mac = fail_over_mac_value; 6300 params->tx_queues = tx_queues; 6301 params->all_slaves_active = all_slaves_active; 6302 params->resend_igmp = resend_igmp; 6303 params->min_links = min_links; 6304 params->lp_interval = lp_interval; 6305 params->packets_per_slave = packets_per_slave; 6306 params->tlb_dynamic_lb = tlb_dynamic_lb; 6307 params->ad_actor_sys_prio = ad_actor_sys_prio; 6308 eth_zero_addr(params->ad_actor_system); 6309 params->ad_user_port_key = ad_user_port_key; 6310 params->coupled_control = 1; 6311 if (packets_per_slave > 0) { 6312 params->reciprocal_packets_per_slave = 6313 reciprocal_value(packets_per_slave); 6314 } else { 6315 /* reciprocal_packets_per_slave is unused if 6316 * packets_per_slave is 0 or 1, just initialize it 6317 */ 6318 params->reciprocal_packets_per_slave = 6319 (struct reciprocal_value) { 0 }; 6320 } 6321 6322 if (primary) 6323 strscpy_pad(params->primary, primary, sizeof(params->primary)); 6324 6325 memcpy(params->arp_targets, arp_target, sizeof(arp_target)); 6326 #if IS_ENABLED(CONFIG_IPV6) 6327 memset(params->ns_targets, 0, sizeof(struct in6_addr) * BOND_MAX_NS_TARGETS); 6328 #endif 6329 6330 return 0; 6331 } 6332 6333 /* Called from registration process */ 6334 static int bond_init(struct net_device *bond_dev) 6335 { 6336 struct bonding *bond = netdev_priv(bond_dev); 6337 struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id); 6338 6339 netdev_dbg(bond_dev, "Begin bond_init\n"); 6340 6341 bond->wq = alloc_ordered_workqueue(bond_dev->name, WQ_MEM_RECLAIM); 6342 if (!bond->wq) 6343 return -ENOMEM; 6344 6345 bond->notifier_ctx = false; 6346 6347 spin_lock_init(&bond->stats_lock); 6348 netdev_lockdep_set_classes(bond_dev); 6349 6350 list_add_tail_rcu(&bond->bond_list, &bn->dev_list); 6351 6352 bond_prepare_sysfs_group(bond); 6353 6354 bond_debug_register(bond); 6355 6356 /* Ensure valid dev_addr */ 6357 if (is_zero_ether_addr(bond_dev->dev_addr) && 6358 bond_dev->addr_assign_type == NET_ADDR_PERM) 6359 eth_hw_addr_random(bond_dev); 6360 6361 return 0; 6362 } 6363 6364 unsigned int bond_get_num_tx_queues(void) 6365 { 6366 return tx_queues; 6367 } 6368 6369 /* Create a new bond based on the specified name and bonding parameters. 6370 * If name is NULL, obtain a suitable "bond%d" name for us. 6371 * Caller must NOT hold rtnl_lock; we need to release it here before we 6372 * set up our sysfs entries. 6373 */ 6374 int bond_create(struct net *net, const char *name) 6375 { 6376 struct net_device *bond_dev; 6377 struct bonding *bond; 6378 int res = -ENOMEM; 6379 6380 rtnl_lock(); 6381 6382 bond_dev = alloc_netdev_mq(sizeof(struct bonding), 6383 name ? name : "bond%d", NET_NAME_UNKNOWN, 6384 bond_setup, tx_queues); 6385 if (!bond_dev) 6386 goto out; 6387 6388 bond = netdev_priv(bond_dev); 6389 dev_net_set(bond_dev, net); 6390 bond_dev->rtnl_link_ops = &bond_link_ops; 6391 6392 res = register_netdevice(bond_dev); 6393 if (res < 0) { 6394 free_netdev(bond_dev); 6395 goto out; 6396 } 6397 6398 netif_carrier_off(bond_dev); 6399 6400 bond_work_init_all(bond); 6401 6402 out: 6403 rtnl_unlock(); 6404 return res; 6405 } 6406 6407 static int __net_init bond_net_init(struct net *net) 6408 { 6409 struct bond_net *bn = net_generic(net, bond_net_id); 6410 6411 bn->net = net; 6412 INIT_LIST_HEAD(&bn->dev_list); 6413 6414 bond_create_proc_dir(bn); 6415 bond_create_sysfs(bn); 6416 6417 return 0; 6418 } 6419 6420 /* According to commit 69b0216ac255 ("bonding: fix bonding_masters 6421 * race condition in bond unloading") we need to remove sysfs files 6422 * before we remove our devices (done later in bond_net_exit_batch_rtnl()) 6423 */ 6424 static void __net_exit bond_net_pre_exit(struct net *net) 6425 { 6426 struct bond_net *bn = net_generic(net, bond_net_id); 6427 6428 bond_destroy_sysfs(bn); 6429 } 6430 6431 static void __net_exit bond_net_exit_batch_rtnl(struct list_head *net_list, 6432 struct list_head *dev_kill_list) 6433 { 6434 struct bond_net *bn; 6435 struct net *net; 6436 6437 /* Kill off any bonds created after unregistering bond rtnl ops */ 6438 list_for_each_entry(net, net_list, exit_list) { 6439 struct bonding *bond, *tmp_bond; 6440 6441 bn = net_generic(net, bond_net_id); 6442 list_for_each_entry_safe(bond, tmp_bond, &bn->dev_list, bond_list) 6443 unregister_netdevice_queue(bond->dev, dev_kill_list); 6444 } 6445 } 6446 6447 /* According to commit 23fa5c2caae0 ("bonding: destroy proc directory 6448 * only after all bonds are gone") bond_destroy_proc_dir() is called 6449 * after bond_net_exit_batch_rtnl() has completed. 6450 */ 6451 static void __net_exit bond_net_exit_batch(struct list_head *net_list) 6452 { 6453 struct bond_net *bn; 6454 struct net *net; 6455 6456 list_for_each_entry(net, net_list, exit_list) { 6457 bn = net_generic(net, bond_net_id); 6458 bond_destroy_proc_dir(bn); 6459 } 6460 } 6461 6462 static struct pernet_operations bond_net_ops = { 6463 .init = bond_net_init, 6464 .pre_exit = bond_net_pre_exit, 6465 .exit_batch_rtnl = bond_net_exit_batch_rtnl, 6466 .exit_batch = bond_net_exit_batch, 6467 .id = &bond_net_id, 6468 .size = sizeof(struct bond_net), 6469 }; 6470 6471 static int __init bonding_init(void) 6472 { 6473 int i; 6474 int res; 6475 6476 res = bond_check_params(&bonding_defaults); 6477 if (res) 6478 goto out; 6479 6480 res = register_pernet_subsys(&bond_net_ops); 6481 if (res) 6482 goto out; 6483 6484 res = bond_netlink_init(); 6485 if (res) 6486 goto err_link; 6487 6488 bond_create_debugfs(); 6489 6490 for (i = 0; i < max_bonds; i++) { 6491 res = bond_create(&init_net, NULL); 6492 if (res) 6493 goto err; 6494 } 6495 6496 skb_flow_dissector_init(&flow_keys_bonding, 6497 flow_keys_bonding_keys, 6498 ARRAY_SIZE(flow_keys_bonding_keys)); 6499 6500 register_netdevice_notifier(&bond_netdev_notifier); 6501 out: 6502 return res; 6503 err: 6504 bond_destroy_debugfs(); 6505 bond_netlink_fini(); 6506 err_link: 6507 unregister_pernet_subsys(&bond_net_ops); 6508 goto out; 6509 6510 } 6511 6512 static void __exit bonding_exit(void) 6513 { 6514 unregister_netdevice_notifier(&bond_netdev_notifier); 6515 6516 bond_destroy_debugfs(); 6517 6518 bond_netlink_fini(); 6519 unregister_pernet_subsys(&bond_net_ops); 6520 6521 #ifdef CONFIG_NET_POLL_CONTROLLER 6522 /* Make sure we don't have an imbalance on our netpoll blocking */ 6523 WARN_ON(atomic_read(&netpoll_block_tx)); 6524 #endif 6525 } 6526 6527 module_init(bonding_init); 6528 module_exit(bonding_exit); 6529 MODULE_LICENSE("GPL"); 6530 MODULE_DESCRIPTION(DRV_DESCRIPTION); 6531 MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others"); 6532