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);
  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);
  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         dev_close(primary_dev);
  65 err_primary_open:
  66         netif_tx_disable(dev);
  67         return err;
  68 }
  69
  70 static 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
  88 static 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
  96 static 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
 116 static u16 net_failover_select_queue(struct net_device *dev,
 117                                      struct sk_buff *skb,
 118                                      struct net_device *sb_dev,
 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                                                     sb_dev, fallback);
 132                 else
 133                         txq = fallback(primary_dev, skb, NULL);
 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  */
 157 static 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
 183 static 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
 216 static 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 = rtnl_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 = rtnl_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
 244 static 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
 266 static 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
 291 static 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
 308 static 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
 325 static 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
 332 static 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
 353 static 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  */
 363 static 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
 381 static void net_failover_compute_features(struct net_device *dev)
 382 {
 383         netdev_features_t vlan_features = FAILOVER_VLAN_FEATURES &
 384                                           NETIF_F_ALL_FOR_ALL;
 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
 436 static 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
 463 static 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
 499 static 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);
 530         dev_mc_sync_multiple(slave_dev, failover_dev);
 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
 567 err_vlan_add:
 568         dev_uc_unsync(slave_dev, failover_dev);
 569         dev_mc_unsync(slave_dev, failover_dev);
 570         dev_close(slave_dev);
 571 err_dev_open:
 572         dev_put(slave_dev);
 573         dev_set_mtu(slave_dev, orig_mtu);
 574 done:
 575         return err;
 576 }
 577
 578 static 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
 594 static 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         if (WARN_ON_ONCE(slave_dev != primary_dev && slave_dev != standby_dev))
 606                 return -ENODEV;
 607
 608         vlan_vids_del_by_dev(slave_dev, failover_dev);
 609         dev_uc_unsync(slave_dev, failover_dev);
 610         dev_mc_unsync(slave_dev, failover_dev);
 611         dev_close(slave_dev);
 612
 613         nfo_info = netdev_priv(failover_dev);
 614         dev_get_stats(failover_dev, &nfo_info->failover_stats);
 615
 616         slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
 617         if (slave_is_standby) {
 618                 RCU_INIT_POINTER(nfo_info->standby_dev, NULL);
 619         } else {
 620                 RCU_INIT_POINTER(nfo_info->primary_dev, NULL);
 621                 if (standby_dev) {
 622                         failover_dev->min_mtu = standby_dev->min_mtu;
 623                         failover_dev->max_mtu = standby_dev->max_mtu;
 624                 }
 625         }
 626
 627         dev_put(slave_dev);
 628
 629         net_failover_compute_features(failover_dev);
 630
 631         netdev_info(failover_dev, "failover %s slave:%s unregistered\n",
 632                     slave_is_standby ? "standby" : "primary", slave_dev->name);
 633
 634         return 0;
 635 }
 636
 637 static int net_failover_slave_link_change(struct net_device *slave_dev,
 638                                           struct net_device *failover_dev)
 639 {
 640         struct net_device *primary_dev, *standby_dev;
 641         struct net_failover_info *nfo_info;
 642
 643         nfo_info = netdev_priv(failover_dev);
 644
 645         primary_dev = rtnl_dereference(nfo_info->primary_dev);
 646         standby_dev = rtnl_dereference(nfo_info->standby_dev);
 647
 648         if (slave_dev != primary_dev && slave_dev != standby_dev)
 649                 return -ENODEV;
 650
 651         if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
 652             (standby_dev && net_failover_xmit_ready(standby_dev))) {
 653                 netif_carrier_on(failover_dev);
 654                 netif_tx_wake_all_queues(failover_dev);
 655         } else {
 656                 dev_get_stats(failover_dev, &nfo_info->failover_stats);
 657                 netif_carrier_off(failover_dev);
 658                 netif_tx_stop_all_queues(failover_dev);
 659         }
 660
 661         net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
 662
 663         return 0;
 664 }
 665
 666 static int net_failover_slave_name_change(struct net_device *slave_dev,
 667                                           struct net_device *failover_dev)
 668 {
 669         struct net_device *primary_dev, *standby_dev;
 670         struct net_failover_info *nfo_info;
 671
 672         nfo_info = netdev_priv(failover_dev);
 673
 674         primary_dev = rtnl_dereference(nfo_info->primary_dev);
 675         standby_dev = rtnl_dereference(nfo_info->standby_dev);
 676
 677         if (slave_dev != primary_dev && slave_dev != standby_dev)
 678                 return -ENODEV;
 679
 680         /* We need to bring up the slave after the rename by udev in case
 681          * open failed with EBUSY when it was registered.
 682          */
 683         dev_open(slave_dev);
 684
 685         return 0;
 686 }
 687
 688 static struct failover_ops net_failover_ops = {
 689         .slave_pre_register     = net_failover_slave_pre_register,
 690         .slave_register         = net_failover_slave_register,
 691         .slave_pre_unregister   = net_failover_slave_pre_unregister,
 692         .slave_unregister       = net_failover_slave_unregister,
 693         .slave_link_change      = net_failover_slave_link_change,
 694         .slave_name_change      = net_failover_slave_name_change,
 695         .slave_handle_frame     = net_failover_handle_frame,
 696 };
 697
 698 /**
 699  * net_failover_create - Create and register a failover instance
 700  *
 701  * @dev: standby netdev
 702  *
 703  * Creates a failover netdev and registers a failover instance for a standby
 704  * netdev. Used by paravirtual drivers that use 3-netdev model.
 705  * The failover netdev acts as a master device and controls 2 slave devices -
 706  * the original standby netdev and a VF netdev with the same MAC gets
 707  * registered as primary netdev.
 708  *
 709  * Return: pointer to failover instance
 710  */
 711 struct failover *net_failover_create(struct net_device *standby_dev)
 712 {
 713         struct device *dev = standby_dev->dev.parent;
 714         struct net_device *failover_dev;
 715         struct failover *failover;
 716         int err;
 717
 718         /* Alloc at least 2 queues, for now we are going with 16 assuming
 719          * that VF devices being enslaved won't have too many queues.
 720          */
 721         failover_dev = alloc_etherdev_mq(sizeof(struct net_failover_info), 16);
 722         if (!failover_dev) {
 723                 dev_err(dev, "Unable to allocate failover_netdev!\n");
 724                 return ERR_PTR(-ENOMEM);
 725         }
 726
 727         dev_net_set(failover_dev, dev_net(standby_dev));
 728         SET_NETDEV_DEV(failover_dev, dev);
 729
 730         failover_dev->netdev_ops = &failover_dev_ops;
 731         failover_dev->ethtool_ops = &failover_ethtool_ops;
 732
 733         /* Initialize the device options */
 734         failover_dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE;
 735         failover_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE |
 736                                        IFF_TX_SKB_SHARING);
 737
 738         /* don't acquire failover netdev's netif_tx_lock when transmitting */
 739         failover_dev->features |= NETIF_F_LLTX;
 740
 741         /* Don't allow failover devices to change network namespaces. */
 742         failover_dev->features |= NETIF_F_NETNS_LOCAL;
 743
 744         failover_dev->hw_features = FAILOVER_VLAN_FEATURES |
 745                                     NETIF_F_HW_VLAN_CTAG_TX |
 746                                     NETIF_F_HW_VLAN_CTAG_RX |
 747                                     NETIF_F_HW_VLAN_CTAG_FILTER;
 748
 749         failover_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
 750         failover_dev->features |= failover_dev->hw_features;
 751
 752         memcpy(failover_dev->dev_addr, standby_dev->dev_addr,
 753                failover_dev->addr_len);
 754
 755         failover_dev->min_mtu = standby_dev->min_mtu;
 756         failover_dev->max_mtu = standby_dev->max_mtu;
 757
 758         err = register_netdev(failover_dev);
 759         if (err) {
 760                 dev_err(dev, "Unable to register failover_dev!\n");
 761                 goto err_register_netdev;
 762         }
 763
 764         netif_carrier_off(failover_dev);
 765
 766         failover = failover_register(failover_dev, &net_failover_ops);
 767         if (IS_ERR(failover)) {
 768                 err = PTR_ERR(failover);
 769                 goto err_failover_register;
 770         }
 771
 772         return failover;
 773
 774 err_failover_register:
 775         unregister_netdev(failover_dev);
 776 err_register_netdev:
 777         free_netdev(failover_dev);
 778
 779         return ERR_PTR(err);
 780 }
 781 EXPORT_SYMBOL_GPL(net_failover_create);
 782
 783 /**
 784  * net_failover_destroy - Destroy a failover instance
 785  *
 786  * @failover: pointer to failover instance
 787  *
 788  * Unregisters any slave netdevs associated with the failover instance by
 789  * calling failover_slave_unregister().
 790  * unregisters the failover instance itself and finally frees the failover
 791  * netdev. Used by paravirtual drivers that use 3-netdev model.
 792  *
 793  */
 794 void net_failover_destroy(struct failover *failover)
 795 {
 796         struct net_failover_info *nfo_info;
 797         struct net_device *failover_dev;
 798         struct net_device *slave_dev;
 799
 800         if (!failover)
 801                 return;
 802
 803         failover_dev = rcu_dereference(failover->failover_dev);
 804         nfo_info = netdev_priv(failover_dev);
 805
 806         netif_device_detach(failover_dev);
 807
 808         rtnl_lock();
 809
 810         slave_dev = rtnl_dereference(nfo_info->primary_dev);
 811         if (slave_dev)
 812                 failover_slave_unregister(slave_dev);
 813
 814         slave_dev = rtnl_dereference(nfo_info->standby_dev);
 815         if (slave_dev)
 816                 failover_slave_unregister(slave_dev);
 817
 818         failover_unregister(failover);
 819
 820         unregister_netdevice(failover_dev);
 821
 822         rtnl_unlock();
 823
 824         free_netdev(failover_dev);
 825 }
 826 EXPORT_SYMBOL_GPL(net_failover_destroy);
 827
 828 static __init int
 829 net_failover_init(void)
 830 {
 831         return 0;
 832 }
 833 module_init(net_failover_init);
 834
 835 static __exit
 836 void net_failover_exit(void)
 837 {
 838 }
 839 module_exit(net_failover_exit);
 840
 841 MODULE_DESCRIPTION("Failover driver for Paravirtual drivers");
 842 MODULE_LICENSE("GPL v2");