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