Debian Codegraph @

drivers/net/bonding/bond_main.c

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