virtio_net.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546
  1. /* A simple network driver using virtio.
  2. *
  3. * Copyright 2007 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the Free Software
  17. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18. */
  19. //#define DEBUG
  20. #include <linux/netdevice.h>
  21. #include <linux/etherdevice.h>
  22. #include <linux/module.h>
  23. #include <linux/virtio.h>
  24. #include <linux/virtio_net.h>
  25. #include <linux/scatterlist.h>
  26. static int napi_weight = 128;
  27. module_param(napi_weight, int, 0444);
  28. static int csum = 1, gso = 1;
  29. module_param(csum, bool, 0444);
  30. module_param(gso, bool, 0444);
  31. /* FIXME: MTU in config. */
  32. #define MAX_PACKET_LEN (ETH_HLEN+ETH_DATA_LEN)
  33. struct virtnet_info
  34. {
  35. struct virtio_device *vdev;
  36. struct virtqueue *rvq, *svq;
  37. struct net_device *dev;
  38. struct napi_struct napi;
  39. /* The skb we couldn't send because buffers were full. */
  40. struct sk_buff *last_xmit_skb;
  41. /* Number of input buffers, and max we've ever had. */
  42. unsigned int num, max;
  43. /* For cleaning up after transmission. */
  44. struct tasklet_struct tasklet;
  45. /* Receive & send queues. */
  46. struct sk_buff_head recv;
  47. struct sk_buff_head send;
  48. };
  49. static inline struct virtio_net_hdr *skb_vnet_hdr(struct sk_buff *skb)
  50. {
  51. return (struct virtio_net_hdr *)skb->cb;
  52. }
  53. static inline void vnet_hdr_to_sg(struct scatterlist *sg, struct sk_buff *skb)
  54. {
  55. sg_init_one(sg, skb_vnet_hdr(skb), sizeof(struct virtio_net_hdr));
  56. }
  57. static void skb_xmit_done(struct virtqueue *svq)
  58. {
  59. struct virtnet_info *vi = svq->vdev->priv;
  60. /* Suppress further interrupts. */
  61. svq->vq_ops->disable_cb(svq);
  62. /* We were waiting for more output buffers. */
  63. netif_wake_queue(vi->dev);
  64. /* Make sure we re-xmit last_xmit_skb: if there are no more packets
  65. * queued, start_xmit won't be called. */
  66. tasklet_schedule(&vi->tasklet);
  67. }
  68. static void receive_skb(struct net_device *dev, struct sk_buff *skb,
  69. unsigned len)
  70. {
  71. struct virtio_net_hdr *hdr = skb_vnet_hdr(skb);
  72. if (unlikely(len < sizeof(struct virtio_net_hdr) + ETH_HLEN)) {
  73. pr_debug("%s: short packet %i\n", dev->name, len);
  74. dev->stats.rx_length_errors++;
  75. goto drop;
  76. }
  77. len -= sizeof(struct virtio_net_hdr);
  78. BUG_ON(len > MAX_PACKET_LEN);
  79. skb_trim(skb, len);
  80. dev->stats.rx_bytes += skb->len;
  81. dev->stats.rx_packets++;
  82. if (hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
  83. pr_debug("Needs csum!\n");
  84. if (!skb_partial_csum_set(skb,hdr->csum_start,hdr->csum_offset))
  85. goto frame_err;
  86. }
  87. skb->protocol = eth_type_trans(skb, dev);
  88. pr_debug("Receiving skb proto 0x%04x len %i type %i\n",
  89. ntohs(skb->protocol), skb->len, skb->pkt_type);
  90. if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
  91. pr_debug("GSO!\n");
  92. switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
  93. case VIRTIO_NET_HDR_GSO_TCPV4:
  94. skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
  95. break;
  96. case VIRTIO_NET_HDR_GSO_UDP:
  97. skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
  98. break;
  99. case VIRTIO_NET_HDR_GSO_TCPV6:
  100. skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
  101. break;
  102. default:
  103. if (net_ratelimit())
  104. printk(KERN_WARNING "%s: bad gso type %u.\n",
  105. dev->name, hdr->gso_type);
  106. goto frame_err;
  107. }
  108. if (hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN)
  109. skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
  110. skb_shinfo(skb)->gso_size = hdr->gso_size;
  111. if (skb_shinfo(skb)->gso_size == 0) {
  112. if (net_ratelimit())
  113. printk(KERN_WARNING "%s: zero gso size.\n",
  114. dev->name);
  115. goto frame_err;
  116. }
  117. /* Header must be checked, and gso_segs computed. */
  118. skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
  119. skb_shinfo(skb)->gso_segs = 0;
  120. }
  121. netif_receive_skb(skb);
  122. return;
  123. frame_err:
  124. dev->stats.rx_frame_errors++;
  125. drop:
  126. dev_kfree_skb(skb);
  127. }
  128. static void try_fill_recv(struct virtnet_info *vi)
  129. {
  130. struct sk_buff *skb;
  131. struct scatterlist sg[2+MAX_SKB_FRAGS];
  132. int num, err;
  133. sg_init_table(sg, 2+MAX_SKB_FRAGS);
  134. for (;;) {
  135. skb = netdev_alloc_skb(vi->dev, MAX_PACKET_LEN);
  136. if (unlikely(!skb))
  137. break;
  138. skb_put(skb, MAX_PACKET_LEN);
  139. vnet_hdr_to_sg(sg, skb);
  140. num = skb_to_sgvec(skb, sg+1, 0, skb->len) + 1;
  141. skb_queue_head(&vi->recv, skb);
  142. err = vi->rvq->vq_ops->add_buf(vi->rvq, sg, 0, num, skb);
  143. if (err) {
  144. skb_unlink(skb, &vi->recv);
  145. kfree_skb(skb);
  146. break;
  147. }
  148. vi->num++;
  149. }
  150. if (unlikely(vi->num > vi->max))
  151. vi->max = vi->num;
  152. vi->rvq->vq_ops->kick(vi->rvq);
  153. }
  154. static void skb_recv_done(struct virtqueue *rvq)
  155. {
  156. struct virtnet_info *vi = rvq->vdev->priv;
  157. /* Schedule NAPI, Suppress further interrupts if successful. */
  158. if (netif_rx_schedule_prep(vi->dev, &vi->napi)) {
  159. rvq->vq_ops->disable_cb(rvq);
  160. __netif_rx_schedule(vi->dev, &vi->napi);
  161. }
  162. }
  163. static int virtnet_poll(struct napi_struct *napi, int budget)
  164. {
  165. struct virtnet_info *vi = container_of(napi, struct virtnet_info, napi);
  166. struct sk_buff *skb = NULL;
  167. unsigned int len, received = 0;
  168. again:
  169. while (received < budget &&
  170. (skb = vi->rvq->vq_ops->get_buf(vi->rvq, &len)) != NULL) {
  171. __skb_unlink(skb, &vi->recv);
  172. receive_skb(vi->dev, skb, len);
  173. vi->num--;
  174. received++;
  175. }
  176. /* FIXME: If we oom and completely run out of inbufs, we need
  177. * to start a timer trying to fill more. */
  178. if (vi->num < vi->max / 2)
  179. try_fill_recv(vi);
  180. /* Out of packets? */
  181. if (received < budget) {
  182. netif_rx_complete(vi->dev, napi);
  183. if (unlikely(!vi->rvq->vq_ops->enable_cb(vi->rvq))
  184. && napi_schedule_prep(napi)) {
  185. vi->rvq->vq_ops->disable_cb(vi->rvq);
  186. __netif_rx_schedule(vi->dev, napi);
  187. goto again;
  188. }
  189. }
  190. return received;
  191. }
  192. static void free_old_xmit_skbs(struct virtnet_info *vi)
  193. {
  194. struct sk_buff *skb;
  195. unsigned int len;
  196. while ((skb = vi->svq->vq_ops->get_buf(vi->svq, &len)) != NULL) {
  197. pr_debug("Sent skb %p\n", skb);
  198. __skb_unlink(skb, &vi->send);
  199. vi->dev->stats.tx_bytes += skb->len;
  200. vi->dev->stats.tx_packets++;
  201. kfree_skb(skb);
  202. }
  203. }
  204. static int xmit_skb(struct virtnet_info *vi, struct sk_buff *skb)
  205. {
  206. int num;
  207. struct scatterlist sg[2+MAX_SKB_FRAGS];
  208. struct virtio_net_hdr *hdr;
  209. const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest;
  210. sg_init_table(sg, 2+MAX_SKB_FRAGS);
  211. pr_debug("%s: xmit %p " MAC_FMT "\n", vi->dev->name, skb,
  212. dest[0], dest[1], dest[2],
  213. dest[3], dest[4], dest[5]);
  214. /* Encode metadata header at front. */
  215. hdr = skb_vnet_hdr(skb);
  216. if (skb->ip_summed == CHECKSUM_PARTIAL) {
  217. hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
  218. hdr->csum_start = skb->csum_start - skb_headroom(skb);
  219. hdr->csum_offset = skb->csum_offset;
  220. } else {
  221. hdr->flags = 0;
  222. hdr->csum_offset = hdr->csum_start = 0;
  223. }
  224. if (skb_is_gso(skb)) {
  225. hdr->hdr_len = skb_transport_header(skb) - skb->data;
  226. hdr->gso_size = skb_shinfo(skb)->gso_size;
  227. if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
  228. hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
  229. else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
  230. hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
  231. else if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
  232. hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP;
  233. else
  234. BUG();
  235. if (skb_shinfo(skb)->gso_type & SKB_GSO_TCP_ECN)
  236. hdr->gso_type |= VIRTIO_NET_HDR_GSO_ECN;
  237. } else {
  238. hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
  239. hdr->gso_size = hdr->hdr_len = 0;
  240. }
  241. vnet_hdr_to_sg(sg, skb);
  242. num = skb_to_sgvec(skb, sg+1, 0, skb->len) + 1;
  243. return vi->svq->vq_ops->add_buf(vi->svq, sg, num, 0, skb);
  244. }
  245. static void xmit_tasklet(unsigned long data)
  246. {
  247. struct virtnet_info *vi = (void *)data;
  248. netif_tx_lock_bh(vi->dev);
  249. if (vi->last_xmit_skb && xmit_skb(vi, vi->last_xmit_skb) == 0) {
  250. vi->svq->vq_ops->kick(vi->svq);
  251. vi->last_xmit_skb = NULL;
  252. }
  253. netif_tx_unlock_bh(vi->dev);
  254. }
  255. static int start_xmit(struct sk_buff *skb, struct net_device *dev)
  256. {
  257. struct virtnet_info *vi = netdev_priv(dev);
  258. again:
  259. /* Free up any pending old buffers before queueing new ones. */
  260. free_old_xmit_skbs(vi);
  261. /* If we has a buffer left over from last time, send it now. */
  262. if (unlikely(vi->last_xmit_skb)) {
  263. if (xmit_skb(vi, vi->last_xmit_skb) != 0) {
  264. /* Drop this skb: we only queue one. */
  265. vi->dev->stats.tx_dropped++;
  266. kfree_skb(skb);
  267. skb = NULL;
  268. goto stop_queue;
  269. }
  270. vi->last_xmit_skb = NULL;
  271. }
  272. /* Put new one in send queue and do transmit */
  273. if (likely(skb)) {
  274. __skb_queue_head(&vi->send, skb);
  275. if (xmit_skb(vi, skb) != 0) {
  276. vi->last_xmit_skb = skb;
  277. skb = NULL;
  278. goto stop_queue;
  279. }
  280. }
  281. done:
  282. vi->svq->vq_ops->kick(vi->svq);
  283. return NETDEV_TX_OK;
  284. stop_queue:
  285. pr_debug("%s: virtio not prepared to send\n", dev->name);
  286. netif_stop_queue(dev);
  287. /* Activate callback for using skbs: if this returns false it
  288. * means some were used in the meantime. */
  289. if (unlikely(!vi->svq->vq_ops->enable_cb(vi->svq))) {
  290. vi->svq->vq_ops->disable_cb(vi->svq);
  291. netif_start_queue(dev);
  292. goto again;
  293. }
  294. goto done;
  295. }
  296. #ifdef CONFIG_NET_POLL_CONTROLLER
  297. static void virtnet_netpoll(struct net_device *dev)
  298. {
  299. struct virtnet_info *vi = netdev_priv(dev);
  300. napi_schedule(&vi->napi);
  301. }
  302. #endif
  303. static int virtnet_open(struct net_device *dev)
  304. {
  305. struct virtnet_info *vi = netdev_priv(dev);
  306. napi_enable(&vi->napi);
  307. /* If all buffers were filled by other side before we napi_enabled, we
  308. * won't get another interrupt, so process any outstanding packets
  309. * now. virtnet_poll wants re-enable the queue, so we disable here.
  310. * We synchronize against interrupts via NAPI_STATE_SCHED */
  311. if (netif_rx_schedule_prep(dev, &vi->napi)) {
  312. vi->rvq->vq_ops->disable_cb(vi->rvq);
  313. __netif_rx_schedule(dev, &vi->napi);
  314. }
  315. return 0;
  316. }
  317. static int virtnet_close(struct net_device *dev)
  318. {
  319. struct virtnet_info *vi = netdev_priv(dev);
  320. napi_disable(&vi->napi);
  321. return 0;
  322. }
  323. static int virtnet_probe(struct virtio_device *vdev)
  324. {
  325. int err;
  326. struct net_device *dev;
  327. struct virtnet_info *vi;
  328. /* Allocate ourselves a network device with room for our info */
  329. dev = alloc_etherdev(sizeof(struct virtnet_info));
  330. if (!dev)
  331. return -ENOMEM;
  332. /* Set up network device as normal. */
  333. dev->open = virtnet_open;
  334. dev->stop = virtnet_close;
  335. dev->hard_start_xmit = start_xmit;
  336. dev->features = NETIF_F_HIGHDMA;
  337. #ifdef CONFIG_NET_POLL_CONTROLLER
  338. dev->poll_controller = virtnet_netpoll;
  339. #endif
  340. SET_NETDEV_DEV(dev, &vdev->dev);
  341. /* Do we support "hardware" checksums? */
  342. if (csum && virtio_has_feature(vdev, VIRTIO_NET_F_CSUM)) {
  343. /* This opens up the world of extra features. */
  344. dev->features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
  345. if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_GSO)) {
  346. dev->features |= NETIF_F_TSO | NETIF_F_UFO
  347. | NETIF_F_TSO_ECN | NETIF_F_TSO6;
  348. }
  349. /* Individual feature bits: what can host handle? */
  350. if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4))
  351. dev->features |= NETIF_F_TSO;
  352. if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO6))
  353. dev->features |= NETIF_F_TSO6;
  354. if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_ECN))
  355. dev->features |= NETIF_F_TSO_ECN;
  356. if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_UFO))
  357. dev->features |= NETIF_F_UFO;
  358. }
  359. /* Configuration may specify what MAC to use. Otherwise random. */
  360. if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC)) {
  361. vdev->config->get(vdev,
  362. offsetof(struct virtio_net_config, mac),
  363. dev->dev_addr, dev->addr_len);
  364. } else
  365. random_ether_addr(dev->dev_addr);
  366. /* Set up our device-specific information */
  367. vi = netdev_priv(dev);
  368. netif_napi_add(dev, &vi->napi, virtnet_poll, napi_weight);
  369. vi->dev = dev;
  370. vi->vdev = vdev;
  371. vdev->priv = vi;
  372. /* We expect two virtqueues, receive then send. */
  373. vi->rvq = vdev->config->find_vq(vdev, 0, skb_recv_done);
  374. if (IS_ERR(vi->rvq)) {
  375. err = PTR_ERR(vi->rvq);
  376. goto free;
  377. }
  378. vi->svq = vdev->config->find_vq(vdev, 1, skb_xmit_done);
  379. if (IS_ERR(vi->svq)) {
  380. err = PTR_ERR(vi->svq);
  381. goto free_recv;
  382. }
  383. /* Initialize our empty receive and send queues. */
  384. skb_queue_head_init(&vi->recv);
  385. skb_queue_head_init(&vi->send);
  386. tasklet_init(&vi->tasklet, xmit_tasklet, (unsigned long)vi);
  387. err = register_netdev(dev);
  388. if (err) {
  389. pr_debug("virtio_net: registering device failed\n");
  390. goto free_send;
  391. }
  392. /* Last of all, set up some receive buffers. */
  393. try_fill_recv(vi);
  394. /* If we didn't even get one input buffer, we're useless. */
  395. if (vi->num == 0) {
  396. err = -ENOMEM;
  397. goto unregister;
  398. }
  399. pr_debug("virtnet: registered device %s\n", dev->name);
  400. return 0;
  401. unregister:
  402. unregister_netdev(dev);
  403. free_send:
  404. vdev->config->del_vq(vi->svq);
  405. free_recv:
  406. vdev->config->del_vq(vi->rvq);
  407. free:
  408. free_netdev(dev);
  409. return err;
  410. }
  411. static void virtnet_remove(struct virtio_device *vdev)
  412. {
  413. struct virtnet_info *vi = vdev->priv;
  414. struct sk_buff *skb;
  415. /* Stop all the virtqueues. */
  416. vdev->config->reset(vdev);
  417. /* Free our skbs in send and recv queues, if any. */
  418. while ((skb = __skb_dequeue(&vi->recv)) != NULL) {
  419. kfree_skb(skb);
  420. vi->num--;
  421. }
  422. __skb_queue_purge(&vi->send);
  423. BUG_ON(vi->num != 0);
  424. vdev->config->del_vq(vi->svq);
  425. vdev->config->del_vq(vi->rvq);
  426. unregister_netdev(vi->dev);
  427. free_netdev(vi->dev);
  428. }
  429. static struct virtio_device_id id_table[] = {
  430. { VIRTIO_ID_NET, VIRTIO_DEV_ANY_ID },
  431. { 0 },
  432. };
  433. static unsigned int features[] = {
  434. VIRTIO_NET_F_CSUM, VIRTIO_NET_F_GSO, VIRTIO_NET_F_MAC,
  435. VIRTIO_NET_F_HOST_TSO4, VIRTIO_NET_F_HOST_UFO, VIRTIO_NET_F_HOST_TSO6,
  436. VIRTIO_NET_F_HOST_ECN,
  437. };
  438. static struct virtio_driver virtio_net = {
  439. .feature_table = features,
  440. .feature_table_size = ARRAY_SIZE(features),
  441. .driver.name = KBUILD_MODNAME,
  442. .driver.owner = THIS_MODULE,
  443. .id_table = id_table,
  444. .probe = virtnet_probe,
  445. .remove = __devexit_p(virtnet_remove),
  446. };
  447. static int __init init(void)
  448. {
  449. return register_virtio_driver(&virtio_net);
  450. }
  451. static void __exit fini(void)
  452. {
  453. unregister_virtio_driver(&virtio_net);
  454. }
  455. module_init(init);
  456. module_exit(fini);
  457. MODULE_DEVICE_TABLE(virtio, id_table);
  458. MODULE_DESCRIPTION("Virtio network driver");
  459. MODULE_LICENSE("GPL");