drivers/net/bonding/bond_main.c

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