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