?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge 3.0-rc2 into tty-linus
[linux/fpc-iii.git] / drivers / net / virtio_net.c
blobf6853247a620046a12e9dab53c9e4f3adcf4d2b2
1 /* A 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/ethtool.h>
23 #include <linux/module.h>
24 #include <linux/virtio.h>
25 #include <linux/virtio_net.h>
26 #include <linux/scatterlist.h>
27 #include <linux/if_vlan.h>
28 #include <linux/slab.h>
29
30 static int napi_weight = 128;
31 module_param(napi_weight, int, 0444);
32
33 static int csum = 1, gso = 1;
34 module_param(csum, bool, 0444);
35 module_param(gso, bool, 0444);
36
37 /* FIXME: MTU in config. */
38 #define MAX_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
39 #define GOOD_COPY_LEN 128
40
41 #define VIRTNET_SEND_COMMAND_SG_MAX 2
42
43 struct virtnet_info {
44 struct virtio_device *vdev;
45 struct virtqueue *rvq, *svq, *cvq;
46 struct net_device *dev;
47 struct napi_struct napi;
48 unsigned int status;
49
50 /* Number of input buffers, and max we've ever had. */
51 unsigned int num, max;
52
53 /* I like... big packets and I cannot lie! */
54 bool big_packets;
55
56 /* Host will merge rx buffers for big packets (shake it! shake it!) */
57 bool mergeable_rx_bufs;
58
59 /* Work struct for refilling if we run low on memory. */
60 struct delayed_work refill;
61
62 /* Chain pages by the private ptr. */
63 struct page *pages;
64
65 /* fragments + linear part + virtio header */
66 struct scatterlist rx_sg[MAX_SKB_FRAGS + 2];
67 struct scatterlist tx_sg[MAX_SKB_FRAGS + 2];
68 };
69
70 struct skb_vnet_hdr {
71 union {
72 struct virtio_net_hdr hdr;
73 struct virtio_net_hdr_mrg_rxbuf mhdr;
74 };
75 unsigned int num_sg;
76 };
77
78 struct padded_vnet_hdr {
79 struct virtio_net_hdr hdr;
80 /*
81 * virtio_net_hdr should be in a separated sg buffer because of a
82 * QEMU bug, and data sg buffer shares same page with this header sg.
83 * This padding makes next sg 16 byte aligned after virtio_net_hdr.
84 */
85 char padding[6];
86 };
87
88 static inline struct skb_vnet_hdr *skb_vnet_hdr(struct sk_buff *skb)
89 {
90 return (struct skb_vnet_hdr *)skb->cb;
91 }
92
93 /*
94 * private is used to chain pages for big packets, put the whole
95 * most recent used list in the beginning for reuse
96 */
97 static void give_pages(struct virtnet_info *vi, struct page *page)
98 {
99 struct page *end;
100
101 /* Find end of list, sew whole thing into vi->pages. */
102 for (end = page; end->private; end = (struct page *)end->private);
103 end->private = (unsigned long)vi->pages;
104 vi->pages = page;
105 }
106
107 static struct page *get_a_page(struct virtnet_info *vi, gfp_t gfp_mask)
108 {
109 struct page *p = vi->pages;
110
111 if (p) {
112 vi->pages = (struct page *)p->private;
113 /* clear private here, it is used to chain pages */
114 p->private = 0;
115 } else
116 p = alloc_page(gfp_mask);
117 return p;
118 }
119
120 static void skb_xmit_done(struct virtqueue *svq)
121 {
122 struct virtnet_info *vi = svq->vdev->priv;
123
124 /* Suppress further interrupts. */
125 virtqueue_disable_cb(svq);
126
127 /* We were probably waiting for more output buffers. */
128 netif_wake_queue(vi->dev);
129 }
130
131 static void set_skb_frag(struct sk_buff *skb, struct page *page,
132 unsigned int offset, unsigned int *len)
133 {
134 int i = skb_shinfo(skb)->nr_frags;
135 skb_frag_t *f;
136
137 f = &skb_shinfo(skb)->frags[i];
138 f->size = min((unsigned)PAGE_SIZE - offset, *len);
139 f->page_offset = offset;
140 f->page = page;
141
142 skb->data_len += f->size;
143 skb->len += f->size;
144 skb_shinfo(skb)->nr_frags++;
145 *len -= f->size;
146 }
147
148 static struct sk_buff *page_to_skb(struct virtnet_info *vi,
149 struct page *page, unsigned int len)
150 {
151 struct sk_buff *skb;
152 struct skb_vnet_hdr *hdr;
153 unsigned int copy, hdr_len, offset;
154 char *p;
155
156 p = page_address(page);
157
158 /* copy small packet so we can reuse these pages for small data */
159 skb = netdev_alloc_skb_ip_align(vi->dev, GOOD_COPY_LEN);
160 if (unlikely(!skb))
161 return NULL;
162
163 hdr = skb_vnet_hdr(skb);
164
165 if (vi->mergeable_rx_bufs) {
166 hdr_len = sizeof hdr->mhdr;
167 offset = hdr_len;
168 } else {
169 hdr_len = sizeof hdr->hdr;
170 offset = sizeof(struct padded_vnet_hdr);
171 }
172
173 memcpy(hdr, p, hdr_len);
174
175 len -= hdr_len;
176 p += offset;
177
178 copy = len;
179 if (copy > skb_tailroom(skb))
180 copy = skb_tailroom(skb);
181 memcpy(skb_put(skb, copy), p, copy);
182
183 len -= copy;
184 offset += copy;
185
186 while (len) {
187 set_skb_frag(skb, page, offset, &len);
188 page = (struct page *)page->private;
189 offset = 0;
190 }
191
192 if (page)
193 give_pages(vi, page);
194
195 return skb;
196 }
197
198 static int receive_mergeable(struct virtnet_info *vi, struct sk_buff *skb)
199 {
200 struct skb_vnet_hdr *hdr = skb_vnet_hdr(skb);
201 struct page *page;
202 int num_buf, i, len;
203
204 num_buf = hdr->mhdr.num_buffers;
205 while (--num_buf) {
206 i = skb_shinfo(skb)->nr_frags;
207 if (i >= MAX_SKB_FRAGS) {
208 pr_debug("%s: packet too long\n", skb->dev->name);
209 skb->dev->stats.rx_length_errors++;
210 return -EINVAL;
211 }
212
213 page = virtqueue_get_buf(vi->rvq, &len);
214 if (!page) {
215 pr_debug("%s: rx error: %d buffers missing\n",
216 skb->dev->name, hdr->mhdr.num_buffers);
217 skb->dev->stats.rx_length_errors++;
218 return -EINVAL;
219 }
220 if (len > PAGE_SIZE)
221 len = PAGE_SIZE;
222
223 set_skb_frag(skb, page, 0, &len);
224
225 --vi->num;
226 }
227 return 0;
228 }
229
230 static void receive_buf(struct net_device *dev, void *buf, unsigned int len)
231 {
232 struct virtnet_info *vi = netdev_priv(dev);
233 struct sk_buff *skb;
234 struct page *page;
235 struct skb_vnet_hdr *hdr;
236
237 if (unlikely(len < sizeof(struct virtio_net_hdr) + ETH_HLEN)) {
238 pr_debug("%s: short packet %i\n", dev->name, len);
239 dev->stats.rx_length_errors++;
240 if (vi->mergeable_rx_bufs || vi->big_packets)
241 give_pages(vi, buf);
242 else
243 dev_kfree_skb(buf);
244 return;
245 }
246
247 if (!vi->mergeable_rx_bufs && !vi->big_packets) {
248 skb = buf;
249 len -= sizeof(struct virtio_net_hdr);
250 skb_trim(skb, len);
251 } else {
252 page = buf;
253 skb = page_to_skb(vi, page, len);
254 if (unlikely(!skb)) {
255 dev->stats.rx_dropped++;
256 give_pages(vi, page);
257 return;
258 }
259 if (vi->mergeable_rx_bufs)
260 if (receive_mergeable(vi, skb)) {
261 dev_kfree_skb(skb);
262 return;
263 }
264 }
265
266 hdr = skb_vnet_hdr(skb);
267 skb->truesize += skb->data_len;
268 dev->stats.rx_bytes += skb->len;
269 dev->stats.rx_packets++;
270
271 if (hdr->hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
272 pr_debug("Needs csum!\n");
273 if (!skb_partial_csum_set(skb,
274 hdr->hdr.csum_start,
275 hdr->hdr.csum_offset))
276 goto frame_err;
277 }
278
279 skb->protocol = eth_type_trans(skb, dev);
280 pr_debug("Receiving skb proto 0x%04x len %i type %i\n",
281 ntohs(skb->protocol), skb->len, skb->pkt_type);
282
283 if (hdr->hdr.gso_type != VIRTIO_NET_HDR_GSO_NONE) {
284 pr_debug("GSO!\n");
285 switch (hdr->hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
286 case VIRTIO_NET_HDR_GSO_TCPV4:
287 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
288 break;
289 case VIRTIO_NET_HDR_GSO_UDP:
290 skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
291 break;
292 case VIRTIO_NET_HDR_GSO_TCPV6:
293 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
294 break;
295 default:
296 if (net_ratelimit())
297 printk(KERN_WARNING "%s: bad gso type %u.\n",
298 dev->name, hdr->hdr.gso_type);
299 goto frame_err;
300 }
301
302 if (hdr->hdr.gso_type & VIRTIO_NET_HDR_GSO_ECN)
303 skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
304
305 skb_shinfo(skb)->gso_size = hdr->hdr.gso_size;
306 if (skb_shinfo(skb)->gso_size == 0) {
307 if (net_ratelimit())
308 printk(KERN_WARNING "%s: zero gso size.\n",
309 dev->name);
310 goto frame_err;
311 }
312
313 /* Header must be checked, and gso_segs computed. */
314 skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
315 skb_shinfo(skb)->gso_segs = 0;
316 }
317
318 netif_receive_skb(skb);
319 return;
320
321 frame_err:
322 dev->stats.rx_frame_errors++;
323 dev_kfree_skb(skb);
324 }
325
326 static int add_recvbuf_small(struct virtnet_info *vi, gfp_t gfp)
327 {
328 struct sk_buff *skb;
329 struct skb_vnet_hdr *hdr;
330 int err;
331
332 skb = netdev_alloc_skb_ip_align(vi->dev, MAX_PACKET_LEN);
333 if (unlikely(!skb))
334 return -ENOMEM;
335
336 skb_put(skb, MAX_PACKET_LEN);
337
338 hdr = skb_vnet_hdr(skb);
339 sg_set_buf(vi->rx_sg, &hdr->hdr, sizeof hdr->hdr);
340
341 skb_to_sgvec(skb, vi->rx_sg + 1, 0, skb->len);
342
343 err = virtqueue_add_buf_gfp(vi->rvq, vi->rx_sg, 0, 2, skb, gfp);
344 if (err < 0)
345 dev_kfree_skb(skb);
346
347 return err;
348 }
349
350 static int add_recvbuf_big(struct virtnet_info *vi, gfp_t gfp)
351 {
352 struct page *first, *list = NULL;
353 char *p;
354 int i, err, offset;
355
356 /* page in vi->rx_sg[MAX_SKB_FRAGS + 1] is list tail */
357 for (i = MAX_SKB_FRAGS + 1; i > 1; --i) {
358 first = get_a_page(vi, gfp);
359 if (!first) {
360 if (list)
361 give_pages(vi, list);
362 return -ENOMEM;
363 }
364 sg_set_buf(&vi->rx_sg[i], page_address(first), PAGE_SIZE);
365
366 /* chain new page in list head to match sg */
367 first->private = (unsigned long)list;
368 list = first;
369 }
370
371 first = get_a_page(vi, gfp);
372 if (!first) {
373 give_pages(vi, list);
374 return -ENOMEM;
375 }
376 p = page_address(first);
377
378 /* vi->rx_sg[0], vi->rx_sg[1] share the same page */
379 /* a separated vi->rx_sg[0] for virtio_net_hdr only due to QEMU bug */
380 sg_set_buf(&vi->rx_sg[0], p, sizeof(struct virtio_net_hdr));
381
382 /* vi->rx_sg[1] for data packet, from offset */
383 offset = sizeof(struct padded_vnet_hdr);
384 sg_set_buf(&vi->rx_sg[1], p + offset, PAGE_SIZE - offset);
385
386 /* chain first in list head */
387 first->private = (unsigned long)list;
388 err = virtqueue_add_buf_gfp(vi->rvq, vi->rx_sg, 0, MAX_SKB_FRAGS + 2,
389 first, gfp);
390 if (err < 0)
391 give_pages(vi, first);
392
393 return err;
394 }
395
396 static int add_recvbuf_mergeable(struct virtnet_info *vi, gfp_t gfp)
397 {
398 struct page *page;
399 int err;
400
401 page = get_a_page(vi, gfp);
402 if (!page)
403 return -ENOMEM;
404
405 sg_init_one(vi->rx_sg, page_address(page), PAGE_SIZE);
406
407 err = virtqueue_add_buf_gfp(vi->rvq, vi->rx_sg, 0, 1, page, gfp);
408 if (err < 0)
409 give_pages(vi, page);
410
411 return err;
412 }
413
414 /* Returns false if we couldn't fill entirely (OOM). */
415 static bool try_fill_recv(struct virtnet_info *vi, gfp_t gfp)
416 {
417 int err;
418 bool oom;
419
420 do {
421 if (vi->mergeable_rx_bufs)
422 err = add_recvbuf_mergeable(vi, gfp);
423 else if (vi->big_packets)
424 err = add_recvbuf_big(vi, gfp);
425 else
426 err = add_recvbuf_small(vi, gfp);
427
428 oom = err == -ENOMEM;
429 if (err < 0)
430 break;
431 ++vi->num;
432 } while (err > 0);
433 if (unlikely(vi->num > vi->max))
434 vi->max = vi->num;
435 virtqueue_kick(vi->rvq);
436 return !oom;
437 }
438
439 static void skb_recv_done(struct virtqueue *rvq)
440 {
441 struct virtnet_info *vi = rvq->vdev->priv;
442 /* Schedule NAPI, Suppress further interrupts if successful. */
443 if (napi_schedule_prep(&vi->napi)) {
444 virtqueue_disable_cb(rvq);
445 __napi_schedule(&vi->napi);
446 }
447 }
448
449 static void virtnet_napi_enable(struct virtnet_info *vi)
450 {
451 napi_enable(&vi->napi);
452
453 /* If all buffers were filled by other side before we napi_enabled, we
454 * won't get another interrupt, so process any outstanding packets
455 * now. virtnet_poll wants re-enable the queue, so we disable here.
456 * We synchronize against interrupts via NAPI_STATE_SCHED */
457 if (napi_schedule_prep(&vi->napi)) {
458 virtqueue_disable_cb(vi->rvq);
459 __napi_schedule(&vi->napi);
460 }
461 }
462
463 static void refill_work(struct work_struct *work)
464 {
465 struct virtnet_info *vi;
466 bool still_empty;
467
468 vi = container_of(work, struct virtnet_info, refill.work);
469 napi_disable(&vi->napi);
470 still_empty = !try_fill_recv(vi, GFP_KERNEL);
471 virtnet_napi_enable(vi);
472
473 /* In theory, this can happen: if we don't get any buffers in
474 * we will *never* try to fill again. */
475 if (still_empty)
476 schedule_delayed_work(&vi->refill, HZ/2);
477 }
478
479 static int virtnet_poll(struct napi_struct *napi, int budget)
480 {
481 struct virtnet_info *vi = container_of(napi, struct virtnet_info, napi);
482 void *buf;
483 unsigned int len, received = 0;
484
485 again:
486 while (received < budget &&
487 (buf = virtqueue_get_buf(vi->rvq, &len)) != NULL) {
488 receive_buf(vi->dev, buf, len);
489 --vi->num;
490 received++;
491 }
492
493 if (vi->num < vi->max / 2) {
494 if (!try_fill_recv(vi, GFP_ATOMIC))
495 schedule_delayed_work(&vi->refill, 0);
496 }
497
498 /* Out of packets? */
499 if (received < budget) {
500 napi_complete(napi);
501 if (unlikely(!virtqueue_enable_cb(vi->rvq)) &&
502 napi_schedule_prep(napi)) {
503 virtqueue_disable_cb(vi->rvq);
504 __napi_schedule(napi);
505 goto again;
506 }
507 }
508
509 return received;
510 }
511
512 static unsigned int free_old_xmit_skbs(struct virtnet_info *vi)
513 {
514 struct sk_buff *skb;
515 unsigned int len, tot_sgs = 0;
516
517 while ((skb = virtqueue_get_buf(vi->svq, &len)) != NULL) {
518 pr_debug("Sent skb %p\n", skb);
519 vi->dev->stats.tx_bytes += skb->len;
520 vi->dev->stats.tx_packets++;
521 tot_sgs += skb_vnet_hdr(skb)->num_sg;
522 dev_kfree_skb_any(skb);
523 }
524 return tot_sgs;
525 }
526
527 static int xmit_skb(struct virtnet_info *vi, struct sk_buff *skb)
528 {
529 struct skb_vnet_hdr *hdr = skb_vnet_hdr(skb);
530 const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest;
531
532 pr_debug("%s: xmit %p %pM\n", vi->dev->name, skb, dest);
533
534 if (skb->ip_summed == CHECKSUM_PARTIAL) {
535 hdr->hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
536 hdr->hdr.csum_start = skb_checksum_start_offset(skb);
537 hdr->hdr.csum_offset = skb->csum_offset;
538 } else {
539 hdr->hdr.flags = 0;
540 hdr->hdr.csum_offset = hdr->hdr.csum_start = 0;
541 }
542
543 if (skb_is_gso(skb)) {
544 hdr->hdr.hdr_len = skb_headlen(skb);
545 hdr->hdr.gso_size = skb_shinfo(skb)->gso_size;
546 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
547 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
548 else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
549 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
550 else if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
551 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_UDP;
552 else
553 BUG();
554 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCP_ECN)
555 hdr->hdr.gso_type |= VIRTIO_NET_HDR_GSO_ECN;
556 } else {
557 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_NONE;
558 hdr->hdr.gso_size = hdr->hdr.hdr_len = 0;
559 }
560
561 hdr->mhdr.num_buffers = 0;
562
563 /* Encode metadata header at front. */
564 if (vi->mergeable_rx_bufs)
565 sg_set_buf(vi->tx_sg, &hdr->mhdr, sizeof hdr->mhdr);
566 else
567 sg_set_buf(vi->tx_sg, &hdr->hdr, sizeof hdr->hdr);
568
569 hdr->num_sg = skb_to_sgvec(skb, vi->tx_sg + 1, 0, skb->len) + 1;
570 return virtqueue_add_buf(vi->svq, vi->tx_sg, hdr->num_sg,
571 0, skb);
572 }
573
574 static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
575 {
576 struct virtnet_info *vi = netdev_priv(dev);
577 int capacity;
578
579 /* Free up any pending old buffers before queueing new ones. */
580 free_old_xmit_skbs(vi);
581
582 /* Try to transmit */
583 capacity = xmit_skb(vi, skb);
584
585 /* This can happen with OOM and indirect buffers. */
586 if (unlikely(capacity < 0)) {
587 if (net_ratelimit()) {
588 if (likely(capacity == -ENOMEM)) {
589 dev_warn(&dev->dev,
590 "TX queue failure: out of memory\n");
591 } else {
592 dev->stats.tx_fifo_errors++;
593 dev_warn(&dev->dev,
594 "Unexpected TX queue failure: %d\n",
595 capacity);
596 }
597 }
598 dev->stats.tx_dropped++;
599 kfree_skb(skb);
600 return NETDEV_TX_OK;
601 }
602 virtqueue_kick(vi->svq);
603
604 /* Don't wait up for transmitted skbs to be freed. */
605 skb_orphan(skb);
606 nf_reset(skb);
607
608 /* Apparently nice girls don't return TX_BUSY; stop the queue
609 * before it gets out of hand. Naturally, this wastes entries. */
610 if (capacity < 2+MAX_SKB_FRAGS) {
611 netif_stop_queue(dev);
612 if (unlikely(!virtqueue_enable_cb_delayed(vi->svq))) {
613 /* More just got used, free them then recheck. */
614 capacity += free_old_xmit_skbs(vi);
615 if (capacity >= 2+MAX_SKB_FRAGS) {
616 netif_start_queue(dev);
617 virtqueue_disable_cb(vi->svq);
618 }
619 }
620 }
621
622 return NETDEV_TX_OK;
623 }
624
625 static int virtnet_set_mac_address(struct net_device *dev, void *p)
626 {
627 struct virtnet_info *vi = netdev_priv(dev);
628 struct virtio_device *vdev = vi->vdev;
629 int ret;
630
631 ret = eth_mac_addr(dev, p);
632 if (ret)
633 return ret;
634
635 if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC))
636 vdev->config->set(vdev, offsetof(struct virtio_net_config, mac),
637 dev->dev_addr, dev->addr_len);
638
639 return 0;
640 }
641
642 #ifdef CONFIG_NET_POLL_CONTROLLER
643 static void virtnet_netpoll(struct net_device *dev)
644 {
645 struct virtnet_info *vi = netdev_priv(dev);
646
647 napi_schedule(&vi->napi);
648 }
649 #endif
650
651 static int virtnet_open(struct net_device *dev)
652 {
653 struct virtnet_info *vi = netdev_priv(dev);
654
655 virtnet_napi_enable(vi);
656 return 0;
657 }
658
659 /*
660 * Send command via the control virtqueue and check status. Commands
661 * supported by the hypervisor, as indicated by feature bits, should
662 * never fail unless improperly formated.
663 */
664 static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
665 struct scatterlist *data, int out, int in)
666 {
667 struct scatterlist *s, sg[VIRTNET_SEND_COMMAND_SG_MAX + 2];
668 struct virtio_net_ctrl_hdr ctrl;
669 virtio_net_ctrl_ack status = ~0;
670 unsigned int tmp;
671 int i;
672
673 /* Caller should know better */
674 BUG_ON(!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ) ||
675 (out + in > VIRTNET_SEND_COMMAND_SG_MAX));
676
677 out++; /* Add header */
678 in++; /* Add return status */
679
680 ctrl.class = class;
681 ctrl.cmd = cmd;
682
683 sg_init_table(sg, out + in);
684
685 sg_set_buf(&sg[0], &ctrl, sizeof(ctrl));
686 for_each_sg(data, s, out + in - 2, i)
687 sg_set_buf(&sg[i + 1], sg_virt(s), s->length);
688 sg_set_buf(&sg[out + in - 1], &status, sizeof(status));
689
690 BUG_ON(virtqueue_add_buf(vi->cvq, sg, out, in, vi) < 0);
691
692 virtqueue_kick(vi->cvq);
693
694 /*
695 * Spin for a response, the kick causes an ioport write, trapping
696 * into the hypervisor, so the request should be handled immediately.
697 */
698 while (!virtqueue_get_buf(vi->cvq, &tmp))
699 cpu_relax();
700
701 return status == VIRTIO_NET_OK;
702 }
703
704 static int virtnet_close(struct net_device *dev)
705 {
706 struct virtnet_info *vi = netdev_priv(dev);
707
708 napi_disable(&vi->napi);
709
710 return 0;
711 }
712
713 static void virtnet_set_rx_mode(struct net_device *dev)
714 {
715 struct virtnet_info *vi = netdev_priv(dev);
716 struct scatterlist sg[2];
717 u8 promisc, allmulti;
718 struct virtio_net_ctrl_mac *mac_data;
719 struct netdev_hw_addr *ha;
720 int uc_count;
721 int mc_count;
722 void *buf;
723 int i;
724
725 /* We can't dynamicaly set ndo_set_rx_mode, so return gracefully */
726 if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_RX))
727 return;
728
729 promisc = ((dev->flags & IFF_PROMISC) != 0);
730 allmulti = ((dev->flags & IFF_ALLMULTI) != 0);
731
732 sg_init_one(sg, &promisc, sizeof(promisc));
733
734 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
735 VIRTIO_NET_CTRL_RX_PROMISC,
736 sg, 1, 0))
737 dev_warn(&dev->dev, "Failed to %sable promisc mode.\n",
738 promisc ? "en" : "dis");
739
740 sg_init_one(sg, &allmulti, sizeof(allmulti));
741
742 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
743 VIRTIO_NET_CTRL_RX_ALLMULTI,
744 sg, 1, 0))
745 dev_warn(&dev->dev, "Failed to %sable allmulti mode.\n",
746 allmulti ? "en" : "dis");
747
748 uc_count = netdev_uc_count(dev);
749 mc_count = netdev_mc_count(dev);
750 /* MAC filter - use one buffer for both lists */
751 buf = kzalloc(((uc_count + mc_count) * ETH_ALEN) +
752 (2 * sizeof(mac_data->entries)), GFP_ATOMIC);
753 mac_data = buf;
754 if (!buf) {
755 dev_warn(&dev->dev, "No memory for MAC address buffer\n");
756 return;
757 }
758
759 sg_init_table(sg, 2);
760
761 /* Store the unicast list and count in the front of the buffer */
762 mac_data->entries = uc_count;
763 i = 0;
764 netdev_for_each_uc_addr(ha, dev)
765 memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
766
767 sg_set_buf(&sg[0], mac_data,
768 sizeof(mac_data->entries) + (uc_count * ETH_ALEN));
769
770 /* multicast list and count fill the end */
771 mac_data = (void *)&mac_data->macs[uc_count][0];
772
773 mac_data->entries = mc_count;
774 i = 0;
775 netdev_for_each_mc_addr(ha, dev)
776 memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
777
778 sg_set_buf(&sg[1], mac_data,
779 sizeof(mac_data->entries) + (mc_count * ETH_ALEN));
780
781 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MAC,
782 VIRTIO_NET_CTRL_MAC_TABLE_SET,
783 sg, 2, 0))
784 dev_warn(&dev->dev, "Failed to set MAC fitler table.\n");
785
786 kfree(buf);
787 }
788
789 static void virtnet_vlan_rx_add_vid(struct net_device *dev, u16 vid)
790 {
791 struct virtnet_info *vi = netdev_priv(dev);
792 struct scatterlist sg;
793
794 sg_init_one(&sg, &vid, sizeof(vid));
795
796 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
797 VIRTIO_NET_CTRL_VLAN_ADD, &sg, 1, 0))
798 dev_warn(&dev->dev, "Failed to add VLAN ID %d.\n", vid);
799 }
800
801 static void virtnet_vlan_rx_kill_vid(struct net_device *dev, u16 vid)
802 {
803 struct virtnet_info *vi = netdev_priv(dev);
804 struct scatterlist sg;
805
806 sg_init_one(&sg, &vid, sizeof(vid));
807
808 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
809 VIRTIO_NET_CTRL_VLAN_DEL, &sg, 1, 0))
810 dev_warn(&dev->dev, "Failed to kill VLAN ID %d.\n", vid);
811 }
812
813 static const struct ethtool_ops virtnet_ethtool_ops = {
814 .get_link = ethtool_op_get_link,
815 };
816
817 #define MIN_MTU 68
818 #define MAX_MTU 65535
819
820 static int virtnet_change_mtu(struct net_device *dev, int new_mtu)
821 {
822 if (new_mtu < MIN_MTU || new_mtu > MAX_MTU)
823 return -EINVAL;
824 dev->mtu = new_mtu;
825 return 0;
826 }
827
828 static const struct net_device_ops virtnet_netdev = {
829 .ndo_open = virtnet_open,
830 .ndo_stop = virtnet_close,
831 .ndo_start_xmit = start_xmit,
832 .ndo_validate_addr = eth_validate_addr,
833 .ndo_set_mac_address = virtnet_set_mac_address,
834 .ndo_set_rx_mode = virtnet_set_rx_mode,
835 .ndo_change_mtu = virtnet_change_mtu,
836 .ndo_vlan_rx_add_vid = virtnet_vlan_rx_add_vid,
837 .ndo_vlan_rx_kill_vid = virtnet_vlan_rx_kill_vid,
838 #ifdef CONFIG_NET_POLL_CONTROLLER
839 .ndo_poll_controller = virtnet_netpoll,
840 #endif
841 };
842
843 static void virtnet_update_status(struct virtnet_info *vi)
844 {
845 u16 v;
846
847 if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_STATUS))
848 return;
849
850 vi->vdev->config->get(vi->vdev,
851 offsetof(struct virtio_net_config, status),
852 &v, sizeof(v));
853
854 /* Ignore unknown (future) status bits */
855 v &= VIRTIO_NET_S_LINK_UP;
856
857 if (vi->status == v)
858 return;
859
860 vi->status = v;
861
862 if (vi->status & VIRTIO_NET_S_LINK_UP) {
863 netif_carrier_on(vi->dev);
864 netif_wake_queue(vi->dev);
865 } else {
866 netif_carrier_off(vi->dev);
867 netif_stop_queue(vi->dev);
868 }
869 }
870
871 static void virtnet_config_changed(struct virtio_device *vdev)
872 {
873 struct virtnet_info *vi = vdev->priv;
874
875 virtnet_update_status(vi);
876 }
877
878 static int virtnet_probe(struct virtio_device *vdev)
879 {
880 int err;
881 struct net_device *dev;
882 struct virtnet_info *vi;
883 struct virtqueue *vqs[3];
884 vq_callback_t *callbacks[] = { skb_recv_done, skb_xmit_done, NULL};
885 const char *names[] = { "input", "output", "control" };
886 int nvqs;
887
888 /* Allocate ourselves a network device with room for our info */
889 dev = alloc_etherdev(sizeof(struct virtnet_info));
890 if (!dev)
891 return -ENOMEM;
892
893 /* Set up network device as normal. */
894 dev->netdev_ops = &virtnet_netdev;
895 dev->features = NETIF_F_HIGHDMA;
896 SET_ETHTOOL_OPS(dev, &virtnet_ethtool_ops);
897 SET_NETDEV_DEV(dev, &vdev->dev);
898
899 /* Do we support "hardware" checksums? */
900 if (virtio_has_feature(vdev, VIRTIO_NET_F_CSUM)) {
901 /* This opens up the world of extra features. */
902 dev->hw_features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
903 if (csum)
904 dev->features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
905
906 if (virtio_has_feature(vdev, VIRTIO_NET_F_GSO)) {
907 dev->hw_features |= NETIF_F_TSO | NETIF_F_UFO
908 | NETIF_F_TSO_ECN | NETIF_F_TSO6;
909 }
910 /* Individual feature bits: what can host handle? */
911 if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4))
912 dev->hw_features |= NETIF_F_TSO;
913 if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO6))
914 dev->hw_features |= NETIF_F_TSO6;
915 if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_ECN))
916 dev->hw_features |= NETIF_F_TSO_ECN;
917 if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_UFO))
918 dev->hw_features |= NETIF_F_UFO;
919
920 if (gso)
921 dev->features |= dev->hw_features & (NETIF_F_ALL_TSO|NETIF_F_UFO);
922 /* (!csum && gso) case will be fixed by register_netdev() */
923 }
924
925 /* Configuration may specify what MAC to use. Otherwise random. */
926 if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC)) {
927 vdev->config->get(vdev,
928 offsetof(struct virtio_net_config, mac),
929 dev->dev_addr, dev->addr_len);
930 } else
931 random_ether_addr(dev->dev_addr);
932
933 /* Set up our device-specific information */
934 vi = netdev_priv(dev);
935 netif_napi_add(dev, &vi->napi, virtnet_poll, napi_weight);
936 vi->dev = dev;
937 vi->vdev = vdev;
938 vdev->priv = vi;
939 vi->pages = NULL;
940 INIT_DELAYED_WORK(&vi->refill, refill_work);
941 sg_init_table(vi->rx_sg, ARRAY_SIZE(vi->rx_sg));
942 sg_init_table(vi->tx_sg, ARRAY_SIZE(vi->tx_sg));
943
944 /* If we can receive ANY GSO packets, we must allocate large ones. */
945 if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4) ||
946 virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6) ||
947 virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_ECN))
948 vi->big_packets = true;
949
950 if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF))
951 vi->mergeable_rx_bufs = true;
952
953 /* We expect two virtqueues, receive then send,
954 * and optionally control. */
955 nvqs = virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ) ? 3 : 2;
956
957 err = vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names);
958 if (err)
959 goto free;
960
961 vi->rvq = vqs[0];
962 vi->svq = vqs[1];
963
964 if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ)) {
965 vi->cvq = vqs[2];
966
967 if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VLAN))
968 dev->features |= NETIF_F_HW_VLAN_FILTER;
969 }
970
971 err = register_netdev(dev);
972 if (err) {
973 pr_debug("virtio_net: registering device failed\n");
974 goto free_vqs;
975 }
976
977 /* Last of all, set up some receive buffers. */
978 try_fill_recv(vi, GFP_KERNEL);
979
980 /* If we didn't even get one input buffer, we're useless. */
981 if (vi->num == 0) {
982 err = -ENOMEM;
983 goto unregister;
984 }
985
986 /* Assume link up if device can't report link status,
987 otherwise get link status from config. */
988 if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_STATUS)) {
989 netif_carrier_off(dev);
990 virtnet_update_status(vi);
991 } else {
992 vi->status = VIRTIO_NET_S_LINK_UP;
993 netif_carrier_on(dev);
994 }
995
996 pr_debug("virtnet: registered device %s\n", dev->name);
997 return 0;
998
999 unregister:
1000 unregister_netdev(dev);
1001 cancel_delayed_work_sync(&vi->refill);
1002 free_vqs:
1003 vdev->config->del_vqs(vdev);
1004 free:
1005 free_netdev(dev);
1006 return err;
1007 }
1008
1009 static void free_unused_bufs(struct virtnet_info *vi)
1010 {
1011 void *buf;
1012 while (1) {
1013 buf = virtqueue_detach_unused_buf(vi->svq);
1014 if (!buf)
1015 break;
1016 dev_kfree_skb(buf);
1017 }
1018 while (1) {
1019 buf = virtqueue_detach_unused_buf(vi->rvq);
1020 if (!buf)
1021 break;
1022 if (vi->mergeable_rx_bufs || vi->big_packets)
1023 give_pages(vi, buf);
1024 else
1025 dev_kfree_skb(buf);
1026 --vi->num;
1027 }
1028 BUG_ON(vi->num != 0);
1029 }
1030
1031 static void __devexit virtnet_remove(struct virtio_device *vdev)
1032 {
1033 struct virtnet_info *vi = vdev->priv;
1034
1035 /* Stop all the virtqueues. */
1036 vdev->config->reset(vdev);
1037
1038
1039 unregister_netdev(vi->dev);
1040 cancel_delayed_work_sync(&vi->refill);
1041
1042 /* Free unused buffers in both send and recv, if any. */
1043 free_unused_bufs(vi);
1044
1045 vdev->config->del_vqs(vi->vdev);
1046
1047 while (vi->pages)
1048 __free_pages(get_a_page(vi, GFP_KERNEL), 0);
1049
1050 free_netdev(vi->dev);
1051 }
1052
1053 static struct virtio_device_id id_table[] = {
1054 { VIRTIO_ID_NET, VIRTIO_DEV_ANY_ID },
1055 { 0 },
1056 };
1057
1058 static unsigned int features[] = {
1059 VIRTIO_NET_F_CSUM, VIRTIO_NET_F_GUEST_CSUM,
1060 VIRTIO_NET_F_GSO, VIRTIO_NET_F_MAC,
1061 VIRTIO_NET_F_HOST_TSO4, VIRTIO_NET_F_HOST_UFO, VIRTIO_NET_F_HOST_TSO6,
1062 VIRTIO_NET_F_HOST_ECN, VIRTIO_NET_F_GUEST_TSO4, VIRTIO_NET_F_GUEST_TSO6,
1063 VIRTIO_NET_F_GUEST_ECN, VIRTIO_NET_F_GUEST_UFO,
1064 VIRTIO_NET_F_MRG_RXBUF, VIRTIO_NET_F_STATUS, VIRTIO_NET_F_CTRL_VQ,
1065 VIRTIO_NET_F_CTRL_RX, VIRTIO_NET_F_CTRL_VLAN,
1066 };
1067
1068 static struct virtio_driver virtio_net_driver = {
1069 .feature_table = features,
1070 .feature_table_size = ARRAY_SIZE(features),
1071 .driver.name = KBUILD_MODNAME,
1072 .driver.owner = THIS_MODULE,
1073 .id_table = id_table,
1074 .probe = virtnet_probe,
1075 .remove = __devexit_p(virtnet_remove),
1076 .config_changed = virtnet_config_changed,
1077 };
1078
1079 static int __init init(void)
1080 {
1081 return register_virtio_driver(&virtio_net_driver);
1082 }
1083
1084 static void __exit fini(void)
1085 {
1086 unregister_virtio_driver(&virtio_net_driver);
1087 }
1088 module_init(init);
1089 module_exit(fini);
1090
1091 MODULE_DEVICE_TABLE(virtio, id_table);
1092 MODULE_DESCRIPTION("Virtio network driver");
1093 MODULE_LICENSE("GPL");
Linux with added FPC-III support