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