Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us