Loading...
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (c) 2018, Intel Corporation. */
3
4/* This provides a net_failover interface for paravirtual drivers to
5 * provide an alternate datapath by exporting APIs to create and
6 * destroy a upper 'net_failover' netdev. The upper dev manages the
7 * original paravirtual interface as a 'standby' netdev and uses the
8 * generic failover infrastructure to register and manage a direct
9 * attached VF as a 'primary' netdev. This enables live migration of
10 * a VM with direct attached VF by failing over to the paravirtual
11 * datapath when the VF is unplugged.
12 *
13 * Some of the netdev management routines are based on bond/team driver as
14 * this driver provides active-backup functionality similar to those drivers.
15 */
16
17#include <linux/netdevice.h>
18#include <linux/etherdevice.h>
19#include <linux/ethtool.h>
20#include <linux/module.h>
21#include <linux/slab.h>
22#include <linux/netpoll.h>
23#include <linux/rtnetlink.h>
24#include <linux/if_vlan.h>
25#include <linux/pci.h>
26#include <net/sch_generic.h>
27#include <uapi/linux/if_arp.h>
28#include <net/net_failover.h>
29
30static bool net_failover_xmit_ready(struct net_device *dev)
31{
32 return netif_running(dev) && netif_carrier_ok(dev);
33}
34
35static int net_failover_open(struct net_device *dev)
36{
37 struct net_failover_info *nfo_info = netdev_priv(dev);
38 struct net_device *primary_dev, *standby_dev;
39 int err;
40
41 primary_dev = rtnl_dereference(nfo_info->primary_dev);
42 if (primary_dev) {
43 err = dev_open(primary_dev, NULL);
44 if (err)
45 goto err_primary_open;
46 }
47
48 standby_dev = rtnl_dereference(nfo_info->standby_dev);
49 if (standby_dev) {
50 err = dev_open(standby_dev, NULL);
51 if (err)
52 goto err_standby_open;
53 }
54
55 if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
56 (standby_dev && net_failover_xmit_ready(standby_dev))) {
57 netif_carrier_on(dev);
58 netif_tx_wake_all_queues(dev);
59 }
60
61 return 0;
62
63err_standby_open:
64 if (primary_dev)
65 dev_close(primary_dev);
66err_primary_open:
67 netif_tx_disable(dev);
68 return err;
69}
70
71static int net_failover_close(struct net_device *dev)
72{
73 struct net_failover_info *nfo_info = netdev_priv(dev);
74 struct net_device *slave_dev;
75
76 netif_tx_disable(dev);
77
78 slave_dev = rtnl_dereference(nfo_info->primary_dev);
79 if (slave_dev)
80 dev_close(slave_dev);
81
82 slave_dev = rtnl_dereference(nfo_info->standby_dev);
83 if (slave_dev)
84 dev_close(slave_dev);
85
86 return 0;
87}
88
89static netdev_tx_t net_failover_drop_xmit(struct sk_buff *skb,
90 struct net_device *dev)
91{
92 dev_core_stats_tx_dropped_inc(dev);
93 dev_kfree_skb_any(skb);
94 return NETDEV_TX_OK;
95}
96
97static netdev_tx_t net_failover_start_xmit(struct sk_buff *skb,
98 struct net_device *dev)
99{
100 struct net_failover_info *nfo_info = netdev_priv(dev);
101 struct net_device *xmit_dev;
102
103 /* Try xmit via primary netdev followed by standby netdev */
104 xmit_dev = rcu_dereference_bh(nfo_info->primary_dev);
105 if (!xmit_dev || !net_failover_xmit_ready(xmit_dev)) {
106 xmit_dev = rcu_dereference_bh(nfo_info->standby_dev);
107 if (!xmit_dev || !net_failover_xmit_ready(xmit_dev))
108 return net_failover_drop_xmit(skb, dev);
109 }
110
111 skb->dev = xmit_dev;
112 skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
113
114 return dev_queue_xmit(skb);
115}
116
117static u16 net_failover_select_queue(struct net_device *dev,
118 struct sk_buff *skb,
119 struct net_device *sb_dev)
120{
121 struct net_failover_info *nfo_info = netdev_priv(dev);
122 struct net_device *primary_dev;
123 u16 txq;
124
125 primary_dev = rcu_dereference(nfo_info->primary_dev);
126 if (primary_dev) {
127 const struct net_device_ops *ops = primary_dev->netdev_ops;
128
129 if (ops->ndo_select_queue)
130 txq = ops->ndo_select_queue(primary_dev, skb, sb_dev);
131 else
132 txq = netdev_pick_tx(primary_dev, skb, NULL);
133 } else {
134 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
135 }
136
137 /* Save the original txq to restore before passing to the driver */
138 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
139
140 if (unlikely(txq >= dev->real_num_tx_queues)) {
141 do {
142 txq -= dev->real_num_tx_queues;
143 } while (txq >= dev->real_num_tx_queues);
144 }
145
146 return txq;
147}
148
149/* fold stats, assuming all rtnl_link_stats64 fields are u64, but
150 * that some drivers can provide 32bit values only.
151 */
152static void net_failover_fold_stats(struct rtnl_link_stats64 *_res,
153 const struct rtnl_link_stats64 *_new,
154 const struct rtnl_link_stats64 *_old)
155{
156 const u64 *new = (const u64 *)_new;
157 const u64 *old = (const u64 *)_old;
158 u64 *res = (u64 *)_res;
159 int i;
160
161 for (i = 0; i < sizeof(*_res) / sizeof(u64); i++) {
162 u64 nv = new[i];
163 u64 ov = old[i];
164 s64 delta = nv - ov;
165
166 /* detects if this particular field is 32bit only */
167 if (((nv | ov) >> 32) == 0)
168 delta = (s64)(s32)((u32)nv - (u32)ov);
169
170 /* filter anomalies, some drivers reset their stats
171 * at down/up events.
172 */
173 if (delta > 0)
174 res[i] += delta;
175 }
176}
177
178static void net_failover_get_stats(struct net_device *dev,
179 struct rtnl_link_stats64 *stats)
180{
181 struct net_failover_info *nfo_info = netdev_priv(dev);
182 const struct rtnl_link_stats64 *new;
183 struct rtnl_link_stats64 temp;
184 struct net_device *slave_dev;
185
186 spin_lock(&nfo_info->stats_lock);
187 memcpy(stats, &nfo_info->failover_stats, sizeof(*stats));
188
189 rcu_read_lock();
190
191 slave_dev = rcu_dereference(nfo_info->primary_dev);
192 if (slave_dev) {
193 new = dev_get_stats(slave_dev, &temp);
194 net_failover_fold_stats(stats, new, &nfo_info->primary_stats);
195 memcpy(&nfo_info->primary_stats, new, sizeof(*new));
196 }
197
198 slave_dev = rcu_dereference(nfo_info->standby_dev);
199 if (slave_dev) {
200 new = dev_get_stats(slave_dev, &temp);
201 net_failover_fold_stats(stats, new, &nfo_info->standby_stats);
202 memcpy(&nfo_info->standby_stats, new, sizeof(*new));
203 }
204
205 rcu_read_unlock();
206
207 memcpy(&nfo_info->failover_stats, stats, sizeof(*stats));
208 spin_unlock(&nfo_info->stats_lock);
209}
210
211static int net_failover_change_mtu(struct net_device *dev, int new_mtu)
212{
213 struct net_failover_info *nfo_info = netdev_priv(dev);
214 struct net_device *primary_dev, *standby_dev;
215 int ret = 0;
216
217 primary_dev = rtnl_dereference(nfo_info->primary_dev);
218 if (primary_dev) {
219 ret = dev_set_mtu(primary_dev, new_mtu);
220 if (ret)
221 return ret;
222 }
223
224 standby_dev = rtnl_dereference(nfo_info->standby_dev);
225 if (standby_dev) {
226 ret = dev_set_mtu(standby_dev, new_mtu);
227 if (ret) {
228 if (primary_dev)
229 dev_set_mtu(primary_dev, dev->mtu);
230 return ret;
231 }
232 }
233
234 dev->mtu = new_mtu;
235
236 return 0;
237}
238
239static void net_failover_set_rx_mode(struct net_device *dev)
240{
241 struct net_failover_info *nfo_info = netdev_priv(dev);
242 struct net_device *slave_dev;
243
244 rcu_read_lock();
245
246 slave_dev = rcu_dereference(nfo_info->primary_dev);
247 if (slave_dev) {
248 dev_uc_sync_multiple(slave_dev, dev);
249 dev_mc_sync_multiple(slave_dev, dev);
250 }
251
252 slave_dev = rcu_dereference(nfo_info->standby_dev);
253 if (slave_dev) {
254 dev_uc_sync_multiple(slave_dev, dev);
255 dev_mc_sync_multiple(slave_dev, dev);
256 }
257
258 rcu_read_unlock();
259}
260
261static int net_failover_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
262 u16 vid)
263{
264 struct net_failover_info *nfo_info = netdev_priv(dev);
265 struct net_device *primary_dev, *standby_dev;
266 int ret = 0;
267
268 primary_dev = rcu_dereference(nfo_info->primary_dev);
269 if (primary_dev) {
270 ret = vlan_vid_add(primary_dev, proto, vid);
271 if (ret)
272 return ret;
273 }
274
275 standby_dev = rcu_dereference(nfo_info->standby_dev);
276 if (standby_dev) {
277 ret = vlan_vid_add(standby_dev, proto, vid);
278 if (ret)
279 if (primary_dev)
280 vlan_vid_del(primary_dev, proto, vid);
281 }
282
283 return ret;
284}
285
286static int net_failover_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
287 u16 vid)
288{
289 struct net_failover_info *nfo_info = netdev_priv(dev);
290 struct net_device *slave_dev;
291
292 slave_dev = rcu_dereference(nfo_info->primary_dev);
293 if (slave_dev)
294 vlan_vid_del(slave_dev, proto, vid);
295
296 slave_dev = rcu_dereference(nfo_info->standby_dev);
297 if (slave_dev)
298 vlan_vid_del(slave_dev, proto, vid);
299
300 return 0;
301}
302
303static const struct net_device_ops failover_dev_ops = {
304 .ndo_open = net_failover_open,
305 .ndo_stop = net_failover_close,
306 .ndo_start_xmit = net_failover_start_xmit,
307 .ndo_select_queue = net_failover_select_queue,
308 .ndo_get_stats64 = net_failover_get_stats,
309 .ndo_change_mtu = net_failover_change_mtu,
310 .ndo_set_rx_mode = net_failover_set_rx_mode,
311 .ndo_vlan_rx_add_vid = net_failover_vlan_rx_add_vid,
312 .ndo_vlan_rx_kill_vid = net_failover_vlan_rx_kill_vid,
313 .ndo_validate_addr = eth_validate_addr,
314 .ndo_features_check = passthru_features_check,
315};
316
317#define FAILOVER_NAME "net_failover"
318#define FAILOVER_VERSION "0.1"
319
320static void nfo_ethtool_get_drvinfo(struct net_device *dev,
321 struct ethtool_drvinfo *drvinfo)
322{
323 strscpy(drvinfo->driver, FAILOVER_NAME, sizeof(drvinfo->driver));
324 strscpy(drvinfo->version, FAILOVER_VERSION, sizeof(drvinfo->version));
325}
326
327static int nfo_ethtool_get_link_ksettings(struct net_device *dev,
328 struct ethtool_link_ksettings *cmd)
329{
330 struct net_failover_info *nfo_info = netdev_priv(dev);
331 struct net_device *slave_dev;
332
333 slave_dev = rtnl_dereference(nfo_info->primary_dev);
334 if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
335 slave_dev = rtnl_dereference(nfo_info->standby_dev);
336 if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
337 cmd->base.duplex = DUPLEX_UNKNOWN;
338 cmd->base.port = PORT_OTHER;
339 cmd->base.speed = SPEED_UNKNOWN;
340
341 return 0;
342 }
343 }
344
345 return __ethtool_get_link_ksettings(slave_dev, cmd);
346}
347
348static const struct ethtool_ops failover_ethtool_ops = {
349 .get_drvinfo = nfo_ethtool_get_drvinfo,
350 .get_link = ethtool_op_get_link,
351 .get_link_ksettings = nfo_ethtool_get_link_ksettings,
352};
353
354/* Called when slave dev is injecting data into network stack.
355 * Change the associated network device from lower dev to failover dev.
356 * note: already called with rcu_read_lock
357 */
358static rx_handler_result_t net_failover_handle_frame(struct sk_buff **pskb)
359{
360 struct sk_buff *skb = *pskb;
361 struct net_device *dev = rcu_dereference(skb->dev->rx_handler_data);
362 struct net_failover_info *nfo_info = netdev_priv(dev);
363 struct net_device *primary_dev, *standby_dev;
364
365 primary_dev = rcu_dereference(nfo_info->primary_dev);
366 standby_dev = rcu_dereference(nfo_info->standby_dev);
367
368 if (primary_dev && skb->dev == standby_dev)
369 return RX_HANDLER_EXACT;
370
371 skb->dev = dev;
372
373 return RX_HANDLER_ANOTHER;
374}
375
376static void net_failover_compute_features(struct net_device *dev)
377{
378 netdev_features_t vlan_features = FAILOVER_VLAN_FEATURES &
379 NETIF_F_ALL_FOR_ALL;
380 netdev_features_t enc_features = FAILOVER_ENC_FEATURES;
381 unsigned short max_hard_header_len = ETH_HLEN;
382 unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE |
383 IFF_XMIT_DST_RELEASE_PERM;
384 struct net_failover_info *nfo_info = netdev_priv(dev);
385 struct net_device *primary_dev, *standby_dev;
386
387 primary_dev = rcu_dereference(nfo_info->primary_dev);
388 if (primary_dev) {
389 vlan_features =
390 netdev_increment_features(vlan_features,
391 primary_dev->vlan_features,
392 FAILOVER_VLAN_FEATURES);
393 enc_features =
394 netdev_increment_features(enc_features,
395 primary_dev->hw_enc_features,
396 FAILOVER_ENC_FEATURES);
397
398 dst_release_flag &= primary_dev->priv_flags;
399 if (primary_dev->hard_header_len > max_hard_header_len)
400 max_hard_header_len = primary_dev->hard_header_len;
401 }
402
403 standby_dev = rcu_dereference(nfo_info->standby_dev);
404 if (standby_dev) {
405 vlan_features =
406 netdev_increment_features(vlan_features,
407 standby_dev->vlan_features,
408 FAILOVER_VLAN_FEATURES);
409 enc_features =
410 netdev_increment_features(enc_features,
411 standby_dev->hw_enc_features,
412 FAILOVER_ENC_FEATURES);
413
414 dst_release_flag &= standby_dev->priv_flags;
415 if (standby_dev->hard_header_len > max_hard_header_len)
416 max_hard_header_len = standby_dev->hard_header_len;
417 }
418
419 dev->vlan_features = vlan_features;
420 dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL;
421 dev->hard_header_len = max_hard_header_len;
422
423 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
424 if (dst_release_flag == (IFF_XMIT_DST_RELEASE |
425 IFF_XMIT_DST_RELEASE_PERM))
426 dev->priv_flags |= IFF_XMIT_DST_RELEASE;
427
428 netdev_change_features(dev);
429}
430
431static void net_failover_lower_state_changed(struct net_device *slave_dev,
432 struct net_device *primary_dev,
433 struct net_device *standby_dev)
434{
435 struct netdev_lag_lower_state_info info;
436
437 if (netif_carrier_ok(slave_dev))
438 info.link_up = true;
439 else
440 info.link_up = false;
441
442 if (slave_dev == primary_dev) {
443 if (netif_running(primary_dev))
444 info.tx_enabled = true;
445 else
446 info.tx_enabled = false;
447 } else {
448 if ((primary_dev && netif_running(primary_dev)) ||
449 (!netif_running(standby_dev)))
450 info.tx_enabled = false;
451 else
452 info.tx_enabled = true;
453 }
454
455 netdev_lower_state_changed(slave_dev, &info);
456}
457
458static int net_failover_slave_pre_register(struct net_device *slave_dev,
459 struct net_device *failover_dev)
460{
461 struct net_device *standby_dev, *primary_dev;
462 struct net_failover_info *nfo_info;
463 bool slave_is_standby;
464
465 nfo_info = netdev_priv(failover_dev);
466 standby_dev = rtnl_dereference(nfo_info->standby_dev);
467 primary_dev = rtnl_dereference(nfo_info->primary_dev);
468 slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
469 if (slave_is_standby ? standby_dev : primary_dev) {
470 netdev_err(failover_dev, "%s attempting to register as slave dev when %s already present\n",
471 slave_dev->name,
472 slave_is_standby ? "standby" : "primary");
473 return -EINVAL;
474 }
475
476 /* We want to allow only a direct attached VF device as a primary
477 * netdev. As there is no easy way to check for a VF device, restrict
478 * this to a pci device.
479 */
480 if (!slave_is_standby && (!slave_dev->dev.parent ||
481 !dev_is_pci(slave_dev->dev.parent)))
482 return -EINVAL;
483
484 if (failover_dev->features & NETIF_F_VLAN_CHALLENGED &&
485 vlan_uses_dev(failover_dev)) {
486 netdev_err(failover_dev, "Device %s is VLAN challenged and failover device has VLAN set up\n",
487 failover_dev->name);
488 return -EINVAL;
489 }
490
491 return 0;
492}
493
494static int net_failover_slave_register(struct net_device *slave_dev,
495 struct net_device *failover_dev)
496{
497 struct net_device *standby_dev, *primary_dev;
498 struct net_failover_info *nfo_info;
499 bool slave_is_standby;
500 u32 orig_mtu;
501 int err;
502
503 /* Align MTU of slave with failover dev */
504 orig_mtu = slave_dev->mtu;
505 err = dev_set_mtu(slave_dev, failover_dev->mtu);
506 if (err) {
507 netdev_err(failover_dev, "unable to change mtu of %s to %u register failed\n",
508 slave_dev->name, failover_dev->mtu);
509 goto done;
510 }
511
512 dev_hold(slave_dev);
513
514 if (netif_running(failover_dev)) {
515 err = dev_open(slave_dev, NULL);
516 if (err && (err != -EBUSY)) {
517 netdev_err(failover_dev, "Opening slave %s failed err:%d\n",
518 slave_dev->name, err);
519 goto err_dev_open;
520 }
521 }
522
523 netif_addr_lock_bh(failover_dev);
524 dev_uc_sync_multiple(slave_dev, failover_dev);
525 dev_mc_sync_multiple(slave_dev, failover_dev);
526 netif_addr_unlock_bh(failover_dev);
527
528 err = vlan_vids_add_by_dev(slave_dev, failover_dev);
529 if (err) {
530 netdev_err(failover_dev, "Failed to add vlan ids to device %s err:%d\n",
531 slave_dev->name, err);
532 goto err_vlan_add;
533 }
534
535 nfo_info = netdev_priv(failover_dev);
536 standby_dev = rtnl_dereference(nfo_info->standby_dev);
537 primary_dev = rtnl_dereference(nfo_info->primary_dev);
538 slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
539
540 if (slave_is_standby) {
541 rcu_assign_pointer(nfo_info->standby_dev, slave_dev);
542 standby_dev = slave_dev;
543 dev_get_stats(standby_dev, &nfo_info->standby_stats);
544 } else {
545 rcu_assign_pointer(nfo_info->primary_dev, slave_dev);
546 primary_dev = slave_dev;
547 dev_get_stats(primary_dev, &nfo_info->primary_stats);
548 failover_dev->min_mtu = slave_dev->min_mtu;
549 failover_dev->max_mtu = slave_dev->max_mtu;
550 }
551
552 net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
553 net_failover_compute_features(failover_dev);
554
555 call_netdevice_notifiers(NETDEV_JOIN, slave_dev);
556
557 netdev_info(failover_dev, "failover %s slave:%s registered\n",
558 slave_is_standby ? "standby" : "primary", slave_dev->name);
559
560 return 0;
561
562err_vlan_add:
563 dev_uc_unsync(slave_dev, failover_dev);
564 dev_mc_unsync(slave_dev, failover_dev);
565 dev_close(slave_dev);
566err_dev_open:
567 dev_put(slave_dev);
568 dev_set_mtu(slave_dev, orig_mtu);
569done:
570 return err;
571}
572
573static int net_failover_slave_pre_unregister(struct net_device *slave_dev,
574 struct net_device *failover_dev)
575{
576 struct net_device *standby_dev, *primary_dev;
577 struct net_failover_info *nfo_info;
578
579 nfo_info = netdev_priv(failover_dev);
580 primary_dev = rtnl_dereference(nfo_info->primary_dev);
581 standby_dev = rtnl_dereference(nfo_info->standby_dev);
582
583 if (slave_dev != primary_dev && slave_dev != standby_dev)
584 return -ENODEV;
585
586 return 0;
587}
588
589static int net_failover_slave_unregister(struct net_device *slave_dev,
590 struct net_device *failover_dev)
591{
592 struct net_device *standby_dev, *primary_dev;
593 struct net_failover_info *nfo_info;
594 bool slave_is_standby;
595
596 nfo_info = netdev_priv(failover_dev);
597 primary_dev = rtnl_dereference(nfo_info->primary_dev);
598 standby_dev = rtnl_dereference(nfo_info->standby_dev);
599
600 if (WARN_ON_ONCE(slave_dev != primary_dev && slave_dev != standby_dev))
601 return -ENODEV;
602
603 vlan_vids_del_by_dev(slave_dev, failover_dev);
604 dev_uc_unsync(slave_dev, failover_dev);
605 dev_mc_unsync(slave_dev, failover_dev);
606 dev_close(slave_dev);
607
608 nfo_info = netdev_priv(failover_dev);
609 dev_get_stats(failover_dev, &nfo_info->failover_stats);
610
611 slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
612 if (slave_is_standby) {
613 RCU_INIT_POINTER(nfo_info->standby_dev, NULL);
614 } else {
615 RCU_INIT_POINTER(nfo_info->primary_dev, NULL);
616 if (standby_dev) {
617 failover_dev->min_mtu = standby_dev->min_mtu;
618 failover_dev->max_mtu = standby_dev->max_mtu;
619 }
620 }
621
622 dev_put(slave_dev);
623
624 net_failover_compute_features(failover_dev);
625
626 netdev_info(failover_dev, "failover %s slave:%s unregistered\n",
627 slave_is_standby ? "standby" : "primary", slave_dev->name);
628
629 return 0;
630}
631
632static int net_failover_slave_link_change(struct net_device *slave_dev,
633 struct net_device *failover_dev)
634{
635 struct net_device *primary_dev, *standby_dev;
636 struct net_failover_info *nfo_info;
637
638 nfo_info = netdev_priv(failover_dev);
639
640 primary_dev = rtnl_dereference(nfo_info->primary_dev);
641 standby_dev = rtnl_dereference(nfo_info->standby_dev);
642
643 if (slave_dev != primary_dev && slave_dev != standby_dev)
644 return -ENODEV;
645
646 if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
647 (standby_dev && net_failover_xmit_ready(standby_dev))) {
648 netif_carrier_on(failover_dev);
649 netif_tx_wake_all_queues(failover_dev);
650 } else {
651 dev_get_stats(failover_dev, &nfo_info->failover_stats);
652 netif_carrier_off(failover_dev);
653 netif_tx_stop_all_queues(failover_dev);
654 }
655
656 net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
657
658 return 0;
659}
660
661static int net_failover_slave_name_change(struct net_device *slave_dev,
662 struct net_device *failover_dev)
663{
664 struct net_device *primary_dev, *standby_dev;
665 struct net_failover_info *nfo_info;
666
667 nfo_info = netdev_priv(failover_dev);
668
669 primary_dev = rtnl_dereference(nfo_info->primary_dev);
670 standby_dev = rtnl_dereference(nfo_info->standby_dev);
671
672 if (slave_dev != primary_dev && slave_dev != standby_dev)
673 return -ENODEV;
674
675 /* We need to bring up the slave after the rename by udev in case
676 * open failed with EBUSY when it was registered.
677 */
678 dev_open(slave_dev, NULL);
679
680 return 0;
681}
682
683static struct failover_ops net_failover_ops = {
684 .slave_pre_register = net_failover_slave_pre_register,
685 .slave_register = net_failover_slave_register,
686 .slave_pre_unregister = net_failover_slave_pre_unregister,
687 .slave_unregister = net_failover_slave_unregister,
688 .slave_link_change = net_failover_slave_link_change,
689 .slave_name_change = net_failover_slave_name_change,
690 .slave_handle_frame = net_failover_handle_frame,
691};
692
693/**
694 * net_failover_create - Create and register a failover instance
695 *
696 * @standby_dev: standby netdev
697 *
698 * Creates a failover netdev and registers a failover instance for a standby
699 * netdev. Used by paravirtual drivers that use 3-netdev model.
700 * The failover netdev acts as a master device and controls 2 slave devices -
701 * the original standby netdev and a VF netdev with the same MAC gets
702 * registered as primary netdev.
703 *
704 * Return: pointer to failover instance
705 */
706struct failover *net_failover_create(struct net_device *standby_dev)
707{
708 struct device *dev = standby_dev->dev.parent;
709 struct net_device *failover_dev;
710 struct failover *failover;
711 int err;
712
713 /* Alloc at least 2 queues, for now we are going with 16 assuming
714 * that VF devices being enslaved won't have too many queues.
715 */
716 failover_dev = alloc_etherdev_mq(sizeof(struct net_failover_info), 16);
717 if (!failover_dev) {
718 dev_err(dev, "Unable to allocate failover_netdev!\n");
719 return ERR_PTR(-ENOMEM);
720 }
721
722 dev_net_set(failover_dev, dev_net(standby_dev));
723 SET_NETDEV_DEV(failover_dev, dev);
724
725 failover_dev->netdev_ops = &failover_dev_ops;
726 failover_dev->ethtool_ops = &failover_ethtool_ops;
727
728 /* Initialize the device options */
729 failover_dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE;
730 failover_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE |
731 IFF_TX_SKB_SHARING);
732
733 /* don't acquire failover netdev's netif_tx_lock when transmitting */
734 failover_dev->features |= NETIF_F_LLTX;
735
736 /* Don't allow failover devices to change network namespaces. */
737 failover_dev->features |= NETIF_F_NETNS_LOCAL;
738
739 failover_dev->hw_features = FAILOVER_VLAN_FEATURES |
740 NETIF_F_HW_VLAN_CTAG_TX |
741 NETIF_F_HW_VLAN_CTAG_RX |
742 NETIF_F_HW_VLAN_CTAG_FILTER;
743
744 failover_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
745 failover_dev->features |= failover_dev->hw_features;
746
747 dev_addr_set(failover_dev, standby_dev->dev_addr);
748
749 failover_dev->min_mtu = standby_dev->min_mtu;
750 failover_dev->max_mtu = standby_dev->max_mtu;
751
752 err = register_netdev(failover_dev);
753 if (err) {
754 dev_err(dev, "Unable to register failover_dev!\n");
755 goto err_register_netdev;
756 }
757
758 netif_carrier_off(failover_dev);
759
760 failover = failover_register(failover_dev, &net_failover_ops);
761 if (IS_ERR(failover)) {
762 err = PTR_ERR(failover);
763 goto err_failover_register;
764 }
765
766 return failover;
767
768err_failover_register:
769 unregister_netdev(failover_dev);
770err_register_netdev:
771 free_netdev(failover_dev);
772
773 return ERR_PTR(err);
774}
775EXPORT_SYMBOL_GPL(net_failover_create);
776
777/**
778 * net_failover_destroy - Destroy a failover instance
779 *
780 * @failover: pointer to failover instance
781 *
782 * Unregisters any slave netdevs associated with the failover instance by
783 * calling failover_slave_unregister().
784 * unregisters the failover instance itself and finally frees the failover
785 * netdev. Used by paravirtual drivers that use 3-netdev model.
786 *
787 */
788void net_failover_destroy(struct failover *failover)
789{
790 struct net_failover_info *nfo_info;
791 struct net_device *failover_dev;
792 struct net_device *slave_dev;
793
794 if (!failover)
795 return;
796
797 failover_dev = rcu_dereference(failover->failover_dev);
798 nfo_info = netdev_priv(failover_dev);
799
800 netif_device_detach(failover_dev);
801
802 rtnl_lock();
803
804 slave_dev = rtnl_dereference(nfo_info->primary_dev);
805 if (slave_dev)
806 failover_slave_unregister(slave_dev);
807
808 slave_dev = rtnl_dereference(nfo_info->standby_dev);
809 if (slave_dev)
810 failover_slave_unregister(slave_dev);
811
812 failover_unregister(failover);
813
814 unregister_netdevice(failover_dev);
815
816 rtnl_unlock();
817
818 free_netdev(failover_dev);
819}
820EXPORT_SYMBOL_GPL(net_failover_destroy);
821
822static __init int
823net_failover_init(void)
824{
825 return 0;
826}
827module_init(net_failover_init);
828
829static __exit
830void net_failover_exit(void)
831{
832}
833module_exit(net_failover_exit);
834
835MODULE_DESCRIPTION("Failover driver for Paravirtual drivers");
836MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (c) 2018, Intel Corporation. */
3
4/* This provides a net_failover interface for paravirtual drivers to
5 * provide an alternate datapath by exporting APIs to create and
6 * destroy a upper 'net_failover' netdev. The upper dev manages the
7 * original paravirtual interface as a 'standby' netdev and uses the
8 * generic failover infrastructure to register and manage a direct
9 * attached VF as a 'primary' netdev. This enables live migration of
10 * a VM with direct attached VF by failing over to the paravirtual
11 * datapath when the VF is unplugged.
12 *
13 * Some of the netdev management routines are based on bond/team driver as
14 * this driver provides active-backup functionality similar to those drivers.
15 */
16
17#include <linux/netdevice.h>
18#include <linux/etherdevice.h>
19#include <linux/ethtool.h>
20#include <linux/module.h>
21#include <linux/slab.h>
22#include <linux/netpoll.h>
23#include <linux/rtnetlink.h>
24#include <linux/if_vlan.h>
25#include <linux/pci.h>
26#include <net/sch_generic.h>
27#include <uapi/linux/if_arp.h>
28#include <net/net_failover.h>
29
30static bool net_failover_xmit_ready(struct net_device *dev)
31{
32 return netif_running(dev) && netif_carrier_ok(dev);
33}
34
35static int net_failover_open(struct net_device *dev)
36{
37 struct net_failover_info *nfo_info = netdev_priv(dev);
38 struct net_device *primary_dev, *standby_dev;
39 int err;
40
41 primary_dev = rtnl_dereference(nfo_info->primary_dev);
42 if (primary_dev) {
43 err = dev_open(primary_dev, NULL);
44 if (err)
45 goto err_primary_open;
46 }
47
48 standby_dev = rtnl_dereference(nfo_info->standby_dev);
49 if (standby_dev) {
50 err = dev_open(standby_dev, NULL);
51 if (err)
52 goto err_standby_open;
53 }
54
55 if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
56 (standby_dev && net_failover_xmit_ready(standby_dev))) {
57 netif_carrier_on(dev);
58 netif_tx_wake_all_queues(dev);
59 }
60
61 return 0;
62
63err_standby_open:
64 dev_close(primary_dev);
65err_primary_open:
66 netif_tx_disable(dev);
67 return err;
68}
69
70static int net_failover_close(struct net_device *dev)
71{
72 struct net_failover_info *nfo_info = netdev_priv(dev);
73 struct net_device *slave_dev;
74
75 netif_tx_disable(dev);
76
77 slave_dev = rtnl_dereference(nfo_info->primary_dev);
78 if (slave_dev)
79 dev_close(slave_dev);
80
81 slave_dev = rtnl_dereference(nfo_info->standby_dev);
82 if (slave_dev)
83 dev_close(slave_dev);
84
85 return 0;
86}
87
88static netdev_tx_t net_failover_drop_xmit(struct sk_buff *skb,
89 struct net_device *dev)
90{
91 atomic_long_inc(&dev->tx_dropped);
92 dev_kfree_skb_any(skb);
93 return NETDEV_TX_OK;
94}
95
96static netdev_tx_t net_failover_start_xmit(struct sk_buff *skb,
97 struct net_device *dev)
98{
99 struct net_failover_info *nfo_info = netdev_priv(dev);
100 struct net_device *xmit_dev;
101
102 /* Try xmit via primary netdev followed by standby netdev */
103 xmit_dev = rcu_dereference_bh(nfo_info->primary_dev);
104 if (!xmit_dev || !net_failover_xmit_ready(xmit_dev)) {
105 xmit_dev = rcu_dereference_bh(nfo_info->standby_dev);
106 if (!xmit_dev || !net_failover_xmit_ready(xmit_dev))
107 return net_failover_drop_xmit(skb, dev);
108 }
109
110 skb->dev = xmit_dev;
111 skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
112
113 return dev_queue_xmit(skb);
114}
115
116static u16 net_failover_select_queue(struct net_device *dev,
117 struct sk_buff *skb,
118 struct net_device *sb_dev)
119{
120 struct net_failover_info *nfo_info = netdev_priv(dev);
121 struct net_device *primary_dev;
122 u16 txq;
123
124 primary_dev = rcu_dereference(nfo_info->primary_dev);
125 if (primary_dev) {
126 const struct net_device_ops *ops = primary_dev->netdev_ops;
127
128 if (ops->ndo_select_queue)
129 txq = ops->ndo_select_queue(primary_dev, skb, sb_dev);
130 else
131 txq = netdev_pick_tx(primary_dev, skb, NULL);
132
133 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
134
135 return txq;
136 }
137
138 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
139
140 /* Save the original txq to restore before passing to the driver */
141 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
142
143 if (unlikely(txq >= dev->real_num_tx_queues)) {
144 do {
145 txq -= dev->real_num_tx_queues;
146 } while (txq >= dev->real_num_tx_queues);
147 }
148
149 return txq;
150}
151
152/* fold stats, assuming all rtnl_link_stats64 fields are u64, but
153 * that some drivers can provide 32bit values only.
154 */
155static void net_failover_fold_stats(struct rtnl_link_stats64 *_res,
156 const struct rtnl_link_stats64 *_new,
157 const struct rtnl_link_stats64 *_old)
158{
159 const u64 *new = (const u64 *)_new;
160 const u64 *old = (const u64 *)_old;
161 u64 *res = (u64 *)_res;
162 int i;
163
164 for (i = 0; i < sizeof(*_res) / sizeof(u64); i++) {
165 u64 nv = new[i];
166 u64 ov = old[i];
167 s64 delta = nv - ov;
168
169 /* detects if this particular field is 32bit only */
170 if (((nv | ov) >> 32) == 0)
171 delta = (s64)(s32)((u32)nv - (u32)ov);
172
173 /* filter anomalies, some drivers reset their stats
174 * at down/up events.
175 */
176 if (delta > 0)
177 res[i] += delta;
178 }
179}
180
181static void net_failover_get_stats(struct net_device *dev,
182 struct rtnl_link_stats64 *stats)
183{
184 struct net_failover_info *nfo_info = netdev_priv(dev);
185 const struct rtnl_link_stats64 *new;
186 struct rtnl_link_stats64 temp;
187 struct net_device *slave_dev;
188
189 spin_lock(&nfo_info->stats_lock);
190 memcpy(stats, &nfo_info->failover_stats, sizeof(*stats));
191
192 rcu_read_lock();
193
194 slave_dev = rcu_dereference(nfo_info->primary_dev);
195 if (slave_dev) {
196 new = dev_get_stats(slave_dev, &temp);
197 net_failover_fold_stats(stats, new, &nfo_info->primary_stats);
198 memcpy(&nfo_info->primary_stats, new, sizeof(*new));
199 }
200
201 slave_dev = rcu_dereference(nfo_info->standby_dev);
202 if (slave_dev) {
203 new = dev_get_stats(slave_dev, &temp);
204 net_failover_fold_stats(stats, new, &nfo_info->standby_stats);
205 memcpy(&nfo_info->standby_stats, new, sizeof(*new));
206 }
207
208 rcu_read_unlock();
209
210 memcpy(&nfo_info->failover_stats, stats, sizeof(*stats));
211 spin_unlock(&nfo_info->stats_lock);
212}
213
214static int net_failover_change_mtu(struct net_device *dev, int new_mtu)
215{
216 struct net_failover_info *nfo_info = netdev_priv(dev);
217 struct net_device *primary_dev, *standby_dev;
218 int ret = 0;
219
220 primary_dev = rtnl_dereference(nfo_info->primary_dev);
221 if (primary_dev) {
222 ret = dev_set_mtu(primary_dev, new_mtu);
223 if (ret)
224 return ret;
225 }
226
227 standby_dev = rtnl_dereference(nfo_info->standby_dev);
228 if (standby_dev) {
229 ret = dev_set_mtu(standby_dev, new_mtu);
230 if (ret) {
231 if (primary_dev)
232 dev_set_mtu(primary_dev, dev->mtu);
233 return ret;
234 }
235 }
236
237 dev->mtu = new_mtu;
238
239 return 0;
240}
241
242static void net_failover_set_rx_mode(struct net_device *dev)
243{
244 struct net_failover_info *nfo_info = netdev_priv(dev);
245 struct net_device *slave_dev;
246
247 rcu_read_lock();
248
249 slave_dev = rcu_dereference(nfo_info->primary_dev);
250 if (slave_dev) {
251 dev_uc_sync_multiple(slave_dev, dev);
252 dev_mc_sync_multiple(slave_dev, dev);
253 }
254
255 slave_dev = rcu_dereference(nfo_info->standby_dev);
256 if (slave_dev) {
257 dev_uc_sync_multiple(slave_dev, dev);
258 dev_mc_sync_multiple(slave_dev, dev);
259 }
260
261 rcu_read_unlock();
262}
263
264static int net_failover_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
265 u16 vid)
266{
267 struct net_failover_info *nfo_info = netdev_priv(dev);
268 struct net_device *primary_dev, *standby_dev;
269 int ret = 0;
270
271 primary_dev = rcu_dereference(nfo_info->primary_dev);
272 if (primary_dev) {
273 ret = vlan_vid_add(primary_dev, proto, vid);
274 if (ret)
275 return ret;
276 }
277
278 standby_dev = rcu_dereference(nfo_info->standby_dev);
279 if (standby_dev) {
280 ret = vlan_vid_add(standby_dev, proto, vid);
281 if (ret)
282 if (primary_dev)
283 vlan_vid_del(primary_dev, proto, vid);
284 }
285
286 return ret;
287}
288
289static int net_failover_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
290 u16 vid)
291{
292 struct net_failover_info *nfo_info = netdev_priv(dev);
293 struct net_device *slave_dev;
294
295 slave_dev = rcu_dereference(nfo_info->primary_dev);
296 if (slave_dev)
297 vlan_vid_del(slave_dev, proto, vid);
298
299 slave_dev = rcu_dereference(nfo_info->standby_dev);
300 if (slave_dev)
301 vlan_vid_del(slave_dev, proto, vid);
302
303 return 0;
304}
305
306static const struct net_device_ops failover_dev_ops = {
307 .ndo_open = net_failover_open,
308 .ndo_stop = net_failover_close,
309 .ndo_start_xmit = net_failover_start_xmit,
310 .ndo_select_queue = net_failover_select_queue,
311 .ndo_get_stats64 = net_failover_get_stats,
312 .ndo_change_mtu = net_failover_change_mtu,
313 .ndo_set_rx_mode = net_failover_set_rx_mode,
314 .ndo_vlan_rx_add_vid = net_failover_vlan_rx_add_vid,
315 .ndo_vlan_rx_kill_vid = net_failover_vlan_rx_kill_vid,
316 .ndo_validate_addr = eth_validate_addr,
317 .ndo_features_check = passthru_features_check,
318};
319
320#define FAILOVER_NAME "net_failover"
321#define FAILOVER_VERSION "0.1"
322
323static void nfo_ethtool_get_drvinfo(struct net_device *dev,
324 struct ethtool_drvinfo *drvinfo)
325{
326 strlcpy(drvinfo->driver, FAILOVER_NAME, sizeof(drvinfo->driver));
327 strlcpy(drvinfo->version, FAILOVER_VERSION, sizeof(drvinfo->version));
328}
329
330static int nfo_ethtool_get_link_ksettings(struct net_device *dev,
331 struct ethtool_link_ksettings *cmd)
332{
333 struct net_failover_info *nfo_info = netdev_priv(dev);
334 struct net_device *slave_dev;
335
336 slave_dev = rtnl_dereference(nfo_info->primary_dev);
337 if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
338 slave_dev = rtnl_dereference(nfo_info->standby_dev);
339 if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
340 cmd->base.duplex = DUPLEX_UNKNOWN;
341 cmd->base.port = PORT_OTHER;
342 cmd->base.speed = SPEED_UNKNOWN;
343
344 return 0;
345 }
346 }
347
348 return __ethtool_get_link_ksettings(slave_dev, cmd);
349}
350
351static const struct ethtool_ops failover_ethtool_ops = {
352 .get_drvinfo = nfo_ethtool_get_drvinfo,
353 .get_link = ethtool_op_get_link,
354 .get_link_ksettings = nfo_ethtool_get_link_ksettings,
355};
356
357/* Called when slave dev is injecting data into network stack.
358 * Change the associated network device from lower dev to failover dev.
359 * note: already called with rcu_read_lock
360 */
361static rx_handler_result_t net_failover_handle_frame(struct sk_buff **pskb)
362{
363 struct sk_buff *skb = *pskb;
364 struct net_device *dev = rcu_dereference(skb->dev->rx_handler_data);
365 struct net_failover_info *nfo_info = netdev_priv(dev);
366 struct net_device *primary_dev, *standby_dev;
367
368 primary_dev = rcu_dereference(nfo_info->primary_dev);
369 standby_dev = rcu_dereference(nfo_info->standby_dev);
370
371 if (primary_dev && skb->dev == standby_dev)
372 return RX_HANDLER_EXACT;
373
374 skb->dev = dev;
375
376 return RX_HANDLER_ANOTHER;
377}
378
379static void net_failover_compute_features(struct net_device *dev)
380{
381 netdev_features_t vlan_features = FAILOVER_VLAN_FEATURES &
382 NETIF_F_ALL_FOR_ALL;
383 netdev_features_t enc_features = FAILOVER_ENC_FEATURES;
384 unsigned short max_hard_header_len = ETH_HLEN;
385 unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE |
386 IFF_XMIT_DST_RELEASE_PERM;
387 struct net_failover_info *nfo_info = netdev_priv(dev);
388 struct net_device *primary_dev, *standby_dev;
389
390 primary_dev = rcu_dereference(nfo_info->primary_dev);
391 if (primary_dev) {
392 vlan_features =
393 netdev_increment_features(vlan_features,
394 primary_dev->vlan_features,
395 FAILOVER_VLAN_FEATURES);
396 enc_features =
397 netdev_increment_features(enc_features,
398 primary_dev->hw_enc_features,
399 FAILOVER_ENC_FEATURES);
400
401 dst_release_flag &= primary_dev->priv_flags;
402 if (primary_dev->hard_header_len > max_hard_header_len)
403 max_hard_header_len = primary_dev->hard_header_len;
404 }
405
406 standby_dev = rcu_dereference(nfo_info->standby_dev);
407 if (standby_dev) {
408 vlan_features =
409 netdev_increment_features(vlan_features,
410 standby_dev->vlan_features,
411 FAILOVER_VLAN_FEATURES);
412 enc_features =
413 netdev_increment_features(enc_features,
414 standby_dev->hw_enc_features,
415 FAILOVER_ENC_FEATURES);
416
417 dst_release_flag &= standby_dev->priv_flags;
418 if (standby_dev->hard_header_len > max_hard_header_len)
419 max_hard_header_len = standby_dev->hard_header_len;
420 }
421
422 dev->vlan_features = vlan_features;
423 dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL;
424 dev->hard_header_len = max_hard_header_len;
425
426 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
427 if (dst_release_flag == (IFF_XMIT_DST_RELEASE |
428 IFF_XMIT_DST_RELEASE_PERM))
429 dev->priv_flags |= IFF_XMIT_DST_RELEASE;
430
431 netdev_change_features(dev);
432}
433
434static void net_failover_lower_state_changed(struct net_device *slave_dev,
435 struct net_device *primary_dev,
436 struct net_device *standby_dev)
437{
438 struct netdev_lag_lower_state_info info;
439
440 if (netif_carrier_ok(slave_dev))
441 info.link_up = true;
442 else
443 info.link_up = false;
444
445 if (slave_dev == primary_dev) {
446 if (netif_running(primary_dev))
447 info.tx_enabled = true;
448 else
449 info.tx_enabled = false;
450 } else {
451 if ((primary_dev && netif_running(primary_dev)) ||
452 (!netif_running(standby_dev)))
453 info.tx_enabled = false;
454 else
455 info.tx_enabled = true;
456 }
457
458 netdev_lower_state_changed(slave_dev, &info);
459}
460
461static int net_failover_slave_pre_register(struct net_device *slave_dev,
462 struct net_device *failover_dev)
463{
464 struct net_device *standby_dev, *primary_dev;
465 struct net_failover_info *nfo_info;
466 bool slave_is_standby;
467
468 nfo_info = netdev_priv(failover_dev);
469 standby_dev = rtnl_dereference(nfo_info->standby_dev);
470 primary_dev = rtnl_dereference(nfo_info->primary_dev);
471 slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
472 if (slave_is_standby ? standby_dev : primary_dev) {
473 netdev_err(failover_dev, "%s attempting to register as slave dev when %s already present\n",
474 slave_dev->name,
475 slave_is_standby ? "standby" : "primary");
476 return -EINVAL;
477 }
478
479 /* We want to allow only a direct attached VF device as a primary
480 * netdev. As there is no easy way to check for a VF device, restrict
481 * this to a pci device.
482 */
483 if (!slave_is_standby && (!slave_dev->dev.parent ||
484 !dev_is_pci(slave_dev->dev.parent)))
485 return -EINVAL;
486
487 if (failover_dev->features & NETIF_F_VLAN_CHALLENGED &&
488 vlan_uses_dev(failover_dev)) {
489 netdev_err(failover_dev, "Device %s is VLAN challenged and failover device has VLAN set up\n",
490 failover_dev->name);
491 return -EINVAL;
492 }
493
494 return 0;
495}
496
497static int net_failover_slave_register(struct net_device *slave_dev,
498 struct net_device *failover_dev)
499{
500 struct net_device *standby_dev, *primary_dev;
501 struct net_failover_info *nfo_info;
502 bool slave_is_standby;
503 u32 orig_mtu;
504 int err;
505
506 /* Align MTU of slave with failover dev */
507 orig_mtu = slave_dev->mtu;
508 err = dev_set_mtu(slave_dev, failover_dev->mtu);
509 if (err) {
510 netdev_err(failover_dev, "unable to change mtu of %s to %u register failed\n",
511 slave_dev->name, failover_dev->mtu);
512 goto done;
513 }
514
515 dev_hold(slave_dev);
516
517 if (netif_running(failover_dev)) {
518 err = dev_open(slave_dev, NULL);
519 if (err && (err != -EBUSY)) {
520 netdev_err(failover_dev, "Opening slave %s failed err:%d\n",
521 slave_dev->name, err);
522 goto err_dev_open;
523 }
524 }
525
526 netif_addr_lock_bh(failover_dev);
527 dev_uc_sync_multiple(slave_dev, failover_dev);
528 dev_mc_sync_multiple(slave_dev, failover_dev);
529 netif_addr_unlock_bh(failover_dev);
530
531 err = vlan_vids_add_by_dev(slave_dev, failover_dev);
532 if (err) {
533 netdev_err(failover_dev, "Failed to add vlan ids to device %s err:%d\n",
534 slave_dev->name, err);
535 goto err_vlan_add;
536 }
537
538 nfo_info = netdev_priv(failover_dev);
539 standby_dev = rtnl_dereference(nfo_info->standby_dev);
540 primary_dev = rtnl_dereference(nfo_info->primary_dev);
541 slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
542
543 if (slave_is_standby) {
544 rcu_assign_pointer(nfo_info->standby_dev, slave_dev);
545 standby_dev = slave_dev;
546 dev_get_stats(standby_dev, &nfo_info->standby_stats);
547 } else {
548 rcu_assign_pointer(nfo_info->primary_dev, slave_dev);
549 primary_dev = slave_dev;
550 dev_get_stats(primary_dev, &nfo_info->primary_stats);
551 failover_dev->min_mtu = slave_dev->min_mtu;
552 failover_dev->max_mtu = slave_dev->max_mtu;
553 }
554
555 net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
556 net_failover_compute_features(failover_dev);
557
558 call_netdevice_notifiers(NETDEV_JOIN, slave_dev);
559
560 netdev_info(failover_dev, "failover %s slave:%s registered\n",
561 slave_is_standby ? "standby" : "primary", slave_dev->name);
562
563 return 0;
564
565err_vlan_add:
566 dev_uc_unsync(slave_dev, failover_dev);
567 dev_mc_unsync(slave_dev, failover_dev);
568 dev_close(slave_dev);
569err_dev_open:
570 dev_put(slave_dev);
571 dev_set_mtu(slave_dev, orig_mtu);
572done:
573 return err;
574}
575
576static int net_failover_slave_pre_unregister(struct net_device *slave_dev,
577 struct net_device *failover_dev)
578{
579 struct net_device *standby_dev, *primary_dev;
580 struct net_failover_info *nfo_info;
581
582 nfo_info = netdev_priv(failover_dev);
583 primary_dev = rtnl_dereference(nfo_info->primary_dev);
584 standby_dev = rtnl_dereference(nfo_info->standby_dev);
585
586 if (slave_dev != primary_dev && slave_dev != standby_dev)
587 return -ENODEV;
588
589 return 0;
590}
591
592static int net_failover_slave_unregister(struct net_device *slave_dev,
593 struct net_device *failover_dev)
594{
595 struct net_device *standby_dev, *primary_dev;
596 struct net_failover_info *nfo_info;
597 bool slave_is_standby;
598
599 nfo_info = netdev_priv(failover_dev);
600 primary_dev = rtnl_dereference(nfo_info->primary_dev);
601 standby_dev = rtnl_dereference(nfo_info->standby_dev);
602
603 if (WARN_ON_ONCE(slave_dev != primary_dev && slave_dev != standby_dev))
604 return -ENODEV;
605
606 vlan_vids_del_by_dev(slave_dev, failover_dev);
607 dev_uc_unsync(slave_dev, failover_dev);
608 dev_mc_unsync(slave_dev, failover_dev);
609 dev_close(slave_dev);
610
611 nfo_info = netdev_priv(failover_dev);
612 dev_get_stats(failover_dev, &nfo_info->failover_stats);
613
614 slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
615 if (slave_is_standby) {
616 RCU_INIT_POINTER(nfo_info->standby_dev, NULL);
617 } else {
618 RCU_INIT_POINTER(nfo_info->primary_dev, NULL);
619 if (standby_dev) {
620 failover_dev->min_mtu = standby_dev->min_mtu;
621 failover_dev->max_mtu = standby_dev->max_mtu;
622 }
623 }
624
625 dev_put(slave_dev);
626
627 net_failover_compute_features(failover_dev);
628
629 netdev_info(failover_dev, "failover %s slave:%s unregistered\n",
630 slave_is_standby ? "standby" : "primary", slave_dev->name);
631
632 return 0;
633}
634
635static int net_failover_slave_link_change(struct net_device *slave_dev,
636 struct net_device *failover_dev)
637{
638 struct net_device *primary_dev, *standby_dev;
639 struct net_failover_info *nfo_info;
640
641 nfo_info = netdev_priv(failover_dev);
642
643 primary_dev = rtnl_dereference(nfo_info->primary_dev);
644 standby_dev = rtnl_dereference(nfo_info->standby_dev);
645
646 if (slave_dev != primary_dev && slave_dev != standby_dev)
647 return -ENODEV;
648
649 if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
650 (standby_dev && net_failover_xmit_ready(standby_dev))) {
651 netif_carrier_on(failover_dev);
652 netif_tx_wake_all_queues(failover_dev);
653 } else {
654 dev_get_stats(failover_dev, &nfo_info->failover_stats);
655 netif_carrier_off(failover_dev);
656 netif_tx_stop_all_queues(failover_dev);
657 }
658
659 net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
660
661 return 0;
662}
663
664static int net_failover_slave_name_change(struct net_device *slave_dev,
665 struct net_device *failover_dev)
666{
667 struct net_device *primary_dev, *standby_dev;
668 struct net_failover_info *nfo_info;
669
670 nfo_info = netdev_priv(failover_dev);
671
672 primary_dev = rtnl_dereference(nfo_info->primary_dev);
673 standby_dev = rtnl_dereference(nfo_info->standby_dev);
674
675 if (slave_dev != primary_dev && slave_dev != standby_dev)
676 return -ENODEV;
677
678 /* We need to bring up the slave after the rename by udev in case
679 * open failed with EBUSY when it was registered.
680 */
681 dev_open(slave_dev, NULL);
682
683 return 0;
684}
685
686static struct failover_ops net_failover_ops = {
687 .slave_pre_register = net_failover_slave_pre_register,
688 .slave_register = net_failover_slave_register,
689 .slave_pre_unregister = net_failover_slave_pre_unregister,
690 .slave_unregister = net_failover_slave_unregister,
691 .slave_link_change = net_failover_slave_link_change,
692 .slave_name_change = net_failover_slave_name_change,
693 .slave_handle_frame = net_failover_handle_frame,
694};
695
696/**
697 * net_failover_create - Create and register a failover instance
698 *
699 * @dev: standby netdev
700 *
701 * Creates a failover netdev and registers a failover instance for a standby
702 * netdev. Used by paravirtual drivers that use 3-netdev model.
703 * The failover netdev acts as a master device and controls 2 slave devices -
704 * the original standby netdev and a VF netdev with the same MAC gets
705 * registered as primary netdev.
706 *
707 * Return: pointer to failover instance
708 */
709struct failover *net_failover_create(struct net_device *standby_dev)
710{
711 struct device *dev = standby_dev->dev.parent;
712 struct net_device *failover_dev;
713 struct failover *failover;
714 int err;
715
716 /* Alloc at least 2 queues, for now we are going with 16 assuming
717 * that VF devices being enslaved won't have too many queues.
718 */
719 failover_dev = alloc_etherdev_mq(sizeof(struct net_failover_info), 16);
720 if (!failover_dev) {
721 dev_err(dev, "Unable to allocate failover_netdev!\n");
722 return ERR_PTR(-ENOMEM);
723 }
724
725 dev_net_set(failover_dev, dev_net(standby_dev));
726 SET_NETDEV_DEV(failover_dev, dev);
727
728 failover_dev->netdev_ops = &failover_dev_ops;
729 failover_dev->ethtool_ops = &failover_ethtool_ops;
730
731 /* Initialize the device options */
732 failover_dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE;
733 failover_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE |
734 IFF_TX_SKB_SHARING);
735
736 /* don't acquire failover netdev's netif_tx_lock when transmitting */
737 failover_dev->features |= NETIF_F_LLTX;
738
739 /* Don't allow failover devices to change network namespaces. */
740 failover_dev->features |= NETIF_F_NETNS_LOCAL;
741
742 failover_dev->hw_features = FAILOVER_VLAN_FEATURES |
743 NETIF_F_HW_VLAN_CTAG_TX |
744 NETIF_F_HW_VLAN_CTAG_RX |
745 NETIF_F_HW_VLAN_CTAG_FILTER;
746
747 failover_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
748 failover_dev->features |= failover_dev->hw_features;
749
750 memcpy(failover_dev->dev_addr, standby_dev->dev_addr,
751 failover_dev->addr_len);
752
753 failover_dev->min_mtu = standby_dev->min_mtu;
754 failover_dev->max_mtu = standby_dev->max_mtu;
755
756 err = register_netdev(failover_dev);
757 if (err) {
758 dev_err(dev, "Unable to register failover_dev!\n");
759 goto err_register_netdev;
760 }
761
762 netif_carrier_off(failover_dev);
763
764 failover = failover_register(failover_dev, &net_failover_ops);
765 if (IS_ERR(failover)) {
766 err = PTR_ERR(failover);
767 goto err_failover_register;
768 }
769
770 return failover;
771
772err_failover_register:
773 unregister_netdev(failover_dev);
774err_register_netdev:
775 free_netdev(failover_dev);
776
777 return ERR_PTR(err);
778}
779EXPORT_SYMBOL_GPL(net_failover_create);
780
781/**
782 * net_failover_destroy - Destroy a failover instance
783 *
784 * @failover: pointer to failover instance
785 *
786 * Unregisters any slave netdevs associated with the failover instance by
787 * calling failover_slave_unregister().
788 * unregisters the failover instance itself and finally frees the failover
789 * netdev. Used by paravirtual drivers that use 3-netdev model.
790 *
791 */
792void net_failover_destroy(struct failover *failover)
793{
794 struct net_failover_info *nfo_info;
795 struct net_device *failover_dev;
796 struct net_device *slave_dev;
797
798 if (!failover)
799 return;
800
801 failover_dev = rcu_dereference(failover->failover_dev);
802 nfo_info = netdev_priv(failover_dev);
803
804 netif_device_detach(failover_dev);
805
806 rtnl_lock();
807
808 slave_dev = rtnl_dereference(nfo_info->primary_dev);
809 if (slave_dev)
810 failover_slave_unregister(slave_dev);
811
812 slave_dev = rtnl_dereference(nfo_info->standby_dev);
813 if (slave_dev)
814 failover_slave_unregister(slave_dev);
815
816 failover_unregister(failover);
817
818 unregister_netdevice(failover_dev);
819
820 rtnl_unlock();
821
822 free_netdev(failover_dev);
823}
824EXPORT_SYMBOL_GPL(net_failover_destroy);
825
826static __init int
827net_failover_init(void)
828{
829 return 0;
830}
831module_init(net_failover_init);
832
833static __exit
834void net_failover_exit(void)
835{
836}
837module_exit(net_failover_exit);
838
839MODULE_DESCRIPTION("Failover driver for Paravirtual drivers");
840MODULE_LICENSE("GPL v2");