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
vhost_net_get_feature_bits(struct vhost_net * net)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
vhost_net_get_features(struct vhost_net * net,uint64_t features)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 }
vhost_net_get_config(struct vhost_net * net,uint8_t * config,uint32_t config_len)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 }
vhost_net_set_config(struct vhost_net * net,const uint8_t * data,uint32_t offset,uint32_t size,uint32_t flags)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
vhost_net_ack_features(struct vhost_net * net,uint64_t features)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
vhost_net_get_max_queues(VHostNetState * net)134 uint64_t vhost_net_get_max_queues(VHostNetState *net)
135 {
136 return net->dev.max_queues;
137 }
138
vhost_net_get_acked_features(VHostNetState * net)139 uint64_t vhost_net_get_acked_features(VHostNetState *net)
140 {
141 return net->dev.acked_features;
142 }
143
vhost_net_get_fd(NetClientState * backend)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
vhost_net_init(VhostNetOptions * options)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
vhost_net_set_vq_index(struct vhost_net * net,int vq_index)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
vhost_net_start_one(struct vhost_net * net,VirtIODevice * dev)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
vhost_net_stop_one(struct vhost_net * net,VirtIODevice * dev)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
vhost_net_start(VirtIODevice * dev,NetClientState * ncs,int total_queues)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
vhost_net_stop(VirtIODevice * dev,NetClientState * ncs,int total_queues)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
vhost_net_cleanup(struct vhost_net * net)407 void vhost_net_cleanup(struct vhost_net *net)
408 {
409 vhost_dev_cleanup(&net->dev);
410 }
411
vhost_net_notify_migration_done(struct vhost_net * net,char * mac_addr)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
vhost_net_virtqueue_pending(VHostNetState * net,int idx)422 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
423 {
424 return vhost_virtqueue_pending(&net->dev, idx);
425 }
426
vhost_net_virtqueue_mask(VHostNetState * net,VirtIODevice * dev,int idx,bool mask)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
get_vhost_net(NetClientState * nc)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
vhost_set_vring_enable(NetClientState * nc,int enable)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
vhost_net_set_mtu(struct vhost_net * net,uint16_t mtu)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