Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2018, Intel Corporation. */
0003 
0004 /* This provides a net_failover interface for paravirtual drivers to
0005  * provide an alternate datapath by exporting APIs to create and
0006  * destroy a upper 'net_failover' netdev. The upper dev manages the
0007  * original paravirtual interface as a 'standby' netdev and uses the
0008  * generic failover infrastructure to register and manage a direct
0009  * attached VF as a 'primary' netdev. This enables live migration of
0010  * a VM with direct attached VF by failing over to the paravirtual
0011  * datapath when the VF is unplugged.
0012  *
0013  * Some of the netdev management routines are based on bond/team driver as
0014  * this driver provides active-backup functionality similar to those drivers.
0015  */
0016 
0017 #include <linux/netdevice.h>
0018 #include <linux/etherdevice.h>
0019 #include <linux/ethtool.h>
0020 #include <linux/module.h>
0021 #include <linux/slab.h>
0022 #include <linux/netpoll.h>
0023 #include <linux/rtnetlink.h>
0024 #include <linux/if_vlan.h>
0025 #include <linux/pci.h>
0026 #include <net/sch_generic.h>
0027 #include <uapi/linux/if_arp.h>
0028 #include <net/net_failover.h>
0029 
0030 static bool net_failover_xmit_ready(struct net_device *dev)
0031 {
0032     return netif_running(dev) && netif_carrier_ok(dev);
0033 }
0034 
0035 static int net_failover_open(struct net_device *dev)
0036 {
0037     struct net_failover_info *nfo_info = netdev_priv(dev);
0038     struct net_device *primary_dev, *standby_dev;
0039     int err;
0040 
0041     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0042     if (primary_dev) {
0043         err = dev_open(primary_dev, NULL);
0044         if (err)
0045             goto err_primary_open;
0046     }
0047 
0048     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0049     if (standby_dev) {
0050         err = dev_open(standby_dev, NULL);
0051         if (err)
0052             goto err_standby_open;
0053     }
0054 
0055     if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
0056         (standby_dev && net_failover_xmit_ready(standby_dev))) {
0057         netif_carrier_on(dev);
0058         netif_tx_wake_all_queues(dev);
0059     }
0060 
0061     return 0;
0062 
0063 err_standby_open:
0064     if (primary_dev)
0065         dev_close(primary_dev);
0066 err_primary_open:
0067     netif_tx_disable(dev);
0068     return err;
0069 }
0070 
0071 static int net_failover_close(struct net_device *dev)
0072 {
0073     struct net_failover_info *nfo_info = netdev_priv(dev);
0074     struct net_device *slave_dev;
0075 
0076     netif_tx_disable(dev);
0077 
0078     slave_dev = rtnl_dereference(nfo_info->primary_dev);
0079     if (slave_dev)
0080         dev_close(slave_dev);
0081 
0082     slave_dev = rtnl_dereference(nfo_info->standby_dev);
0083     if (slave_dev)
0084         dev_close(slave_dev);
0085 
0086     return 0;
0087 }
0088 
0089 static netdev_tx_t net_failover_drop_xmit(struct sk_buff *skb,
0090                       struct net_device *dev)
0091 {
0092     dev_core_stats_tx_dropped_inc(dev);
0093     dev_kfree_skb_any(skb);
0094     return NETDEV_TX_OK;
0095 }
0096 
0097 static netdev_tx_t net_failover_start_xmit(struct sk_buff *skb,
0098                        struct net_device *dev)
0099 {
0100     struct net_failover_info *nfo_info = netdev_priv(dev);
0101     struct net_device *xmit_dev;
0102 
0103     /* Try xmit via primary netdev followed by standby netdev */
0104     xmit_dev = rcu_dereference_bh(nfo_info->primary_dev);
0105     if (!xmit_dev || !net_failover_xmit_ready(xmit_dev)) {
0106         xmit_dev = rcu_dereference_bh(nfo_info->standby_dev);
0107         if (!xmit_dev || !net_failover_xmit_ready(xmit_dev))
0108             return net_failover_drop_xmit(skb, dev);
0109     }
0110 
0111     skb->dev = xmit_dev;
0112     skb->queue_mapping = qdisc_skb_cb(skb)->slave_dev_queue_mapping;
0113 
0114     return dev_queue_xmit(skb);
0115 }
0116 
0117 static u16 net_failover_select_queue(struct net_device *dev,
0118                      struct sk_buff *skb,
0119                      struct net_device *sb_dev)
0120 {
0121     struct net_failover_info *nfo_info = netdev_priv(dev);
0122     struct net_device *primary_dev;
0123     u16 txq;
0124 
0125     primary_dev = rcu_dereference(nfo_info->primary_dev);
0126     if (primary_dev) {
0127         const struct net_device_ops *ops = primary_dev->netdev_ops;
0128 
0129         if (ops->ndo_select_queue)
0130             txq = ops->ndo_select_queue(primary_dev, skb, sb_dev);
0131         else
0132             txq = netdev_pick_tx(primary_dev, skb, NULL);
0133 
0134         qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
0135 
0136         return txq;
0137     }
0138 
0139     txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
0140 
0141     /* Save the original txq to restore before passing to the driver */
0142     qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
0143 
0144     if (unlikely(txq >= dev->real_num_tx_queues)) {
0145         do {
0146             txq -= dev->real_num_tx_queues;
0147         } while (txq >= dev->real_num_tx_queues);
0148     }
0149 
0150     return txq;
0151 }
0152 
0153 /* fold stats, assuming all rtnl_link_stats64 fields are u64, but
0154  * that some drivers can provide 32bit values only.
0155  */
0156 static void net_failover_fold_stats(struct rtnl_link_stats64 *_res,
0157                     const struct rtnl_link_stats64 *_new,
0158                     const struct rtnl_link_stats64 *_old)
0159 {
0160     const u64 *new = (const u64 *)_new;
0161     const u64 *old = (const u64 *)_old;
0162     u64 *res = (u64 *)_res;
0163     int i;
0164 
0165     for (i = 0; i < sizeof(*_res) / sizeof(u64); i++) {
0166         u64 nv = new[i];
0167         u64 ov = old[i];
0168         s64 delta = nv - ov;
0169 
0170         /* detects if this particular field is 32bit only */
0171         if (((nv | ov) >> 32) == 0)
0172             delta = (s64)(s32)((u32)nv - (u32)ov);
0173 
0174         /* filter anomalies, some drivers reset their stats
0175          * at down/up events.
0176          */
0177         if (delta > 0)
0178             res[i] += delta;
0179     }
0180 }
0181 
0182 static void net_failover_get_stats(struct net_device *dev,
0183                    struct rtnl_link_stats64 *stats)
0184 {
0185     struct net_failover_info *nfo_info = netdev_priv(dev);
0186     const struct rtnl_link_stats64 *new;
0187     struct rtnl_link_stats64 temp;
0188     struct net_device *slave_dev;
0189 
0190     spin_lock(&nfo_info->stats_lock);
0191     memcpy(stats, &nfo_info->failover_stats, sizeof(*stats));
0192 
0193     rcu_read_lock();
0194 
0195     slave_dev = rcu_dereference(nfo_info->primary_dev);
0196     if (slave_dev) {
0197         new = dev_get_stats(slave_dev, &temp);
0198         net_failover_fold_stats(stats, new, &nfo_info->primary_stats);
0199         memcpy(&nfo_info->primary_stats, new, sizeof(*new));
0200     }
0201 
0202     slave_dev = rcu_dereference(nfo_info->standby_dev);
0203     if (slave_dev) {
0204         new = dev_get_stats(slave_dev, &temp);
0205         net_failover_fold_stats(stats, new, &nfo_info->standby_stats);
0206         memcpy(&nfo_info->standby_stats, new, sizeof(*new));
0207     }
0208 
0209     rcu_read_unlock();
0210 
0211     memcpy(&nfo_info->failover_stats, stats, sizeof(*stats));
0212     spin_unlock(&nfo_info->stats_lock);
0213 }
0214 
0215 static int net_failover_change_mtu(struct net_device *dev, int new_mtu)
0216 {
0217     struct net_failover_info *nfo_info = netdev_priv(dev);
0218     struct net_device *primary_dev, *standby_dev;
0219     int ret = 0;
0220 
0221     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0222     if (primary_dev) {
0223         ret = dev_set_mtu(primary_dev, new_mtu);
0224         if (ret)
0225             return ret;
0226     }
0227 
0228     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0229     if (standby_dev) {
0230         ret = dev_set_mtu(standby_dev, new_mtu);
0231         if (ret) {
0232             if (primary_dev)
0233                 dev_set_mtu(primary_dev, dev->mtu);
0234             return ret;
0235         }
0236     }
0237 
0238     dev->mtu = new_mtu;
0239 
0240     return 0;
0241 }
0242 
0243 static void net_failover_set_rx_mode(struct net_device *dev)
0244 {
0245     struct net_failover_info *nfo_info = netdev_priv(dev);
0246     struct net_device *slave_dev;
0247 
0248     rcu_read_lock();
0249 
0250     slave_dev = rcu_dereference(nfo_info->primary_dev);
0251     if (slave_dev) {
0252         dev_uc_sync_multiple(slave_dev, dev);
0253         dev_mc_sync_multiple(slave_dev, dev);
0254     }
0255 
0256     slave_dev = rcu_dereference(nfo_info->standby_dev);
0257     if (slave_dev) {
0258         dev_uc_sync_multiple(slave_dev, dev);
0259         dev_mc_sync_multiple(slave_dev, dev);
0260     }
0261 
0262     rcu_read_unlock();
0263 }
0264 
0265 static int net_failover_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
0266                     u16 vid)
0267 {
0268     struct net_failover_info *nfo_info = netdev_priv(dev);
0269     struct net_device *primary_dev, *standby_dev;
0270     int ret = 0;
0271 
0272     primary_dev = rcu_dereference(nfo_info->primary_dev);
0273     if (primary_dev) {
0274         ret = vlan_vid_add(primary_dev, proto, vid);
0275         if (ret)
0276             return ret;
0277     }
0278 
0279     standby_dev = rcu_dereference(nfo_info->standby_dev);
0280     if (standby_dev) {
0281         ret = vlan_vid_add(standby_dev, proto, vid);
0282         if (ret)
0283             if (primary_dev)
0284                 vlan_vid_del(primary_dev, proto, vid);
0285     }
0286 
0287     return ret;
0288 }
0289 
0290 static int net_failover_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
0291                      u16 vid)
0292 {
0293     struct net_failover_info *nfo_info = netdev_priv(dev);
0294     struct net_device *slave_dev;
0295 
0296     slave_dev = rcu_dereference(nfo_info->primary_dev);
0297     if (slave_dev)
0298         vlan_vid_del(slave_dev, proto, vid);
0299 
0300     slave_dev = rcu_dereference(nfo_info->standby_dev);
0301     if (slave_dev)
0302         vlan_vid_del(slave_dev, proto, vid);
0303 
0304     return 0;
0305 }
0306 
0307 static const struct net_device_ops failover_dev_ops = {
0308     .ndo_open       = net_failover_open,
0309     .ndo_stop       = net_failover_close,
0310     .ndo_start_xmit     = net_failover_start_xmit,
0311     .ndo_select_queue   = net_failover_select_queue,
0312     .ndo_get_stats64    = net_failover_get_stats,
0313     .ndo_change_mtu     = net_failover_change_mtu,
0314     .ndo_set_rx_mode    = net_failover_set_rx_mode,
0315     .ndo_vlan_rx_add_vid    = net_failover_vlan_rx_add_vid,
0316     .ndo_vlan_rx_kill_vid   = net_failover_vlan_rx_kill_vid,
0317     .ndo_validate_addr  = eth_validate_addr,
0318     .ndo_features_check = passthru_features_check,
0319 };
0320 
0321 #define FAILOVER_NAME "net_failover"
0322 #define FAILOVER_VERSION "0.1"
0323 
0324 static void nfo_ethtool_get_drvinfo(struct net_device *dev,
0325                     struct ethtool_drvinfo *drvinfo)
0326 {
0327     strlcpy(drvinfo->driver, FAILOVER_NAME, sizeof(drvinfo->driver));
0328     strlcpy(drvinfo->version, FAILOVER_VERSION, sizeof(drvinfo->version));
0329 }
0330 
0331 static int nfo_ethtool_get_link_ksettings(struct net_device *dev,
0332                       struct ethtool_link_ksettings *cmd)
0333 {
0334     struct net_failover_info *nfo_info = netdev_priv(dev);
0335     struct net_device *slave_dev;
0336 
0337     slave_dev = rtnl_dereference(nfo_info->primary_dev);
0338     if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
0339         slave_dev = rtnl_dereference(nfo_info->standby_dev);
0340         if (!slave_dev || !net_failover_xmit_ready(slave_dev)) {
0341             cmd->base.duplex = DUPLEX_UNKNOWN;
0342             cmd->base.port = PORT_OTHER;
0343             cmd->base.speed = SPEED_UNKNOWN;
0344 
0345             return 0;
0346         }
0347     }
0348 
0349     return __ethtool_get_link_ksettings(slave_dev, cmd);
0350 }
0351 
0352 static const struct ethtool_ops failover_ethtool_ops = {
0353     .get_drvinfo            = nfo_ethtool_get_drvinfo,
0354     .get_link               = ethtool_op_get_link,
0355     .get_link_ksettings     = nfo_ethtool_get_link_ksettings,
0356 };
0357 
0358 /* Called when slave dev is injecting data into network stack.
0359  * Change the associated network device from lower dev to failover dev.
0360  * note: already called with rcu_read_lock
0361  */
0362 static rx_handler_result_t net_failover_handle_frame(struct sk_buff **pskb)
0363 {
0364     struct sk_buff *skb = *pskb;
0365     struct net_device *dev = rcu_dereference(skb->dev->rx_handler_data);
0366     struct net_failover_info *nfo_info = netdev_priv(dev);
0367     struct net_device *primary_dev, *standby_dev;
0368 
0369     primary_dev = rcu_dereference(nfo_info->primary_dev);
0370     standby_dev = rcu_dereference(nfo_info->standby_dev);
0371 
0372     if (primary_dev && skb->dev == standby_dev)
0373         return RX_HANDLER_EXACT;
0374 
0375     skb->dev = dev;
0376 
0377     return RX_HANDLER_ANOTHER;
0378 }
0379 
0380 static void net_failover_compute_features(struct net_device *dev)
0381 {
0382     netdev_features_t vlan_features = FAILOVER_VLAN_FEATURES &
0383                       NETIF_F_ALL_FOR_ALL;
0384     netdev_features_t enc_features  = FAILOVER_ENC_FEATURES;
0385     unsigned short max_hard_header_len = ETH_HLEN;
0386     unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE |
0387                     IFF_XMIT_DST_RELEASE_PERM;
0388     struct net_failover_info *nfo_info = netdev_priv(dev);
0389     struct net_device *primary_dev, *standby_dev;
0390 
0391     primary_dev = rcu_dereference(nfo_info->primary_dev);
0392     if (primary_dev) {
0393         vlan_features =
0394             netdev_increment_features(vlan_features,
0395                           primary_dev->vlan_features,
0396                           FAILOVER_VLAN_FEATURES);
0397         enc_features =
0398             netdev_increment_features(enc_features,
0399                           primary_dev->hw_enc_features,
0400                           FAILOVER_ENC_FEATURES);
0401 
0402         dst_release_flag &= primary_dev->priv_flags;
0403         if (primary_dev->hard_header_len > max_hard_header_len)
0404             max_hard_header_len = primary_dev->hard_header_len;
0405     }
0406 
0407     standby_dev = rcu_dereference(nfo_info->standby_dev);
0408     if (standby_dev) {
0409         vlan_features =
0410             netdev_increment_features(vlan_features,
0411                           standby_dev->vlan_features,
0412                           FAILOVER_VLAN_FEATURES);
0413         enc_features =
0414             netdev_increment_features(enc_features,
0415                           standby_dev->hw_enc_features,
0416                           FAILOVER_ENC_FEATURES);
0417 
0418         dst_release_flag &= standby_dev->priv_flags;
0419         if (standby_dev->hard_header_len > max_hard_header_len)
0420             max_hard_header_len = standby_dev->hard_header_len;
0421     }
0422 
0423     dev->vlan_features = vlan_features;
0424     dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL;
0425     dev->hard_header_len = max_hard_header_len;
0426 
0427     dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
0428     if (dst_release_flag == (IFF_XMIT_DST_RELEASE |
0429                  IFF_XMIT_DST_RELEASE_PERM))
0430         dev->priv_flags |= IFF_XMIT_DST_RELEASE;
0431 
0432     netdev_change_features(dev);
0433 }
0434 
0435 static void net_failover_lower_state_changed(struct net_device *slave_dev,
0436                          struct net_device *primary_dev,
0437                          struct net_device *standby_dev)
0438 {
0439     struct netdev_lag_lower_state_info info;
0440 
0441     if (netif_carrier_ok(slave_dev))
0442         info.link_up = true;
0443     else
0444         info.link_up = false;
0445 
0446     if (slave_dev == primary_dev) {
0447         if (netif_running(primary_dev))
0448             info.tx_enabled = true;
0449         else
0450             info.tx_enabled = false;
0451     } else {
0452         if ((primary_dev && netif_running(primary_dev)) ||
0453             (!netif_running(standby_dev)))
0454             info.tx_enabled = false;
0455         else
0456             info.tx_enabled = true;
0457     }
0458 
0459     netdev_lower_state_changed(slave_dev, &info);
0460 }
0461 
0462 static int net_failover_slave_pre_register(struct net_device *slave_dev,
0463                        struct net_device *failover_dev)
0464 {
0465     struct net_device *standby_dev, *primary_dev;
0466     struct net_failover_info *nfo_info;
0467     bool slave_is_standby;
0468 
0469     nfo_info = netdev_priv(failover_dev);
0470     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0471     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0472     slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
0473     if (slave_is_standby ? standby_dev : primary_dev) {
0474         netdev_err(failover_dev, "%s attempting to register as slave dev when %s already present\n",
0475                slave_dev->name,
0476                slave_is_standby ? "standby" : "primary");
0477         return -EINVAL;
0478     }
0479 
0480     /* We want to allow only a direct attached VF device as a primary
0481      * netdev. As there is no easy way to check for a VF device, restrict
0482      * this to a pci device.
0483      */
0484     if (!slave_is_standby && (!slave_dev->dev.parent ||
0485                   !dev_is_pci(slave_dev->dev.parent)))
0486         return -EINVAL;
0487 
0488     if (failover_dev->features & NETIF_F_VLAN_CHALLENGED &&
0489         vlan_uses_dev(failover_dev)) {
0490         netdev_err(failover_dev, "Device %s is VLAN challenged and failover device has VLAN set up\n",
0491                failover_dev->name);
0492         return -EINVAL;
0493     }
0494 
0495     return 0;
0496 }
0497 
0498 static int net_failover_slave_register(struct net_device *slave_dev,
0499                        struct net_device *failover_dev)
0500 {
0501     struct net_device *standby_dev, *primary_dev;
0502     struct net_failover_info *nfo_info;
0503     bool slave_is_standby;
0504     u32 orig_mtu;
0505     int err;
0506 
0507     /* Align MTU of slave with failover dev */
0508     orig_mtu = slave_dev->mtu;
0509     err = dev_set_mtu(slave_dev, failover_dev->mtu);
0510     if (err) {
0511         netdev_err(failover_dev, "unable to change mtu of %s to %u register failed\n",
0512                slave_dev->name, failover_dev->mtu);
0513         goto done;
0514     }
0515 
0516     dev_hold(slave_dev);
0517 
0518     if (netif_running(failover_dev)) {
0519         err = dev_open(slave_dev, NULL);
0520         if (err && (err != -EBUSY)) {
0521             netdev_err(failover_dev, "Opening slave %s failed err:%d\n",
0522                    slave_dev->name, err);
0523             goto err_dev_open;
0524         }
0525     }
0526 
0527     netif_addr_lock_bh(failover_dev);
0528     dev_uc_sync_multiple(slave_dev, failover_dev);
0529     dev_mc_sync_multiple(slave_dev, failover_dev);
0530     netif_addr_unlock_bh(failover_dev);
0531 
0532     err = vlan_vids_add_by_dev(slave_dev, failover_dev);
0533     if (err) {
0534         netdev_err(failover_dev, "Failed to add vlan ids to device %s err:%d\n",
0535                slave_dev->name, err);
0536         goto err_vlan_add;
0537     }
0538 
0539     nfo_info = netdev_priv(failover_dev);
0540     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0541     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0542     slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
0543 
0544     if (slave_is_standby) {
0545         rcu_assign_pointer(nfo_info->standby_dev, slave_dev);
0546         standby_dev = slave_dev;
0547         dev_get_stats(standby_dev, &nfo_info->standby_stats);
0548     } else {
0549         rcu_assign_pointer(nfo_info->primary_dev, slave_dev);
0550         primary_dev = slave_dev;
0551         dev_get_stats(primary_dev, &nfo_info->primary_stats);
0552         failover_dev->min_mtu = slave_dev->min_mtu;
0553         failover_dev->max_mtu = slave_dev->max_mtu;
0554     }
0555 
0556     net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
0557     net_failover_compute_features(failover_dev);
0558 
0559     call_netdevice_notifiers(NETDEV_JOIN, slave_dev);
0560 
0561     netdev_info(failover_dev, "failover %s slave:%s registered\n",
0562             slave_is_standby ? "standby" : "primary", slave_dev->name);
0563 
0564     return 0;
0565 
0566 err_vlan_add:
0567     dev_uc_unsync(slave_dev, failover_dev);
0568     dev_mc_unsync(slave_dev, failover_dev);
0569     dev_close(slave_dev);
0570 err_dev_open:
0571     dev_put(slave_dev);
0572     dev_set_mtu(slave_dev, orig_mtu);
0573 done:
0574     return err;
0575 }
0576 
0577 static int net_failover_slave_pre_unregister(struct net_device *slave_dev,
0578                          struct net_device *failover_dev)
0579 {
0580     struct net_device *standby_dev, *primary_dev;
0581     struct net_failover_info *nfo_info;
0582 
0583     nfo_info = netdev_priv(failover_dev);
0584     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0585     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0586 
0587     if (slave_dev != primary_dev && slave_dev != standby_dev)
0588         return -ENODEV;
0589 
0590     return 0;
0591 }
0592 
0593 static int net_failover_slave_unregister(struct net_device *slave_dev,
0594                      struct net_device *failover_dev)
0595 {
0596     struct net_device *standby_dev, *primary_dev;
0597     struct net_failover_info *nfo_info;
0598     bool slave_is_standby;
0599 
0600     nfo_info = netdev_priv(failover_dev);
0601     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0602     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0603 
0604     if (WARN_ON_ONCE(slave_dev != primary_dev && slave_dev != standby_dev))
0605         return -ENODEV;
0606 
0607     vlan_vids_del_by_dev(slave_dev, failover_dev);
0608     dev_uc_unsync(slave_dev, failover_dev);
0609     dev_mc_unsync(slave_dev, failover_dev);
0610     dev_close(slave_dev);
0611 
0612     nfo_info = netdev_priv(failover_dev);
0613     dev_get_stats(failover_dev, &nfo_info->failover_stats);
0614 
0615     slave_is_standby = slave_dev->dev.parent == failover_dev->dev.parent;
0616     if (slave_is_standby) {
0617         RCU_INIT_POINTER(nfo_info->standby_dev, NULL);
0618     } else {
0619         RCU_INIT_POINTER(nfo_info->primary_dev, NULL);
0620         if (standby_dev) {
0621             failover_dev->min_mtu = standby_dev->min_mtu;
0622             failover_dev->max_mtu = standby_dev->max_mtu;
0623         }
0624     }
0625 
0626     dev_put(slave_dev);
0627 
0628     net_failover_compute_features(failover_dev);
0629 
0630     netdev_info(failover_dev, "failover %s slave:%s unregistered\n",
0631             slave_is_standby ? "standby" : "primary", slave_dev->name);
0632 
0633     return 0;
0634 }
0635 
0636 static int net_failover_slave_link_change(struct net_device *slave_dev,
0637                       struct net_device *failover_dev)
0638 {
0639     struct net_device *primary_dev, *standby_dev;
0640     struct net_failover_info *nfo_info;
0641 
0642     nfo_info = netdev_priv(failover_dev);
0643 
0644     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0645     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0646 
0647     if (slave_dev != primary_dev && slave_dev != standby_dev)
0648         return -ENODEV;
0649 
0650     if ((primary_dev && net_failover_xmit_ready(primary_dev)) ||
0651         (standby_dev && net_failover_xmit_ready(standby_dev))) {
0652         netif_carrier_on(failover_dev);
0653         netif_tx_wake_all_queues(failover_dev);
0654     } else {
0655         dev_get_stats(failover_dev, &nfo_info->failover_stats);
0656         netif_carrier_off(failover_dev);
0657         netif_tx_stop_all_queues(failover_dev);
0658     }
0659 
0660     net_failover_lower_state_changed(slave_dev, primary_dev, standby_dev);
0661 
0662     return 0;
0663 }
0664 
0665 static int net_failover_slave_name_change(struct net_device *slave_dev,
0666                       struct net_device *failover_dev)
0667 {
0668     struct net_device *primary_dev, *standby_dev;
0669     struct net_failover_info *nfo_info;
0670 
0671     nfo_info = netdev_priv(failover_dev);
0672 
0673     primary_dev = rtnl_dereference(nfo_info->primary_dev);
0674     standby_dev = rtnl_dereference(nfo_info->standby_dev);
0675 
0676     if (slave_dev != primary_dev && slave_dev != standby_dev)
0677         return -ENODEV;
0678 
0679     /* We need to bring up the slave after the rename by udev in case
0680      * open failed with EBUSY when it was registered.
0681      */
0682     dev_open(slave_dev, NULL);
0683 
0684     return 0;
0685 }
0686 
0687 static struct failover_ops net_failover_ops = {
0688     .slave_pre_register = net_failover_slave_pre_register,
0689     .slave_register     = net_failover_slave_register,
0690     .slave_pre_unregister   = net_failover_slave_pre_unregister,
0691     .slave_unregister   = net_failover_slave_unregister,
0692     .slave_link_change  = net_failover_slave_link_change,
0693     .slave_name_change  = net_failover_slave_name_change,
0694     .slave_handle_frame = net_failover_handle_frame,
0695 };
0696 
0697 /**
0698  * net_failover_create - Create and register a failover instance
0699  *
0700  * @standby_dev: standby netdev
0701  *
0702  * Creates a failover netdev and registers a failover instance for a standby
0703  * netdev. Used by paravirtual drivers that use 3-netdev model.
0704  * The failover netdev acts as a master device and controls 2 slave devices -
0705  * the original standby netdev and a VF netdev with the same MAC gets
0706  * registered as primary netdev.
0707  *
0708  * Return: pointer to failover instance
0709  */
0710 struct failover *net_failover_create(struct net_device *standby_dev)
0711 {
0712     struct device *dev = standby_dev->dev.parent;
0713     struct net_device *failover_dev;
0714     struct failover *failover;
0715     int err;
0716 
0717     /* Alloc at least 2 queues, for now we are going with 16 assuming
0718      * that VF devices being enslaved won't have too many queues.
0719      */
0720     failover_dev = alloc_etherdev_mq(sizeof(struct net_failover_info), 16);
0721     if (!failover_dev) {
0722         dev_err(dev, "Unable to allocate failover_netdev!\n");
0723         return ERR_PTR(-ENOMEM);
0724     }
0725 
0726     dev_net_set(failover_dev, dev_net(standby_dev));
0727     SET_NETDEV_DEV(failover_dev, dev);
0728 
0729     failover_dev->netdev_ops = &failover_dev_ops;
0730     failover_dev->ethtool_ops = &failover_ethtool_ops;
0731 
0732     /* Initialize the device options */
0733     failover_dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE;
0734     failover_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE |
0735                        IFF_TX_SKB_SHARING);
0736 
0737     /* don't acquire failover netdev's netif_tx_lock when transmitting */
0738     failover_dev->features |= NETIF_F_LLTX;
0739 
0740     /* Don't allow failover devices to change network namespaces. */
0741     failover_dev->features |= NETIF_F_NETNS_LOCAL;
0742 
0743     failover_dev->hw_features = FAILOVER_VLAN_FEATURES |
0744                     NETIF_F_HW_VLAN_CTAG_TX |
0745                     NETIF_F_HW_VLAN_CTAG_RX |
0746                     NETIF_F_HW_VLAN_CTAG_FILTER;
0747 
0748     failover_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
0749     failover_dev->features |= failover_dev->hw_features;
0750 
0751     dev_addr_set(failover_dev, standby_dev->dev_addr);
0752 
0753     failover_dev->min_mtu = standby_dev->min_mtu;
0754     failover_dev->max_mtu = standby_dev->max_mtu;
0755 
0756     err = register_netdev(failover_dev);
0757     if (err) {
0758         dev_err(dev, "Unable to register failover_dev!\n");
0759         goto err_register_netdev;
0760     }
0761 
0762     netif_carrier_off(failover_dev);
0763 
0764     failover = failover_register(failover_dev, &net_failover_ops);
0765     if (IS_ERR(failover)) {
0766         err = PTR_ERR(failover);
0767         goto err_failover_register;
0768     }
0769 
0770     return failover;
0771 
0772 err_failover_register:
0773     unregister_netdev(failover_dev);
0774 err_register_netdev:
0775     free_netdev(failover_dev);
0776 
0777     return ERR_PTR(err);
0778 }
0779 EXPORT_SYMBOL_GPL(net_failover_create);
0780 
0781 /**
0782  * net_failover_destroy - Destroy a failover instance
0783  *
0784  * @failover: pointer to failover instance
0785  *
0786  * Unregisters any slave netdevs associated with the failover instance by
0787  * calling failover_slave_unregister().
0788  * unregisters the failover instance itself and finally frees the failover
0789  * netdev. Used by paravirtual drivers that use 3-netdev model.
0790  *
0791  */
0792 void net_failover_destroy(struct failover *failover)
0793 {
0794     struct net_failover_info *nfo_info;
0795     struct net_device *failover_dev;
0796     struct net_device *slave_dev;
0797 
0798     if (!failover)
0799         return;
0800 
0801     failover_dev = rcu_dereference(failover->failover_dev);
0802     nfo_info = netdev_priv(failover_dev);
0803 
0804     netif_device_detach(failover_dev);
0805 
0806     rtnl_lock();
0807 
0808     slave_dev = rtnl_dereference(nfo_info->primary_dev);
0809     if (slave_dev)
0810         failover_slave_unregister(slave_dev);
0811 
0812     slave_dev = rtnl_dereference(nfo_info->standby_dev);
0813     if (slave_dev)
0814         failover_slave_unregister(slave_dev);
0815 
0816     failover_unregister(failover);
0817 
0818     unregister_netdevice(failover_dev);
0819 
0820     rtnl_unlock();
0821 
0822     free_netdev(failover_dev);
0823 }
0824 EXPORT_SYMBOL_GPL(net_failover_destroy);
0825 
0826 static __init int
0827 net_failover_init(void)
0828 {
0829     return 0;
0830 }
0831 module_init(net_failover_init);
0832 
0833 static __exit
0834 void net_failover_exit(void)
0835 {
0836 }
0837 module_exit(net_failover_exit);
0838 
0839 MODULE_DESCRIPTION("Failover driver for Paravirtual drivers");
0840 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!