xref: /openbmc/qemu/hw/net/vhost_net.c (revision 5111edaf)
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 
169     net->dev.max_queues = 1;
170     net->dev.nvqs = 2;
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     net->dev.nvqs = 2;
246     net->dev.vqs = net->vqs;
247 
248     r = vhost_dev_enable_notifiers(&net->dev, dev);
249     if (r < 0) {
250         goto fail_notifiers;
251     }
252 
253     r = vhost_dev_start(&net->dev, dev);
254     if (r < 0) {
255         goto fail_start;
256     }
257 
258     if (net->nc->info->poll) {
259         net->nc->info->poll(net->nc, false);
260     }
261 
262     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
263         qemu_set_fd_handler(net->backend, NULL, NULL, NULL);
264         file.fd = net->backend;
265         for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
266             if (!virtio_queue_enabled(dev, net->dev.vq_index +
267                                       file.index)) {
268                 /* Queue might not be ready for start */
269                 continue;
270             }
271             r = vhost_net_set_backend(&net->dev, &file);
272             if (r < 0) {
273                 r = -errno;
274                 goto fail;
275             }
276         }
277     }
278     return 0;
279 fail:
280     file.fd = -1;
281     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
282         while (file.index-- > 0) {
283             if (!virtio_queue_enabled(dev, net->dev.vq_index +
284                                       file.index)) {
285                 /* Queue might not be ready for start */
286                 continue;
287             }
288             int r = vhost_net_set_backend(&net->dev, &file);
289             assert(r >= 0);
290         }
291     }
292     if (net->nc->info->poll) {
293         net->nc->info->poll(net->nc, true);
294     }
295     vhost_dev_stop(&net->dev, dev);
296 fail_start:
297     vhost_dev_disable_notifiers(&net->dev, dev);
298 fail_notifiers:
299     return r;
300 }
301 
302 static void vhost_net_stop_one(struct vhost_net *net,
303                                VirtIODevice *dev)
304 {
305     struct vhost_vring_file file = { .fd = -1 };
306 
307     if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
308         for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
309             int r = vhost_net_set_backend(&net->dev, &file);
310             assert(r >= 0);
311         }
312     }
313     if (net->nc->info->poll) {
314         net->nc->info->poll(net->nc, true);
315     }
316     vhost_dev_stop(&net->dev, dev);
317     vhost_dev_disable_notifiers(&net->dev, dev);
318 }
319 
320 int vhost_net_start(VirtIODevice *dev, NetClientState *ncs,
321                     int total_queues)
322 {
323     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
324     VirtioBusState *vbus = VIRTIO_BUS(qbus);
325     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
326     struct vhost_net *net;
327     int r, e, i;
328     NetClientState *peer;
329 
330     if (!k->set_guest_notifiers) {
331         error_report("binding does not support guest notifiers");
332         return -ENOSYS;
333     }
334 
335     for (i = 0; i < total_queues; i++) {
336 
337         peer = qemu_get_peer(ncs, i);
338         net = get_vhost_net(peer);
339         vhost_net_set_vq_index(net, i * 2);
340 
341         /* Suppress the masking guest notifiers on vhost user
342          * because vhost user doesn't interrupt masking/unmasking
343          * properly.
344          */
345         if (net->nc->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
346             dev->use_guest_notifier_mask = false;
347         }
348      }
349 
350     r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true);
351     if (r < 0) {
352         error_report("Error binding guest notifier: %d", -r);
353         goto err;
354     }
355 
356     for (i = 0; i < total_queues; i++) {
357         peer = qemu_get_peer(ncs, i);
358         r = vhost_net_start_one(get_vhost_net(peer), dev);
359 
360         if (r < 0) {
361             goto err_start;
362         }
363 
364         if (peer->vring_enable) {
365             /* restore vring enable state */
366             r = vhost_set_vring_enable(peer, peer->vring_enable);
367 
368             if (r < 0) {
369                 goto err_start;
370             }
371         }
372     }
373 
374     return 0;
375 
376 err_start:
377     while (--i >= 0) {
378         peer = qemu_get_peer(ncs , i);
379         vhost_net_stop_one(get_vhost_net(peer), dev);
380     }
381     e = k->set_guest_notifiers(qbus->parent, total_queues * 2, false);
382     if (e < 0) {
383         fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", e);
384         fflush(stderr);
385     }
386 err:
387     return r;
388 }
389 
390 void vhost_net_stop(VirtIODevice *dev, NetClientState *ncs,
391                     int total_queues)
392 {
393     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
394     VirtioBusState *vbus = VIRTIO_BUS(qbus);
395     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
396     int i, r;
397 
398     for (i = 0; i < total_queues; i++) {
399         vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev);
400     }
401 
402     r = k->set_guest_notifiers(qbus->parent, total_queues * 2, false);
403     if (r < 0) {
404         fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", r);
405         fflush(stderr);
406     }
407     assert(r >= 0);
408 }
409 
410 void vhost_net_cleanup(struct vhost_net *net)
411 {
412     vhost_dev_cleanup(&net->dev);
413 }
414 
415 int vhost_net_notify_migration_done(struct vhost_net *net, char* mac_addr)
416 {
417     const VhostOps *vhost_ops = net->dev.vhost_ops;
418 
419     assert(vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
420     assert(vhost_ops->vhost_migration_done);
421 
422     return vhost_ops->vhost_migration_done(&net->dev, mac_addr);
423 }
424 
425 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
426 {
427     return vhost_virtqueue_pending(&net->dev, idx);
428 }
429 
430 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
431                               int idx, bool mask)
432 {
433     vhost_virtqueue_mask(&net->dev, dev, idx, mask);
434 }
435 
436 VHostNetState *get_vhost_net(NetClientState *nc)
437 {
438     VHostNetState *vhost_net = 0;
439 
440     if (!nc) {
441         return 0;
442     }
443 
444     switch (nc->info->type) {
445     case NET_CLIENT_DRIVER_TAP:
446         vhost_net = tap_get_vhost_net(nc);
447         break;
448 #ifdef CONFIG_VHOST_NET_USER
449     case NET_CLIENT_DRIVER_VHOST_USER:
450         vhost_net = vhost_user_get_vhost_net(nc);
451         assert(vhost_net);
452         break;
453 #endif
454 #ifdef CONFIG_VHOST_NET_VDPA
455     case NET_CLIENT_DRIVER_VHOST_VDPA:
456         vhost_net = vhost_vdpa_get_vhost_net(nc);
457         assert(vhost_net);
458         break;
459 #endif
460     default:
461         break;
462     }
463 
464     return vhost_net;
465 }
466 
467 int vhost_set_vring_enable(NetClientState *nc, int enable)
468 {
469     VHostNetState *net = get_vhost_net(nc);
470     const VhostOps *vhost_ops = net->dev.vhost_ops;
471 
472     nc->vring_enable = enable;
473 
474     if (vhost_ops && vhost_ops->vhost_set_vring_enable) {
475         return vhost_ops->vhost_set_vring_enable(&net->dev, enable);
476     }
477 
478     return 0;
479 }
480 
481 int vhost_net_set_mtu(struct vhost_net *net, uint16_t mtu)
482 {
483     const VhostOps *vhost_ops = net->dev.vhost_ops;
484 
485     if (!vhost_ops->vhost_net_set_mtu) {
486         return 0;
487     }
488 
489     return vhost_ops->vhost_net_set_mtu(&net->dev, mtu);
490 }
491