net_failover.c 23 KB

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