1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 atomic_long_inc(&dev->tx_dropped);
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
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
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
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
154
155
156static 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
171 if (((nv | ov) >> 32) == 0)
172 delta = (s64)(s32)((u32)nv - (u32)ov);
173
174
175
176
177 if (delta > 0)
178 res[i] += delta;
179 }
180}
181
182static 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
215static 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
243static 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
265static 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
290static 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
307static 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
324static 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
331static 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
352static 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
359
360
361
362static 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
380static 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
435static 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
462static 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
481
482
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
498static 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
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
566err_vlan_add:
567 dev_uc_unsync(slave_dev, failover_dev);
568 dev_mc_unsync(slave_dev, failover_dev);
569 dev_close(slave_dev);
570err_dev_open:
571 dev_put(slave_dev);
572 dev_set_mtu(slave_dev, orig_mtu);
573done:
574 return err;
575}
576
577static 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
593static 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
636static 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
665static 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
680
681
682 dev_open(slave_dev, NULL);
683
684 return 0;
685}
686
687static 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
699
700
701
702
703
704
705
706
707
708
709
710struct 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
718
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
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
738 failover_dev->features |= NETIF_F_LLTX;
739
740
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 memcpy(failover_dev->dev_addr, standby_dev->dev_addr,
752 failover_dev->addr_len);
753
754 failover_dev->min_mtu = standby_dev->min_mtu;
755 failover_dev->max_mtu = standby_dev->max_mtu;
756
757 err = register_netdev(failover_dev);
758 if (err) {
759 dev_err(dev, "Unable to register failover_dev!\n");
760 goto err_register_netdev;
761 }
762
763 netif_carrier_off(failover_dev);
764
765 failover = failover_register(failover_dev, &net_failover_ops);
766 if (IS_ERR(failover)) {
767 err = PTR_ERR(failover);
768 goto err_failover_register;
769 }
770
771 return failover;
772
773err_failover_register:
774 unregister_netdev(failover_dev);
775err_register_netdev:
776 free_netdev(failover_dev);
777
778 return ERR_PTR(err);
779}
780EXPORT_SYMBOL_GPL(net_failover_create);
781
782
783
784
785
786
787
788
789
790
791
792
793void net_failover_destroy(struct failover *failover)
794{
795 struct net_failover_info *nfo_info;
796 struct net_device *failover_dev;
797 struct net_device *slave_dev;
798
799 if (!failover)
800 return;
801
802 failover_dev = rcu_dereference(failover->failover_dev);
803 nfo_info = netdev_priv(failover_dev);
804
805 netif_device_detach(failover_dev);
806
807 rtnl_lock();
808
809 slave_dev = rtnl_dereference(nfo_info->primary_dev);
810 if (slave_dev)
811 failover_slave_unregister(slave_dev);
812
813 slave_dev = rtnl_dereference(nfo_info->standby_dev);
814 if (slave_dev)
815 failover_slave_unregister(slave_dev);
816
817 failover_unregister(failover);
818
819 unregister_netdevice(failover_dev);
820
821 rtnl_unlock();
822
823 free_netdev(failover_dev);
824}
825EXPORT_SYMBOL_GPL(net_failover_destroy);
826
827static __init int
828net_failover_init(void)
829{
830 return 0;
831}
832module_init(net_failover_init);
833
834static __exit
835void net_failover_exit(void)
836{
837}
838module_exit(net_failover_exit);
839
840MODULE_DESCRIPTION("Failover driver for Paravirtual drivers");
841MODULE_LICENSE("GPL v2");
842
