xref: /qemu/hw/net/vhost_net.c (revision 66997c42) 
1 /*
2  * vhost-net support
3  *
4  * Copyright Red Hat, Inc. 2010
5  *
6  * Authors:
7  *  Michael S. Tsirkin <mst@redhat.com>
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2.  See
10  * the COPYING file in the top-level directory.
11  *
12  * Contributions after 2012-01-13 are licensed under the terms of the
13  * GNU GPL, version 2 or (at your option) any later version.
14  */
15 
16 #include "qemu/osdep.h"
17 #include "net/net.h"
18 #include "net/tap.h"
19 #include "net/vhost-user.h"
20 #include "net/vhost-vdpa.h"
21 
22 #include "standard-headers/linux/vhost_types.h"
23 #include "hw/virtio/virtio-net.h"
24 #include "net/vhost_net.h"
25 #include "qapi/error.h"
26 #include "qemu/error-report.h"
27 #include "qemu/main-loop.h"
28 
29 #include <sys/socket.h>
30 #include <net/if.h>
31 #include <netinet/in.h>
32 
33 
34 #include "standard-headers/linux/virtio_ring.h"
35 #include "hw/virtio/vhost.h"
36 #include "hw/virtio/virtio-bus.h"
37 #include "linux-headers/linux/vhost.h"
38 
39 
40 /* Features supported by host kernel. */
41 static const int kernel_feature_bits[] = {
42     VIRTIO_F_NOTIFY_ON_EMPTY,
43     VIRTIO_RING_F_INDIRECT_DESC,
44     VIRTIO_RING_F_EVENT_IDX,
45     VIRTIO_NET_F_MRG_RXBUF,
46     VIRTIO_F_VERSION_1,
47     VIRTIO_NET_F_MTU,
48     VIRTIO_F_IOMMU_PLATFORM,
49     VIRTIO_F_RING_PACKED,
50     VIRTIO_F_RING_RESET,
51     VIRTIO_NET_F_HASH_REPORT,
52     VHOST_INVALID_FEATURE_BIT
53 };
54 
55 /* Features supported by others. */
56 static const int user_feature_bits[] = {
57     VIRTIO_F_NOTIFY_ON_EMPTY,
58     VIRTIO_RING_F_INDIRECT_DESC,
59     VIRTIO_RING_F_EVENT_IDX,
60 
61     VIRTIO_F_ANY_LAYOUT,
62     VIRTIO_F_VERSION_1,
63     VIRTIO_NET_F_CSUM,
64     VIRTIO_NET_F_GUEST_CSUM,
65     VIRTIO_NET_F_GSO,
66     VIRTIO_NET_F_GUEST_TSO4,
67     VIRTIO_NET_F_GUEST_TSO6,
68     VIRTIO_NET_F_GUEST_ECN,
69     VIRTIO_NET_F_GUEST_UFO,
70     VIRTIO_NET_F_HOST_TSO4,
71     VIRTIO_NET_F_HOST_TSO6,
72     VIRTIO_NET_F_HOST_ECN,
73     VIRTIO_NET_F_HOST_UFO,
74     VIRTIO_NET_F_MRG_RXBUF,
75     VIRTIO_NET_F_MTU,
76     VIRTIO_F_IOMMU_PLATFORM,
77     VIRTIO_F_RING_PACKED,
78     VIRTIO_F_RING_RESET,
79     VIRTIO_NET_F_RSS,
80     VIRTIO_NET_F_HASH_REPORT,
81 
82     /* This bit implies RARP isn't sent by QEMU out of band */
83     VIRTIO_NET_F_GUEST_ANNOUNCE,
84 
85     VIRTIO_NET_F_MQ,
86 
87     VHOST_INVALID_FEATURE_BIT
88 };
89 
90 static const int *vhost_net_get_feature_bits(struct vhost_net *net)
91 {
92     const int *feature_bits = 0;
93 
94     switch (net->nc->info->type) {
95     case NET_CLIENT_DRIVER_TAP:
96         feature_bits = kernel_feature_bits;
97         break;
98     case NET_CLIENT_DRIVER_VHOST_USER:
99         feature_bits = user_feature_bits;
100         break;
101 #ifdef CONFIG_VHOST_NET_VDPA
102     case NET_CLIENT_DRIVER_VHOST_VDPA:
103         feature_bits = vdpa_feature_bits;
104         break;
105 #endif
106     default:
107         error_report("Feature bits not defined for this type: %d",
108                 net->nc->info->type);
109         break;
110     }
111 
112     return feature_bits;
113 }
114 
115 uint64_t vhost_net_get_features(struct vhost_net *net, uint64_t features)
116 {
117     return vhost_get_features(&net->dev, vhost_net_get_feature_bits(net),
118             features);
119 }
120 int vhost_net_get_config(struct vhost_net *net,  uint8_t *config,
121                          uint32_t config_len)
122 {
123     return vhost_dev_get_config(&net->dev, config, config_len, NULL);
124 }
125 int vhost_net_set_config(struct vhost_net *net, const uint8_t *data,
126                          uint32_t offset, uint32_t size, uint32_t flags)
127 {
128     return vhost_dev_set_config(&net->dev, data, offset, size, flags);
129 }
130 
131 void vhost_net_ack_features(struct vhost_net *net, uint64_t features)
132 {
133     net->dev.acked_features = net->dev.backend_features;
134     vhost_ack_features(&net->dev, vhost_net_get_feature_bits(net), features);
135 }
136 
137 uint64_t vhost_net_get_max_queues(VHostNetState *net)
138 {
139     return net->dev.max_queues;
140 }
141 
142 uint64_t vhost_net_get_acked_features(VHostNetState *net)
143 {
144     return net->dev.acked_features;
145 }
146 
147 static int vhost_net_get_fd(NetClientState *backend)
148 {
149     switch (backend->info->type) {
150     case NET_CLIENT_DRIVER_TAP:
151         return tap_get_fd(backend);
152     default:
153         fprintf(stderr, "vhost-net requires tap backend\n");
154         return -ENOSYS;
155     }
156 }
157 
158 struct vhost_net *vhost_net_init(VhostNetOptions *options)
159 {
160     int r;
161     bool backend_kernel = options->backend_type == VHOST_BACKEND_TYPE_KERNEL;
162     struct vhost_net *net = g_new0(struct vhost_net, 1);
163     uint64_t features = 0;
164     Error *local_err = NULL;
165 
166     if (!options->net_backend) {
167         fprintf(stderr, "vhost-net requires net backend to be setup\n");
168         goto fail;
169     }
170     net->nc = options->net_backend;
171     net->dev.nvqs = options->nvqs;
172 
173     net->dev.max_queues = 1;
174     net->dev.vqs = net->vqs;
175 
176     if (backend_kernel) {
177         r = vhost_net_get_fd(options->net_backend);
178         if (r < 0) {
179             goto fail;
180         }
181         net->dev.backend_features = qemu_has_vnet_hdr(options->net_backend)
182             ? 0 : (1ULL << VHOST_NET_F_VIRTIO_NET_HDR);
183         net->backend = r;
184         net->dev.protocol_features = 0;
185     } else {
186         net->dev.backend_features = 0;
187         net->dev.protocol_features = 0;
188         net->backend = -1;
189 
190         /* vhost-user needs vq_index to initiate a specific queue pair */
191         net->dev.vq_index = net->nc->queue_index * net->dev.nvqs;
192     }
193 
194     r = vhost_dev_init(&net->dev, options->opaque,
195                        options->backend_type, options->busyloop_timeout,
196                        &local_err);
197     if (r < 0) {
198         error_report_err(local_err);
199         goto fail;
200     }
201     if (backend_kernel) {
202         if (!qemu_has_vnet_hdr_len(options->net_backend,
203                                sizeof(struct virtio_net_hdr_mrg_rxbuf))) {
204             net->dev.features &= ~(1ULL << VIRTIO_NET_F_MRG_RXBUF);
205         }
206         if (~net->dev.features & net->dev.backend_features) {
207             fprintf(stderr, "vhost lacks feature mask 0x%" PRIx64
208                    " for backend\n",
209                    (uint64_t)(~net->dev.features & net->dev.backend_features));
210             goto fail;
211         }
212     }
213 
214     /* Set sane init value. Override when guest acks. */
215 #ifdef CONFIG_VHOST_NET_USER
216     if (net->nc->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
217         features = vhost_user_get_acked_features(net->nc);
218         if (~net->dev.features & features) {
219             fprintf(stderr, "vhost lacks feature mask 0x%" PRIx64
220                     " for backend\n",
221                     (uint64_t)(~net->dev.features & features));
222             goto fail;
223         }
224     }
225 #endif
226 
227     vhost_net_ack_features(net, features);
228 
229     return net;
230 
231 fail:
232     vhost_dev_cleanup(&net->dev);
233     g_free(net);
234     return NULL;
235 }
236 
237 static void vhost_net_set_vq_index(struct vhost_net *net, int vq_index,
238                                    int vq_index_end)
239 {
240     net->dev.vq_index = vq_index;
241     net->dev.vq_index_end = vq_index_end;
242 }
243 
244 static int vhost_net_start_one(struct vhost_net *net,
245                                VirtIODevice *dev)
246 {
247     struct vhost_vring_file file = { };
248     int r;
249 
250     if (net->nc->info->start) {
251         r = net->nc->info->start(net->nc);
252         if (r < 0) {
253             return r;
254         }
255     }
256 
257     r = vhost_dev_enable_notifiers(&net->dev, dev);
258     if (r < 0) {
259         goto fail_notifiers;
260     }
261 
262     r = vhost_dev_start(&net->dev, dev, false);
263     if (r < 0) {
264         goto fail_start;
265     }
266 
267     if (net->nc->info->poll) {
268         net->nc->info->poll(net->nc, false);
269     }
270 
271     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
272         qemu_set_fd_handler(net->backend, NULL, NULL, NULL);
273         file.fd = net->backend;
274         for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
275             if (!virtio_queue_enabled(dev, net->dev.vq_index +
276                                       file.index)) {
277                 /* Queue might not be ready for start */
278                 continue;
279             }
280             r = vhost_net_set_backend(&net->dev, &file);
281             if (r < 0) {
282                 r = -errno;
283                 goto fail;
284             }
285         }
286     }
287 
288     if (net->nc->info->load) {
289         r = net->nc->info->load(net->nc);
290         if (r < 0) {
291             goto fail;
292         }
293     }
294     return 0;
295 fail:
296     file.fd = -1;
297     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
298         while (file.index-- > 0) {
299             if (!virtio_queue_enabled(dev, net->dev.vq_index +
300                                       file.index)) {
301                 /* Queue might not be ready for start */
302                 continue;
303             }
304             int r = vhost_net_set_backend(&net->dev, &file);
305             assert(r >= 0);
306         }
307     }
308     if (net->nc->info->poll) {
309         net->nc->info->poll(net->nc, true);
310     }
311     vhost_dev_stop(&net->dev, dev, false);
312 fail_start:
313     vhost_dev_disable_notifiers(&net->dev, dev);
314 fail_notifiers:
315     return r;
316 }
317 
318 static void vhost_net_stop_one(struct vhost_net *net,
319                                VirtIODevice *dev)
320 {
321     struct vhost_vring_file file = { .fd = -1 };
322 
323     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
324         for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
325             int r = vhost_net_set_backend(&net->dev, &file);
326             assert(r >= 0);
327         }
328     }
329     if (net->nc->info->poll) {
330         net->nc->info->poll(net->nc, true);
331     }
332     vhost_dev_stop(&net->dev, dev, false);
333     if (net->nc->info->stop) {
334         net->nc->info->stop(net->nc);
335     }
336     vhost_dev_disable_notifiers(&net->dev, dev);
337 }
338 
339 int vhost_net_start(VirtIODevice *dev, NetClientState *ncs,
340                     int data_queue_pairs, int cvq)
341 {
342     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
343     VirtioBusState *vbus = VIRTIO_BUS(qbus);
344     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
345     int total_notifiers = data_queue_pairs * 2 + cvq;
346     VirtIONet *n = VIRTIO_NET(dev);
347     int nvhosts = data_queue_pairs + cvq;
348     struct vhost_net *net;
349     int r, e, i, index_end = data_queue_pairs * 2;
350     NetClientState *peer;
351 
352     if (cvq) {
353         index_end += 1;
354     }
355 
356     if (!k->set_guest_notifiers) {
357         error_report("binding does not support guest notifiers");
358         return -ENOSYS;
359     }
360 
361     for (i = 0; i < nvhosts; i++) {
362 
363         if (i < data_queue_pairs) {
364             peer = qemu_get_peer(ncs, i);
365         } else { /* Control Virtqueue */
366             peer = qemu_get_peer(ncs, n->max_queue_pairs);
367         }
368 
369         net = get_vhost_net(peer);
370         vhost_net_set_vq_index(net, i * 2, index_end);
371 
372         /* Suppress the masking guest notifiers on vhost user
373          * because vhost user doesn't interrupt masking/unmasking
374          * properly.
375          */
376         if (net->nc->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
377             dev->use_guest_notifier_mask = false;
378         }
379      }
380 
381     r = k->set_guest_notifiers(qbus->parent, total_notifiers, true);
382     if (r < 0) {
383         error_report("Error binding guest notifier: %d", -r);
384         goto err;
385     }
386 
387     for (i = 0; i < nvhosts; i++) {
388         if (i < data_queue_pairs) {
389             peer = qemu_get_peer(ncs, i);
390         } else {
391             peer = qemu_get_peer(ncs, n->max_queue_pairs);
392         }
393 
394         if (peer->vring_enable) {
395             /* restore vring enable state */
396             r = vhost_set_vring_enable(peer, peer->vring_enable);
397 
398             if (r < 0) {
399                 goto err_start;
400             }
401         }
402 
403         r = vhost_net_start_one(get_vhost_net(peer), dev);
404         if (r < 0) {
405             goto err_start;
406         }
407     }
408 
409     return 0;
410 
411 err_start:
412     while (--i >= 0) {
413         peer = qemu_get_peer(ncs, i < data_queue_pairs ?
414                                   i : n->max_queue_pairs);
415         vhost_net_stop_one(get_vhost_net(peer), dev);
416     }
417     e = k->set_guest_notifiers(qbus->parent, total_notifiers, false);
418     if (e < 0) {
419         fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", e);
420         fflush(stderr);
421     }
422 err:
423     return r;
424 }
425 
426 void vhost_net_stop(VirtIODevice *dev, NetClientState *ncs,
427                     int data_queue_pairs, int cvq)
428 {
429     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
430     VirtioBusState *vbus = VIRTIO_BUS(qbus);
431     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
432     VirtIONet *n = VIRTIO_NET(dev);
433     NetClientState *peer;
434     int total_notifiers = data_queue_pairs * 2 + cvq;
435     int nvhosts = data_queue_pairs + cvq;
436     int i, r;
437 
438     for (i = 0; i < nvhosts; i++) {
439         if (i < data_queue_pairs) {
440             peer = qemu_get_peer(ncs, i);
441         } else {
442             peer = qemu_get_peer(ncs, n->max_queue_pairs);
443         }
444         vhost_net_stop_one(get_vhost_net(peer), dev);
445     }
446 
447     r = k->set_guest_notifiers(qbus->parent, total_notifiers, false);
448     if (r < 0) {
449         fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", r);
450         fflush(stderr);
451     }
452     assert(r >= 0);
453 }
454 
455 void vhost_net_cleanup(struct vhost_net *net)
456 {
457     vhost_dev_cleanup(&net->dev);
458 }
459 
460 int vhost_net_notify_migration_done(struct vhost_net *net, char* mac_addr)
461 {
462     const VhostOps *vhost_ops = net->dev.vhost_ops;
463 
464     assert(vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
465     assert(vhost_ops->vhost_migration_done);
466 
467     return vhost_ops->vhost_migration_done(&net->dev, mac_addr);
468 }
469 
470 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
471 {
472     return vhost_virtqueue_pending(&net->dev, idx);
473 }
474 
475 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
476                               int idx, bool mask)
477 {
478     vhost_virtqueue_mask(&net->dev, dev, idx, mask);
479 }
480 
481 VHostNetState *get_vhost_net(NetClientState *nc)
482 {
483     VHostNetState *vhost_net = 0;
484 
485     if (!nc) {
486         return 0;
487     }
488 
489     switch (nc->info->type) {
490     case NET_CLIENT_DRIVER_TAP:
491         vhost_net = tap_get_vhost_net(nc);
492         break;
493 #ifdef CONFIG_VHOST_NET_USER
494     case NET_CLIENT_DRIVER_VHOST_USER:
495         vhost_net = vhost_user_get_vhost_net(nc);
496         assert(vhost_net);
497         break;
498 #endif
499 #ifdef CONFIG_VHOST_NET_VDPA
500     case NET_CLIENT_DRIVER_VHOST_VDPA:
501         vhost_net = vhost_vdpa_get_vhost_net(nc);
502         assert(vhost_net);
503         break;
504 #endif
505     default:
506         break;
507     }
508 
509     return vhost_net;
510 }
511 
512 int vhost_set_vring_enable(NetClientState *nc, int enable)
513 {
514     VHostNetState *net = get_vhost_net(nc);
515     const VhostOps *vhost_ops = net->dev.vhost_ops;
516 
517     nc->vring_enable = enable;
518 
519     if (vhost_ops && vhost_ops->vhost_set_vring_enable) {
520         return vhost_ops->vhost_set_vring_enable(&net->dev, enable);
521     }
522 
523     return 0;
524 }
525 
526 int vhost_net_set_mtu(struct vhost_net *net, uint16_t mtu)
527 {
528     const VhostOps *vhost_ops = net->dev.vhost_ops;
529 
530     if (!vhost_ops->vhost_net_set_mtu) {
531         return 0;
532     }
533 
534     return vhost_ops->vhost_net_set_mtu(&net->dev, mtu);
535 }
536 
537 void vhost_net_virtqueue_reset(VirtIODevice *vdev, NetClientState *nc,
538                                int vq_index)
539 {
540     VHostNetState *net = get_vhost_net(nc->peer);
541     const VhostOps *vhost_ops = net->dev.vhost_ops;
542     struct vhost_vring_file file = { .fd = -1 };
543     int idx;
544 
545     /* should only be called after backend is connected */
546     assert(vhost_ops);
547 
548     idx = vhost_ops->vhost_get_vq_index(&net->dev, vq_index);
549 
550     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
551         file.index = idx;
552         int r = vhost_net_set_backend(&net->dev, &file);
553         assert(r >= 0);
554     }
555 
556     vhost_virtqueue_stop(&net->dev,
557                          vdev,
558                          net->dev.vqs + idx,
559                          net->dev.vq_index + idx);
560 }
561 
562 int vhost_net_virtqueue_restart(VirtIODevice *vdev, NetClientState *nc,
563                                 int vq_index)
564 {
565     VHostNetState *net = get_vhost_net(nc->peer);
566     const VhostOps *vhost_ops = net->dev.vhost_ops;
567     struct vhost_vring_file file = { };
568     int idx, r;
569 
570     if (!net->dev.started) {
571         return -EBUSY;
572     }
573 
574     /* should only be called after backend is connected */
575     assert(vhost_ops);
576 
577     idx = vhost_ops->vhost_get_vq_index(&net->dev, vq_index);
578 
579     r = vhost_virtqueue_start(&net->dev,
580                               vdev,
581                               net->dev.vqs + idx,
582                               net->dev.vq_index + idx);
583     if (r < 0) {
584         goto err_start;
585     }
586 
587     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
588         file.index = idx;
589         file.fd = net->backend;
590         r = vhost_net_set_backend(&net->dev, &file);
591         if (r < 0) {
592             r = -errno;
593             goto err_start;
594         }
595     }
596 
597     return 0;
598 
599 err_start:
600     error_report("Error when restarting the queue.");
601 
602     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
603         file.fd = VHOST_FILE_UNBIND;
604         file.index = idx;
605         int r = vhost_net_set_backend(&net->dev, &file);
606         assert(r >= 0);
607     }
608 
609     vhost_dev_stop(&net->dev, vdev, false);
610 
611     return r;
612 }
613