ipvtap.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. #include <linux/etherdevice.h>
  3. #include "ipvlan.h"
  4. #include <linux/if_vlan.h>
  5. #include <linux/if_tap.h>
  6. #include <linux/interrupt.h>
  7. #include <linux/nsproxy.h>
  8. #include <linux/compat.h>
  9. #include <linux/if_tun.h>
  10. #include <linux/module.h>
  11. #include <linux/skbuff.h>
  12. #include <linux/cache.h>
  13. #include <linux/sched.h>
  14. #include <linux/types.h>
  15. #include <linux/slab.h>
  16. #include <linux/wait.h>
  17. #include <linux/cdev.h>
  18. #include <linux/idr.h>
  19. #include <linux/fs.h>
  20. #include <linux/uio.h>
  21. #include <net/net_namespace.h>
  22. #include <net/rtnetlink.h>
  23. #include <net/sock.h>
  24. #include <linux/virtio_net.h>
  25. #define TUN_OFFLOADS (NETIF_F_HW_CSUM | NETIF_F_TSO_ECN | NETIF_F_TSO | \
  26. NETIF_F_TSO6)
  27. static dev_t ipvtap_major;
  28. static struct cdev ipvtap_cdev;
  29. static const void *ipvtap_net_namespace(struct device *d)
  30. {
  31. struct net_device *dev = to_net_dev(d->parent);
  32. return dev_net(dev);
  33. }
  34. static struct class ipvtap_class = {
  35. .name = "ipvtap",
  36. .owner = THIS_MODULE,
  37. .ns_type = &net_ns_type_operations,
  38. .namespace = ipvtap_net_namespace,
  39. };
  40. struct ipvtap_dev {
  41. struct ipvl_dev vlan;
  42. struct tap_dev tap;
  43. };
  44. static void ipvtap_count_tx_dropped(struct tap_dev *tap)
  45. {
  46. struct ipvtap_dev *vlantap = container_of(tap, struct ipvtap_dev, tap);
  47. struct ipvl_dev *vlan = &vlantap->vlan;
  48. this_cpu_inc(vlan->pcpu_stats->tx_drps);
  49. }
  50. static void ipvtap_count_rx_dropped(struct tap_dev *tap)
  51. {
  52. struct ipvtap_dev *vlantap = container_of(tap, struct ipvtap_dev, tap);
  53. struct ipvl_dev *vlan = &vlantap->vlan;
  54. ipvlan_count_rx(vlan, 0, 0, 0);
  55. }
  56. static void ipvtap_update_features(struct tap_dev *tap,
  57. netdev_features_t features)
  58. {
  59. struct ipvtap_dev *vlantap = container_of(tap, struct ipvtap_dev, tap);
  60. struct ipvl_dev *vlan = &vlantap->vlan;
  61. vlan->sfeatures = features;
  62. netdev_update_features(vlan->dev);
  63. }
  64. static int ipvtap_newlink(struct net *src_net, struct net_device *dev,
  65. struct nlattr *tb[], struct nlattr *data[],
  66. struct netlink_ext_ack *extack)
  67. {
  68. struct ipvtap_dev *vlantap = netdev_priv(dev);
  69. int err;
  70. INIT_LIST_HEAD(&vlantap->tap.queue_list);
  71. /* Since macvlan supports all offloads by default, make
  72. * tap support all offloads also.
  73. */
  74. vlantap->tap.tap_features = TUN_OFFLOADS;
  75. vlantap->tap.count_tx_dropped = ipvtap_count_tx_dropped;
  76. vlantap->tap.update_features = ipvtap_update_features;
  77. vlantap->tap.count_rx_dropped = ipvtap_count_rx_dropped;
  78. err = netdev_rx_handler_register(dev, tap_handle_frame, &vlantap->tap);
  79. if (err)
  80. return err;
  81. /* Don't put anything that may fail after macvlan_common_newlink
  82. * because we can't undo what it does.
  83. */
  84. err = ipvlan_link_new(src_net, dev, tb, data, extack);
  85. if (err) {
  86. netdev_rx_handler_unregister(dev);
  87. return err;
  88. }
  89. vlantap->tap.dev = vlantap->vlan.dev;
  90. return err;
  91. }
  92. static void ipvtap_dellink(struct net_device *dev,
  93. struct list_head *head)
  94. {
  95. struct ipvtap_dev *vlan = netdev_priv(dev);
  96. netdev_rx_handler_unregister(dev);
  97. tap_del_queues(&vlan->tap);
  98. ipvlan_link_delete(dev, head);
  99. }
  100. static void ipvtap_setup(struct net_device *dev)
  101. {
  102. ipvlan_link_setup(dev);
  103. dev->tx_queue_len = TUN_READQ_SIZE;
  104. dev->priv_flags &= ~IFF_NO_QUEUE;
  105. }
  106. static struct rtnl_link_ops ipvtap_link_ops __read_mostly = {
  107. .kind = "ipvtap",
  108. .setup = ipvtap_setup,
  109. .newlink = ipvtap_newlink,
  110. .dellink = ipvtap_dellink,
  111. .priv_size = sizeof(struct ipvtap_dev),
  112. };
  113. static int ipvtap_device_event(struct notifier_block *unused,
  114. unsigned long event, void *ptr)
  115. {
  116. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  117. struct ipvtap_dev *vlantap;
  118. struct device *classdev;
  119. dev_t devt;
  120. int err;
  121. char tap_name[IFNAMSIZ];
  122. if (dev->rtnl_link_ops != &ipvtap_link_ops)
  123. return NOTIFY_DONE;
  124. snprintf(tap_name, IFNAMSIZ, "tap%d", dev->ifindex);
  125. vlantap = netdev_priv(dev);
  126. switch (event) {
  127. case NETDEV_REGISTER:
  128. /* Create the device node here after the network device has
  129. * been registered but before register_netdevice has
  130. * finished running.
  131. */
  132. err = tap_get_minor(ipvtap_major, &vlantap->tap);
  133. if (err)
  134. return notifier_from_errno(err);
  135. devt = MKDEV(MAJOR(ipvtap_major), vlantap->tap.minor);
  136. classdev = device_create(&ipvtap_class, &dev->dev, devt,
  137. dev, tap_name);
  138. if (IS_ERR(classdev)) {
  139. tap_free_minor(ipvtap_major, &vlantap->tap);
  140. return notifier_from_errno(PTR_ERR(classdev));
  141. }
  142. err = sysfs_create_link(&dev->dev.kobj, &classdev->kobj,
  143. tap_name);
  144. if (err)
  145. return notifier_from_errno(err);
  146. break;
  147. case NETDEV_UNREGISTER:
  148. /* vlan->minor == 0 if NETDEV_REGISTER above failed */
  149. if (vlantap->tap.minor == 0)
  150. break;
  151. sysfs_remove_link(&dev->dev.kobj, tap_name);
  152. devt = MKDEV(MAJOR(ipvtap_major), vlantap->tap.minor);
  153. device_destroy(&ipvtap_class, devt);
  154. tap_free_minor(ipvtap_major, &vlantap->tap);
  155. break;
  156. case NETDEV_CHANGE_TX_QUEUE_LEN:
  157. if (tap_queue_resize(&vlantap->tap))
  158. return NOTIFY_BAD;
  159. break;
  160. }
  161. return NOTIFY_DONE;
  162. }
  163. static struct notifier_block ipvtap_notifier_block __read_mostly = {
  164. .notifier_call = ipvtap_device_event,
  165. };
  166. static int ipvtap_init(void)
  167. {
  168. int err;
  169. err = tap_create_cdev(&ipvtap_cdev, &ipvtap_major, "ipvtap",
  170. THIS_MODULE);
  171. if (err)
  172. goto out1;
  173. err = class_register(&ipvtap_class);
  174. if (err)
  175. goto out2;
  176. err = register_netdevice_notifier(&ipvtap_notifier_block);
  177. if (err)
  178. goto out3;
  179. err = ipvlan_link_register(&ipvtap_link_ops);
  180. if (err)
  181. goto out4;
  182. return 0;
  183. out4:
  184. unregister_netdevice_notifier(&ipvtap_notifier_block);
  185. out3:
  186. class_unregister(&ipvtap_class);
  187. out2:
  188. tap_destroy_cdev(ipvtap_major, &ipvtap_cdev);
  189. out1:
  190. return err;
  191. }
  192. module_init(ipvtap_init);
  193. static void ipvtap_exit(void)
  194. {
  195. rtnl_link_unregister(&ipvtap_link_ops);
  196. unregister_netdevice_notifier(&ipvtap_notifier_block);
  197. class_unregister(&ipvtap_class);
  198. tap_destroy_cdev(ipvtap_major, &ipvtap_cdev);
  199. }
  200. module_exit(ipvtap_exit);
  201. MODULE_ALIAS_RTNL_LINK("ipvtap");
  202. MODULE_AUTHOR("Sainath Grandhi <sainath.grandhi@intel.com>");
  203. MODULE_LICENSE("GPL");