xref: /qemu/hw/net/vhost_net.c (revision b355f08a) 
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 
38 
39 /* Features supported by host kernel. */
40 static const int kernel_feature_bits[] = {
41     VIRTIO_F_NOTIFY_ON_EMPTY,
42     VIRTIO_RING_F_INDIRECT_DESC,
43     VIRTIO_RING_F_EVENT_IDX,
44     VIRTIO_NET_F_MRG_RXBUF,
45     VIRTIO_F_VERSION_1,
46     VIRTIO_NET_F_MTU,
47     VIRTIO_F_IOMMU_PLATFORM,
48     VIRTIO_F_RING_PACKED,
49     VIRTIO_NET_F_HASH_REPORT,
50     VHOST_INVALID_FEATURE_BIT
51 };
52 
53 /* Features supported by others. */
54 static const int user_feature_bits[] = {
55     VIRTIO_F_NOTIFY_ON_EMPTY,
56     VIRTIO_RING_F_INDIRECT_DESC,
57     VIRTIO_RING_F_EVENT_IDX,
58 
59     VIRTIO_F_ANY_LAYOUT,
60     VIRTIO_F_VERSION_1,
61     VIRTIO_NET_F_CSUM,
62     VIRTIO_NET_F_GUEST_CSUM,
63     VIRTIO_NET_F_GSO,
64     VIRTIO_NET_F_GUEST_TSO4,
65     VIRTIO_NET_F_GUEST_TSO6,
66     VIRTIO_NET_F_GUEST_ECN,
67     VIRTIO_NET_F_GUEST_UFO,
68     VIRTIO_NET_F_HOST_TSO4,
69     VIRTIO_NET_F_HOST_TSO6,
70     VIRTIO_NET_F_HOST_ECN,
71     VIRTIO_NET_F_HOST_UFO,
72     VIRTIO_NET_F_MRG_RXBUF,
73     VIRTIO_NET_F_MTU,
74     VIRTIO_F_IOMMU_PLATFORM,
75     VIRTIO_F_RING_PACKED,
76     VIRTIO_NET_F_RSS,
77     VIRTIO_NET_F_HASH_REPORT,
78 
79     /* This bit implies RARP isn't sent by QEMU out of band */
80     VIRTIO_NET_F_GUEST_ANNOUNCE,
81 
82     VIRTIO_NET_F_MQ,
83 
84     VHOST_INVALID_FEATURE_BIT
85 };
86 
87 static const int *vhost_net_get_feature_bits(struct vhost_net *net)
88 {
89     const int *feature_bits = 0;
90 
91     switch (net->nc->info->type) {
92     case NET_CLIENT_DRIVER_TAP:
93         feature_bits = kernel_feature_bits;
94         break;
95     case NET_CLIENT_DRIVER_VHOST_USER:
96         feature_bits = user_feature_bits;
97         break;
98 #ifdef CONFIG_VHOST_NET_VDPA
99     case NET_CLIENT_DRIVER_VHOST_VDPA:
100         feature_bits = vdpa_feature_bits;
101         break;
102 #endif
103     default:
104         error_report("Feature bits not defined for this type: %d",
105                 net->nc->info->type);
106         break;
107     }
108 
109     return feature_bits;
110 }
111 
112 uint64_t vhost_net_get_features(struct vhost_net *net, uint64_t features)
113 {
114     return vhost_get_features(&net->dev, vhost_net_get_feature_bits(net),
115             features);
116 }
117 int vhost_net_get_config(struct vhost_net *net,  uint8_t *config,
118                          uint32_t config_len)
119 {
120     return vhost_dev_get_config(&net->dev, config, config_len, NULL);
121 }
122 int vhost_net_set_config(struct vhost_net *net, const uint8_t *data,
123                          uint32_t offset, uint32_t size, uint32_t flags)
124 {
125     return vhost_dev_set_config(&net->dev, data, offset, size, flags);
126 }
127 
128 void vhost_net_ack_features(struct vhost_net *net, uint64_t features)
129 {
130     net->dev.acked_features = net->dev.backend_features;
131     vhost_ack_features(&net->dev, vhost_net_get_feature_bits(net), features);
132 }
133 
134 uint64_t vhost_net_get_max_queues(VHostNetState *net)
135 {
136     return net->dev.max_queues;
137 }
138 
139 uint64_t vhost_net_get_acked_features(VHostNetState *net)
140 {
141     return net->dev.acked_features;
142 }
143 
144 static int vhost_net_get_fd(NetClientState *backend)
145 {
146     switch (backend->info->type) {
147     case NET_CLIENT_DRIVER_TAP:
148         return tap_get_fd(backend);
149     default:
150         fprintf(stderr, "vhost-net requires tap backend\n");
151         return -ENOSYS;
152     }
153 }
154 
155 struct vhost_net *vhost_net_init(VhostNetOptions *options)
156 {
157     int r;
158     bool backend_kernel = options->backend_type == VHOST_BACKEND_TYPE_KERNEL;
159     struct vhost_net *net = g_new0(struct vhost_net, 1);
160     uint64_t features = 0;
161     Error *local_err = NULL;
162 
163     if (!options->net_backend) {
164         fprintf(stderr, "vhost-net requires net backend to be setup\n");
165         goto fail;
166     }
167     net->nc = options->net_backend;
168     net->dev.nvqs = options->nvqs;
169 
170     net->dev.max_queues = 1;
171     net->dev.vqs = net->vqs;
172 
173     if (backend_kernel) {
174         r = vhost_net_get_fd(options->net_backend);
175         if (r < 0) {
176             goto fail;
177         }
178         net->dev.backend_features = qemu_has_vnet_hdr(options->net_backend)
179             ? 0 : (1ULL << VHOST_NET_F_VIRTIO_NET_HDR);
180         net->backend = r;
181         net->dev.protocol_features = 0;
182     } else {
183         net->dev.backend_features = 0;
184         net->dev.protocol_features = 0;
185         net->backend = -1;
186 
187         /* vhost-user needs vq_index to initiate a specific queue pair */
188         net->dev.vq_index = net->nc->queue_index * net->dev.nvqs;
189     }
190 
191     r = vhost_dev_init(&net->dev, options->opaque,
192                        options->backend_type, options->busyloop_timeout,
193                        &local_err);
194     if (r < 0) {
195         error_report_err(local_err);
196         goto fail;
197     }
198     if (backend_kernel) {
199         if (!qemu_has_vnet_hdr_len(options->net_backend,
200                                sizeof(struct virtio_net_hdr_mrg_rxbuf))) {
201             net->dev.features &= ~(1ULL << VIRTIO_NET_F_MRG_RXBUF);
202         }
203         if (~net->dev.features & net->dev.backend_features) {
204             fprintf(stderr, "vhost lacks feature mask %" PRIu64
205                    " for backend\n",
206                    (uint64_t)(~net->dev.features & net->dev.backend_features));
207             goto fail;
208         }
209     }
210 
211     /* Set sane init value. Override when guest acks. */
212 #ifdef CONFIG_VHOST_NET_USER
213     if (net->nc->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
214         features = vhost_user_get_acked_features(net->nc);
215         if (~net->dev.features & features) {
216             fprintf(stderr, "vhost lacks feature mask %" PRIu64
217                     " for backend\n",
218                     (uint64_t)(~net->dev.features & features));
219             goto fail;
220         }
221     }
222 #endif
223 
224     vhost_net_ack_features(net, features);
225 
226     return net;
227 
228 fail:
229     vhost_dev_cleanup(&net->dev);
230     g_free(net);
231     return NULL;
232 }
233 
234 static void vhost_net_set_vq_index(struct vhost_net *net, int vq_index)
235 {
236     net->dev.vq_index = vq_index;
237 }
238 
239 static int vhost_net_start_one(struct vhost_net *net,
240                                VirtIODevice *dev)
241 {
242     struct vhost_vring_file file = { };
243     int r;
244 
245     r = vhost_dev_enable_notifiers(&net->dev, dev);
246     if (r < 0) {
247         goto fail_notifiers;
248     }
249 
250     r = vhost_dev_start(&net->dev, dev);
251     if (r < 0) {
252         goto fail_start;
253     }
254 
255     if (net->nc->info->poll) {
256         net->nc->info->poll(net->nc, false);
257     }
258 
259     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
260         qemu_set_fd_handler(net->backend, NULL, NULL, NULL);
261         file.fd = net->backend;
262         for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
263             if (!virtio_queue_enabled(dev, net->dev.vq_index +
264                                       file.index)) {
265                 /* Queue might not be ready for start */
266                 continue;
267             }
268             r = vhost_net_set_backend(&net->dev, &file);
269             if (r < 0) {
270                 r = -errno;
271                 goto fail;
272             }
273         }
274     }
275     return 0;
276 fail:
277     file.fd = -1;
278     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
279         while (file.index-- > 0) {
280             if (!virtio_queue_enabled(dev, net->dev.vq_index +
281                                       file.index)) {
282                 /* Queue might not be ready for start */
283                 continue;
284             }
285             int r = vhost_net_set_backend(&net->dev, &file);
286             assert(r >= 0);
287         }
288     }
289     if (net->nc->info->poll) {
290         net->nc->info->poll(net->nc, true);
291     }
292     vhost_dev_stop(&net->dev, dev);
293 fail_start:
294     vhost_dev_disable_notifiers(&net->dev, dev);
295 fail_notifiers:
296     return r;
297 }
298 
299 static void vhost_net_stop_one(struct vhost_net *net,
300                                VirtIODevice *dev)
301 {
302     struct vhost_vring_file file = { .fd = -1 };
303 
304     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
305         for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
306             int r = vhost_net_set_backend(&net->dev, &file);
307             assert(r >= 0);
308         }
309     }
310     if (net->nc->info->poll) {
311         net->nc->info->poll(net->nc, true);
312     }
313     vhost_dev_stop(&net->dev, dev);
314     vhost_dev_disable_notifiers(&net->dev, dev);
315 }
316 
317 int vhost_net_start(VirtIODevice *dev, NetClientState *ncs,
318                     int total_queues)
319 {
320     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
321     VirtioBusState *vbus = VIRTIO_BUS(qbus);
322     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
323     struct vhost_net *net;
324     int r, e, i;
325     NetClientState *peer;
326 
327     if (!k->set_guest_notifiers) {
328         error_report("binding does not support guest notifiers");
329         return -ENOSYS;
330     }
331 
332     for (i = 0; i < total_queues; i++) {
333 
334         peer = qemu_get_peer(ncs, i);
335         net = get_vhost_net(peer);
336         vhost_net_set_vq_index(net, i * 2);
337 
338         /* Suppress the masking guest notifiers on vhost user
339          * because vhost user doesn't interrupt masking/unmasking
340          * properly.
341          */
342         if (net->nc->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
343             dev->use_guest_notifier_mask = false;
344         }
345      }
346 
347     r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true);
348     if (r < 0) {
349         error_report("Error binding guest notifier: %d", -r);
350         goto err;
351     }
352 
353     for (i = 0; i < total_queues; i++) {
354         peer = qemu_get_peer(ncs, i);
355         r = vhost_net_start_one(get_vhost_net(peer), dev);
356 
357         if (r < 0) {
358             goto err_start;
359         }
360 
361         if (peer->vring_enable) {
362             /* restore vring enable state */
363             r = vhost_set_vring_enable(peer, peer->vring_enable);
364 
365             if (r < 0) {
366                 goto err_start;
367             }
368         }
369     }
370 
371     return 0;
372 
373 err_start:
374     while (--i >= 0) {
375         peer = qemu_get_peer(ncs , i);
376         vhost_net_stop_one(get_vhost_net(peer), dev);
377     }
378     e = k->set_guest_notifiers(qbus->parent, total_queues * 2, false);
379     if (e < 0) {
380         fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", e);
381         fflush(stderr);
382     }
383 err:
384     return r;
385 }
386 
387 void vhost_net_stop(VirtIODevice *dev, NetClientState *ncs,
388                     int total_queues)
389 {
390     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
391     VirtioBusState *vbus = VIRTIO_BUS(qbus);
392     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
393     int i, r;
394 
395     for (i = 0; i < total_queues; i++) {
396         vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev);
397     }
398 
399     r = k->set_guest_notifiers(qbus->parent, total_queues * 2, false);
400     if (r < 0) {
401         fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", r);
402         fflush(stderr);
403     }
404     assert(r >= 0);
405 }
406 
407 void vhost_net_cleanup(struct vhost_net *net)
408 {
409     vhost_dev_cleanup(&net->dev);
410 }
411 
412 int vhost_net_notify_migration_done(struct vhost_net *net, char* mac_addr)
413 {
414     const VhostOps *vhost_ops = net->dev.vhost_ops;
415 
416     assert(vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
417     assert(vhost_ops->vhost_migration_done);
418 
419     return vhost_ops->vhost_migration_done(&net->dev, mac_addr);
420 }
421 
422 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
423 {
424     return vhost_virtqueue_pending(&net->dev, idx);
425 }
426 
427 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
428                               int idx, bool mask)
429 {
430     vhost_virtqueue_mask(&net->dev, dev, idx, mask);
431 }
432 
433 VHostNetState *get_vhost_net(NetClientState *nc)
434 {
435     VHostNetState *vhost_net = 0;
436 
437     if (!nc) {
438         return 0;
439     }
440 
441     switch (nc->info->type) {
442     case NET_CLIENT_DRIVER_TAP:
443         vhost_net = tap_get_vhost_net(nc);
444         break;
445 #ifdef CONFIG_VHOST_NET_USER
446     case NET_CLIENT_DRIVER_VHOST_USER:
447         vhost_net = vhost_user_get_vhost_net(nc);
448         assert(vhost_net);
449         break;
450 #endif
451 #ifdef CONFIG_VHOST_NET_VDPA
452     case NET_CLIENT_DRIVER_VHOST_VDPA:
453         vhost_net = vhost_vdpa_get_vhost_net(nc);
454         assert(vhost_net);
455         break;
456 #endif
457     default:
458         break;
459     }
460 
461     return vhost_net;
462 }
463 
464 int vhost_set_vring_enable(NetClientState *nc, int enable)
465 {
466     VHostNetState *net = get_vhost_net(nc);
467     const VhostOps *vhost_ops = net->dev.vhost_ops;
468 
469     nc->vring_enable = enable;
470 
471     if (vhost_ops && vhost_ops->vhost_set_vring_enable) {
472         return vhost_ops->vhost_set_vring_enable(&net->dev, enable);
473     }
474 
475     return 0;
476 }
477 
478 int vhost_net_set_mtu(struct vhost_net *net, uint16_t mtu)
479 {
480     const VhostOps *vhost_ops = net->dev.vhost_ops;
481 
482     if (!vhost_ops->vhost_net_set_mtu) {
483         return 0;
484     }
485 
486     return vhost_ops->vhost_net_set_mtu(&net->dev, mtu);
487 }
488