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