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