GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / net / net_failover.c
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
30 static bool net_failover_xmit_ready(struct net_device *dev)
31 {
32         return netif_running(dev) && netif_carrier_ok(dev);
33 }
34
35 static 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
63 err_standby_open:
64         if (primary_dev)
65                 dev_close(primary_dev);
66 err_primary_open:
67         netif_tx_disable(dev);
68         return err;
69 }
70
71 static 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
89 static 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
97 static 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
117 static 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
134                 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
135
136                 return txq;
137         }
138
139         txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
140
141         /* Save the original txq to restore before passing to the driver */
142         qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
143
144         if (unlikely(txq >= dev->real_num_tx_queues)) {
145                 do {
146                         txq -= dev->real_num_tx_queues;
147                 } while (txq >= dev->real_num_tx_queues);
148         }
149
150         return txq;
151 }
152
153 /* fold stats, assuming all rtnl_link_stats64 fields are u64, but
154  * that some drivers can provide 32bit values only.
155  */
156 static void net_failover_fold_stats(struct rtnl_link_stats64 *_res,
157                                     const struct rtnl_link_stats64 *_new,
158                                     const struct rtnl_link_stats64 *_old)
159 {
160         const u64 *new = (const u64 *)_new;
161         const u64 *old = (const u64 *)_old;
162         u64 *res = (u64 *)_res;
163         int i;
164
165         for (i = 0; i < sizeof(*_res) / sizeof(u64); i++) {
166                 u64 nv = new[i];
167                 u64 ov = old[i];
168                 s64 delta = nv - ov;
169
170                 /* detects if this particular field is 32bit only */
171                 if (((nv | ov) >> 32) == 0)
172                         delta = (s64)(s32)((u32)nv - (u32)ov);
173
174                 /* filter anomalies, some drivers reset their stats
175                  * at down/up events.
176                  */
177                 if (delta > 0)
178                         res[i] += delta;
179         }
180 }
181
182 static void net_failover_get_stats(struct net_device *dev,
183                                    struct rtnl_link_stats64 *stats)
184 {
185         struct net_failover_info *nfo_info = netdev_priv(dev);
186         const struct rtnl_link_stats64 *new;
187         struct rtnl_link_stats64 temp;
188         struct net_device *slave_dev;
189
190         spin_lock(&nfo_info->stats_lock);
191         memcpy(stats, &nfo_info->failover_stats, sizeof(*stats));
192
193         rcu_read_lock();
194
195         slave_dev = rcu_dereference(nfo_info->primary_dev);
196         if (slave_dev) {
197                 new = dev_get_stats(slave_dev, &temp);
198                 net_failover_fold_stats(stats, new, &nfo_info->primary_stats);
199                 memcpy(&nfo_info->primary_stats, new, sizeof(*new));
200         }
201
202         slave_dev = rcu_dereference(nfo_info->standby_dev);
203         if (slave_dev) {
204                 new = dev_get_stats(slave_dev, &temp);
205                 net_failover_fold_stats(stats, new, &nfo_info->standby_stats);
206                 memcpy(&nfo_info->standby_stats, new, sizeof(*new));
207         }
208
209         rcu_read_unlock();
210
211         memcpy(&nfo_info->failover_stats, stats, sizeof(*stats));
212         spin_unlock(&nfo_info->stats_lock);
213 }
214
215 static int net_failover_change_mtu(struct net_device *dev, int new_mtu)
216 {
217         struct net_failover_info *nfo_info = netdev_priv(dev);
218         struct net_device *primary_dev, *standby_dev;
219         int ret = 0;
220
221         primary_dev = rtnl_dereference(nfo_info->primary_dev);
222         if (primary_dev) {
223                 ret = dev_set_mtu(primary_dev, new_mtu);
224                 if (ret)
225                         return ret;
226         }
227
228         standby_dev = rtnl_dereference(nfo_info->standby_dev);
229         if (standby_dev) {
230                 ret = dev_set_mtu(standby_dev, new_mtu);
231                 if (ret) {
232                         if (primary_dev)
233                                 dev_set_mtu(primary_dev, dev->mtu);
234                         return ret;
235                 }
236         }
237
238         dev->mtu = new_mtu;
239
240         return 0;
241 }
242
243 static void net_failover_set_rx_mode(struct net_device *dev)
244 {
245         struct net_failover_info *nfo_info = netdev_priv(dev);
246         struct net_device *slave_dev;
247
248         rcu_read_lock();
249
250         slave_dev = rcu_dereference(nfo_info->primary_dev);
251         if (slave_dev) {
252                 dev_uc_sync_multiple(slave_dev, dev);
253                 dev_mc_sync_multiple(slave_dev, dev);
254         }
255
256         slave_dev = rcu_dereference(nfo_info->standby_dev);
257         if (slave_dev) {
258                 dev_uc_sync_multiple(slave_dev, dev);
259                 dev_mc_sync_multiple(slave_dev, dev);
260         }
261
262         rcu_read_unlock();
263 }
264
265 static int net_failover_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
266                                         u16 vid)
267 {
268         struct net_failover_info *nfo_info = netdev_priv(dev);
269         struct net_device *primary_dev, *standby_dev;
270         int ret = 0;
271
272         primary_dev = rcu_dereference(nfo_info->primary_dev);
273         if (primary_dev) {
274                 ret = vlan_vid_add(primary_dev, proto, vid);
275                 if (ret)
276                         return ret;
277         }
278
279         standby_dev = rcu_dereference(nfo_info->standby_dev);
280         if (standby_dev) {
281                 ret = vlan_vid_add(standby_dev, proto, vid);
282                 if (ret)
283                         if (primary_dev)
284                                 vlan_vid_del(primary_dev, proto, vid);
285         }
286
287         return ret;
288 }
289
290 static int net_failover_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
291                                          u16 vid)
292 {
293         struct net_failover_info *nfo_info = netdev_priv(dev);
294         struct net_device *slave_dev;
295
296         slave_dev = rcu_dereference(nfo_info->primary_dev);
297         if (slave_dev)
298                 vlan_vid_del(slave_dev, proto, vid);
299
300         slave_dev = rcu_dereference(nfo_info->standby_dev);
301         if (slave_dev)
302                 vlan_vid_del(slave_dev, proto, vid);
303
304         return 0;
305 }
306
307 static const struct net_device_ops failover_dev_ops = {
308         .ndo_open               = net_failover_open,
309         .ndo_stop               = net_failover_close,
310         .ndo_start_xmit         = net_failover_start_xmit,
311         .ndo_select_queue       = net_failover_select_queue,
312         .ndo_get_stats64        = net_failover_get_stats,
313         .ndo_change_mtu         = net_failover_change_mtu,
314         .ndo_set_rx_mode        = net_failover_set_rx_mode,
315         .ndo_vlan_rx_add_vid    = net_failover_vlan_rx_add_vid,
316         .ndo_vlan_rx_kill_vid   = net_failover_vlan_rx_kill_vid,
317         .ndo_validate_addr      = eth_validate_addr,
318         .ndo_features_check     = passthru_features_check,
319 };
320
321 #define FAILOVER_NAME "net_failover"
322 #define FAILOVER_VERSION "0.1"
323
324 static void nfo_ethtool_get_drvinfo(struct net_device *dev,
325                                     struct ethtool_drvinfo *drvinfo)
326 {
327         strlcpy(drvinfo->driver, FAILOVER_NAME, sizeof(drvinfo->driver));
328         strlcpy(drvinfo->version, FAILOVER_VERSION, sizeof(drvinfo->version));
329 }
330
331 static int nfo_ethtool_get_link_ksettings(struct net_device *dev,
332                                           struct ethtool_link_ksettings *cmd)
333 {
334         struct net_failover_info *nfo_info = netdev_priv(dev);
335         struct net_device *slave_dev;
336
337         slave_dev = rtnl_dereference(nfo_info->primary_dev);
338         if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
339                 slave_dev = rtnl_dereference(nfo_info->standby_dev);
340                 if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
341                         cmd->base.duplex = DUPLEX_UNKNOWN;
342                         cmd->base.port = PORT_OTHER;
343                         cmd->base.speed = SPEED_UNKNOWN;
344
345                         return 0;
346                 }
347         }
348
349         return __ethtool_get_link_ksettings(slave_dev, cmd);
350 }
351
352 static const struct ethtool_ops failover_ethtool_ops = {
353         .get_drvinfo            = nfo_ethtool_get_drvinfo,
354         .get_link               = ethtool_op_get_link,
355         .get_link_ksettings     = nfo_ethtool_get_link_ksettings,
356 };
357
358 /* Called when slave dev is injecting data into network stack.
359  * Change the associated network device from lower dev to failover dev.
360  * note: already called with rcu_read_lock
361  */
362 static rx_handler_result_t net_failover_handle_frame(struct sk_buff **pskb)
363 {
364         struct sk_buff *skb = *pskb;
365         struct net_device *dev = rcu_dereference(skb->dev->rx_handler_data);
366         struct net_failover_info *nfo_info = netdev_priv(dev);
367         struct net_device *primary_dev, *standby_dev;
368
369         primary_dev = rcu_dereference(nfo_info->primary_dev);
370         standby_dev = rcu_dereference(nfo_info->standby_dev);
371
372         if (primary_dev && skb->dev == standby_dev)
373                 return RX_HANDLER_EXACT;
374
375         skb->dev = dev;
376
377         return RX_HANDLER_ANOTHER;
378 }
379
380 static void net_failover_compute_features(struct net_device *dev)
381 {
382         netdev_features_t vlan_features = FAILOVER_VLAN_FEATURES &
383                                           NETIF_F_ALL_FOR_ALL;
384         netdev_features_t enc_features  = FAILOVER_ENC_FEATURES;
385         unsigned short max_hard_header_len = ETH_HLEN;
386         unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE |
387                                         IFF_XMIT_DST_RELEASE_PERM;
388         struct net_failover_info *nfo_info = netdev_priv(dev);
389         struct net_device *primary_dev, *standby_dev;
390
391         primary_dev = rcu_dereference(nfo_info->primary_dev);
392         if (primary_dev) {
393                 vlan_features =
394                         netdev_increment_features(vlan_features,
395                                                   primary_dev->vlan_features,
396                                                   FAILOVER_VLAN_FEATURES);
397                 enc_features =
398                         netdev_increment_features(enc_features,
399                                                   primary_dev->hw_enc_features,
400                                                   FAILOVER_ENC_FEATURES);
401
402                 dst_release_flag &= primary_dev->priv_flags;
403                 if (primary_dev->hard_header_len > max_hard_header_len)
404                         max_hard_header_len = primary_dev->hard_header_len;
405         }
406
407         standby_dev = rcu_dereference(nfo_info->standby_dev);
408         if (standby_dev) {
409                 vlan_features =
410                         netdev_increment_features(vlan_features,
411                                                   standby_dev->vlan_features,
412                                                   FAILOVER_VLAN_FEATURES);
413                 enc_features =
414                         netdev_increment_features(enc_features,
415                                                   standby_dev->hw_enc_features,
416                                                   FAILOVER_ENC_FEATURES);
417
418                 dst_release_flag &= standby_dev->priv_flags;
419                 if (standby_dev->hard_header_len > max_hard_header_len)
420                         max_hard_header_len = standby_dev->hard_header_len;
421         }
422
423         dev->vlan_features = vlan_features;
424         dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL;
425         dev->hard_header_len = max_hard_header_len;
426
427         dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
428         if (dst_release_flag == (IFF_XMIT_DST_RELEASE |
429                                  IFF_XMIT_DST_RELEASE_PERM))
430                 dev->priv_flags |= IFF_XMIT_DST_RELEASE;
431
432         netdev_change_features(dev);
433 }
434
435 static void net_failover_lower_state_changed(struct net_device *slave_dev,
436                                              struct net_device *primary_dev,
437                                              struct net_device *standby_dev)
438 {
439         struct netdev_lag_lower_state_info info;
440
441         if (netif_carrier_ok(slave_dev))
442                 info.link_up = true;
443         else
444                 info.link_up = false;
445
446         if (slave_dev == primary_dev) {
447                 if (netif_running(primary_dev))
448                         info.tx_enabled = true;
449                 else
450                         info.tx_enabled = false;
451         } else {
452                 if ((primary_dev && netif_running(primary_dev)) ||
453                     (!netif_running(standby_dev)))
454                         info.tx_enabled = false;
455                 else
456                         info.tx_enabled = true;
457         }
458
459         netdev_lower_state_changed(slave_dev, &info);
460 }
461
462 static int net_failover_slave_pre_register(struct net_device *slave_dev,
463                                            struct net_device *failover_dev)
464 {
465         struct net_device *standby_dev, *primary_dev;
466         struct net_failover_info *nfo_info;
467         bool slave_is_standby;
468
469         nfo_info = netdev_priv(failover_dev);
470         standby_dev = rtnl_dereference(nfo_info->standby_dev);
471         primary_dev = rtnl_dereference(nfo_info->primary_dev);
472         slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
473         if (slave_is_standby ? standby_dev : primary_dev) {
474                 netdev_err(failover_dev, "%s attempting to register as slave dev when %s already present\n",
475                            slave_dev->name,
476                            slave_is_standby ? "standby" : "primary");
477                 return -EINVAL;
478         }
479
480         /* We want to allow only a direct attached VF device as a primary
481          * netdev. As there is no easy way to check for a VF device, restrict
482          * this to a pci device.
483          */
484         if (!slave_is_standby && (!slave_dev->dev.parent ||
485                                   !dev_is_pci(slave_dev->dev.parent)))
486                 return -EINVAL;
487
488         if (failover_dev->features & NETIF_F_VLAN_CHALLENGED &&
489             vlan_uses_dev(failover_dev)) {
490                 netdev_err(failover_dev, "Device %s is VLAN challenged and failover device has VLAN set up\n",
491                            failover_dev->name);
492                 return -EINVAL;
493         }
494
495         return 0;
496 }
497
498 static int net_failover_slave_register(struct net_device *slave_dev,
499                                        struct net_device *failover_dev)
500 {
501         struct net_device *standby_dev, *primary_dev;
502         struct net_failover_info *nfo_info;
503         bool slave_is_standby;
504         u32 orig_mtu;
505         int err;
506
507         /* Align MTU of slave with failover dev */
508         orig_mtu = slave_dev->mtu;
509         err = dev_set_mtu(slave_dev, failover_dev->mtu);
510         if (err) {
511                 netdev_err(failover_dev, "unable to change mtu of %s to %u register failed\n",
512                            slave_dev->name, failover_dev->mtu);
513                 goto done;
514         }
515
516         dev_hold(slave_dev);
517
518         if (netif_running(failover_dev)) {
519                 err = dev_open(slave_dev, NULL);
520                 if (err && (err != -EBUSY)) {
521                         netdev_err(failover_dev, "Opening slave %s failed err:%d\n",
522                                    slave_dev->name, err);
523                         goto err_dev_open;
524                 }
525         }
526
527         netif_addr_lock_bh(failover_dev);
528         dev_uc_sync_multiple(slave_dev, failover_dev);
529         dev_mc_sync_multiple(slave_dev, failover_dev);
530         netif_addr_unlock_bh(failover_dev);
531
532         err = vlan_vids_add_by_dev(slave_dev, failover_dev);
533         if (err) {
534                 netdev_err(failover_dev, "Failed to add vlan ids to device %s err:%d\n",
535                            slave_dev->name, err);
536                 goto err_vlan_add;
537         }
538
539         nfo_info = netdev_priv(failover_dev);
540         standby_dev = rtnl_dereference(nfo_info->standby_dev);
541         primary_dev = rtnl_dereference(nfo_info->primary_dev);
542         slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
543
544         if (slave_is_standby) {
545                 rcu_assign_pointer(nfo_info->standby_dev, slave_dev);
546                 standby_dev = slave_dev;
547                 dev_get_stats(standby_dev, &nfo_info->standby_stats);
548         } else {
549                 rcu_assign_pointer(nfo_info->primary_dev, slave_dev);
550                 primary_dev = slave_dev;
551                 dev_get_stats(primary_dev, &nfo_info->primary_stats);
552                 failover_dev->min_mtu = slave_dev->min_mtu;
553                 failover_dev->max_mtu = slave_dev->max_mtu;
554         }
555
556         net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
557         net_failover_compute_features(failover_dev);
558
559         call_netdevice_notifiers(NETDEV_JOIN, slave_dev);
560
561         netdev_info(failover_dev, "failover %s slave:%s registered\n",
562                     slave_is_standby ? "standby" : "primary", slave_dev->name);
563
564         return 0;
565
566 err_vlan_add:
567         dev_uc_unsync(slave_dev, failover_dev);
568         dev_mc_unsync(slave_dev, failover_dev);
569         dev_close(slave_dev);
570 err_dev_open:
571         dev_put(slave_dev);
572         dev_set_mtu(slave_dev, orig_mtu);
573 done:
574         return err;
575 }
576
577 static int net_failover_slave_pre_unregister(struct net_device *slave_dev,
578                                              struct net_device *failover_dev)
579 {
580         struct net_device *standby_dev, *primary_dev;
581         struct net_failover_info *nfo_info;
582
583         nfo_info = netdev_priv(failover_dev);
584         primary_dev = rtnl_dereference(nfo_info->primary_dev);
585         standby_dev = rtnl_dereference(nfo_info->standby_dev);
586
587         if (slave_dev != primary_dev && slave_dev != standby_dev)
588                 return -ENODEV;
589
590         return 0;
591 }
592
593 static int net_failover_slave_unregister(struct net_device *slave_dev,
594                                          struct net_device *failover_dev)
595 {
596         struct net_device *standby_dev, *primary_dev;
597         struct net_failover_info *nfo_info;
598         bool slave_is_standby;
599
600         nfo_info = netdev_priv(failover_dev);
601         primary_dev = rtnl_dereference(nfo_info->primary_dev);
602         standby_dev = rtnl_dereference(nfo_info->standby_dev);
603
604         if (WARN_ON_ONCE(slave_dev != primary_dev && slave_dev != standby_dev))
605                 return -ENODEV;
606
607         vlan_vids_del_by_dev(slave_dev, failover_dev);
608         dev_uc_unsync(slave_dev, failover_dev);
609         dev_mc_unsync(slave_dev, failover_dev);
610         dev_close(slave_dev);
611
612         nfo_info = netdev_priv(failover_dev);
613         dev_get_stats(failover_dev, &nfo_info->failover_stats);
614
615         slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
616         if (slave_is_standby) {
617                 RCU_INIT_POINTER(nfo_info->standby_dev, NULL);
618         } else {
619                 RCU_INIT_POINTER(nfo_info->primary_dev, NULL);
620                 if (standby_dev) {
621                         failover_dev->min_mtu = standby_dev->min_mtu;
622                         failover_dev->max_mtu = standby_dev->max_mtu;
623                 }
624         }
625
626         dev_put(slave_dev);
627
628         net_failover_compute_features(failover_dev);
629
630         netdev_info(failover_dev, "failover %s slave:%s unregistered\n",
631                     slave_is_standby ? "standby" : "primary", slave_dev->name);
632
633         return 0;
634 }
635
636 static int net_failover_slave_link_change(struct net_device *slave_dev,
637                                           struct net_device *failover_dev)
638 {
639         struct net_device *primary_dev, *standby_dev;
640         struct net_failover_info *nfo_info;
641
642         nfo_info = netdev_priv(failover_dev);
643
644         primary_dev = rtnl_dereference(nfo_info->primary_dev);
645         standby_dev = rtnl_dereference(nfo_info->standby_dev);
646
647         if (slave_dev != primary_dev && slave_dev != standby_dev)
648                 return -ENODEV;
649
650         if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
651             (standby_dev && net_failover_xmit_ready(standby_dev))) {
652                 netif_carrier_on(failover_dev);
653                 netif_tx_wake_all_queues(failover_dev);
654         } else {
655                 dev_get_stats(failover_dev, &nfo_info->failover_stats);
656                 netif_carrier_off(failover_dev);
657                 netif_tx_stop_all_queues(failover_dev);
658         }
659
660         net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
661
662         return 0;
663 }
664
665 static int net_failover_slave_name_change(struct net_device *slave_dev,
666                                           struct net_device *failover_dev)
667 {
668         struct net_device *primary_dev, *standby_dev;
669         struct net_failover_info *nfo_info;
670
671         nfo_info = netdev_priv(failover_dev);
672
673         primary_dev = rtnl_dereference(nfo_info->primary_dev);
674         standby_dev = rtnl_dereference(nfo_info->standby_dev);
675
676         if (slave_dev != primary_dev && slave_dev != standby_dev)
677                 return -ENODEV;
678
679         /* We need to bring up the slave after the rename by udev in case
680          * open failed with EBUSY when it was registered.
681          */
682         dev_open(slave_dev, NULL);
683
684         return 0;
685 }
686
687 static struct failover_ops net_failover_ops = {
688         .slave_pre_register     = net_failover_slave_pre_register,
689         .slave_register         = net_failover_slave_register,
690         .slave_pre_unregister   = net_failover_slave_pre_unregister,
691         .slave_unregister       = net_failover_slave_unregister,
692         .slave_link_change      = net_failover_slave_link_change,
693         .slave_name_change      = net_failover_slave_name_change,
694         .slave_handle_frame     = net_failover_handle_frame,
695 };
696
697 /**
698  * net_failover_create - Create and register a failover instance
699  *
700  * @standby_dev: standby netdev
701  *
702  * Creates a failover netdev and registers a failover instance for a standby
703  * netdev. Used by paravirtual drivers that use 3-netdev model.
704  * The failover netdev acts as a master device and controls 2 slave devices -
705  * the original standby netdev and a VF netdev with the same MAC gets
706  * registered as primary netdev.
707  *
708  * Return: pointer to failover instance
709  */
710 struct failover *net_failover_create(struct net_device *standby_dev)
711 {
712         struct device *dev = standby_dev->dev.parent;
713         struct net_device *failover_dev;
714         struct failover *failover;
715         int err;
716
717         /* Alloc at least 2 queues, for now we are going with 16 assuming
718          * that VF devices being enslaved won't have too many queues.
719          */
720         failover_dev = alloc_etherdev_mq(sizeof(struct net_failover_info), 16);
721         if (!failover_dev) {
722                 dev_err(dev, "Unable to allocate failover_netdev!\n");
723                 return ERR_PTR(-ENOMEM);
724         }
725
726         dev_net_set(failover_dev, dev_net(standby_dev));
727         SET_NETDEV_DEV(failover_dev, dev);
728
729         failover_dev->netdev_ops = &failover_dev_ops;
730         failover_dev->ethtool_ops = &failover_ethtool_ops;
731
732         /* Initialize the device options */
733         failover_dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE;
734         failover_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE |
735                                        IFF_TX_SKB_SHARING);
736
737         /* don't acquire failover netdev's netif_tx_lock when transmitting */
738         failover_dev->features |= NETIF_F_LLTX;
739
740         /* Don't allow failover devices to change network namespaces. */
741         failover_dev->features |= NETIF_F_NETNS_LOCAL;
742
743         failover_dev->hw_features = FAILOVER_VLAN_FEATURES |
744                                     NETIF_F_HW_VLAN_CTAG_TX |
745                                     NETIF_F_HW_VLAN_CTAG_RX |
746                                     NETIF_F_HW_VLAN_CTAG_FILTER;
747
748         failover_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
749         failover_dev->features |= failover_dev->hw_features;
750
751         dev_addr_set(failover_dev, standby_dev->dev_addr);
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
772 err_failover_register:
773         unregister_netdev(failover_dev);
774 err_register_netdev:
775         free_netdev(failover_dev);
776
777         return ERR_PTR(err);
778 }
779 EXPORT_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  */
792 void 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 }
824 EXPORT_SYMBOL_GPL(net_failover_destroy);
825
826 static __init int
827 net_failover_init(void)
828 {
829         return 0;
830 }
831 module_init(net_failover_init);
832
833 static __exit
834 void net_failover_exit(void)
835 {
836 }
837 module_exit(net_failover_exit);
838
839 MODULE_DESCRIPTION("Failover driver for Paravirtual drivers");
840 MODULE_LICENSE("GPL v2");