4 * Copyright Red Hat, Inc. 2010
7 * Michael S. Tsirkin <mst@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
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.
16 #include "qemu/osdep.h"
19 #include "net/vhost-user.h"
21 #include "hw/virtio/virtio-net.h"
22 #include "net/vhost_net.h"
23 #include "qemu/error-report.h"
26 #ifdef CONFIG_VHOST_NET
27 #include <linux/vhost.h>
28 #include <sys/socket.h>
29 #include <linux/kvm.h>
30 #include <netpacket/packet.h>
31 #include <net/ethernet.h>
33 #include <netinet/in.h>
36 #include "standard-headers/linux/virtio_ring.h"
37 #include "hw/virtio/vhost.h"
38 #include "hw/virtio/virtio-bus.h"
42 struct vhost_virtqueue vqs
[2];
47 /* Features supported by host kernel. */
48 static const int kernel_feature_bits
[] = {
49 VIRTIO_F_NOTIFY_ON_EMPTY
,
50 VIRTIO_RING_F_INDIRECT_DESC
,
51 VIRTIO_RING_F_EVENT_IDX
,
52 VIRTIO_NET_F_MRG_RXBUF
,
55 VHOST_INVALID_FEATURE_BIT
58 /* Features supported by others. */
59 static const int user_feature_bits
[] = {
60 VIRTIO_F_NOTIFY_ON_EMPTY
,
61 VIRTIO_RING_F_INDIRECT_DESC
,
62 VIRTIO_RING_F_EVENT_IDX
,
67 VIRTIO_NET_F_GUEST_CSUM
,
69 VIRTIO_NET_F_GUEST_TSO4
,
70 VIRTIO_NET_F_GUEST_TSO6
,
71 VIRTIO_NET_F_GUEST_ECN
,
72 VIRTIO_NET_F_GUEST_UFO
,
73 VIRTIO_NET_F_HOST_TSO4
,
74 VIRTIO_NET_F_HOST_TSO6
,
75 VIRTIO_NET_F_HOST_ECN
,
76 VIRTIO_NET_F_HOST_UFO
,
77 VIRTIO_NET_F_MRG_RXBUF
,
80 /* This bit implies RARP isn't sent by QEMU out of band */
81 VIRTIO_NET_F_GUEST_ANNOUNCE
,
85 VHOST_INVALID_FEATURE_BIT
88 static const int *vhost_net_get_feature_bits(struct vhost_net
*net
)
90 const int *feature_bits
= 0;
92 switch (net
->nc
->info
->type
) {
93 case NET_CLIENT_DRIVER_TAP
:
94 feature_bits
= kernel_feature_bits
;
96 case NET_CLIENT_DRIVER_VHOST_USER
:
97 feature_bits
= user_feature_bits
;
100 error_report("Feature bits not defined for this type: %d",
101 net
->nc
->info
->type
);
108 uint64_t vhost_net_get_features(struct vhost_net
*net
, uint64_t features
)
110 return vhost_get_features(&net
->dev
, vhost_net_get_feature_bits(net
),
114 void vhost_net_ack_features(struct vhost_net
*net
, uint64_t features
)
116 net
->dev
.acked_features
= net
->dev
.backend_features
;
117 vhost_ack_features(&net
->dev
, vhost_net_get_feature_bits(net
), features
);
120 uint64_t vhost_net_get_max_queues(VHostNetState
*net
)
122 return net
->dev
.max_queues
;
125 uint64_t vhost_net_get_acked_features(VHostNetState
*net
)
127 return net
->dev
.acked_features
;
130 static int vhost_net_get_fd(NetClientState
*backend
)
132 switch (backend
->info
->type
) {
133 case NET_CLIENT_DRIVER_TAP
:
134 return tap_get_fd(backend
);
136 fprintf(stderr
, "vhost-net requires tap backend\n");
141 struct vhost_net
*vhost_net_init(VhostNetOptions
*options
)
144 bool backend_kernel
= options
->backend_type
== VHOST_BACKEND_TYPE_KERNEL
;
145 struct vhost_net
*net
= g_new0(struct vhost_net
, 1);
146 uint64_t features
= 0;
148 if (!options
->net_backend
) {
149 fprintf(stderr
, "vhost-net requires net backend to be setup\n");
152 net
->nc
= options
->net_backend
;
154 net
->dev
.max_queues
= 1;
156 net
->dev
.vqs
= net
->vqs
;
158 if (backend_kernel
) {
159 r
= vhost_net_get_fd(options
->net_backend
);
163 net
->dev
.backend_features
= qemu_has_vnet_hdr(options
->net_backend
)
164 ? 0 : (1ULL << VHOST_NET_F_VIRTIO_NET_HDR
);
166 net
->dev
.protocol_features
= 0;
168 net
->dev
.backend_features
= 0;
169 net
->dev
.protocol_features
= 0;
172 /* vhost-user needs vq_index to initiate a specific queue pair */
173 net
->dev
.vq_index
= net
->nc
->queue_index
* net
->dev
.nvqs
;
176 r
= vhost_dev_init(&net
->dev
, options
->opaque
,
177 options
->backend_type
, options
->busyloop_timeout
);
181 if (backend_kernel
) {
182 if (!qemu_has_vnet_hdr_len(options
->net_backend
,
183 sizeof(struct virtio_net_hdr_mrg_rxbuf
))) {
184 net
->dev
.features
&= ~(1ULL << VIRTIO_NET_F_MRG_RXBUF
);
186 if (~net
->dev
.features
& net
->dev
.backend_features
) {
187 fprintf(stderr
, "vhost lacks feature mask %" PRIu64
189 (uint64_t)(~net
->dev
.features
& net
->dev
.backend_features
));
194 /* Set sane init value. Override when guest acks. */
195 if (net
->nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
) {
196 features
= vhost_user_get_acked_features(net
->nc
);
197 if (~net
->dev
.features
& features
) {
198 fprintf(stderr
, "vhost lacks feature mask %" PRIu64
200 (uint64_t)(~net
->dev
.features
& features
));
205 vhost_net_ack_features(net
, features
);
210 vhost_dev_cleanup(&net
->dev
);
215 static void vhost_net_set_vq_index(struct vhost_net
*net
, int vq_index
)
217 net
->dev
.vq_index
= vq_index
;
220 static int vhost_net_start_one(struct vhost_net
*net
,
223 struct vhost_vring_file file
= { };
227 net
->dev
.vqs
= net
->vqs
;
229 r
= vhost_dev_enable_notifiers(&net
->dev
, dev
);
234 r
= vhost_dev_start(&net
->dev
, dev
);
239 if (net
->nc
->info
->poll
) {
240 net
->nc
->info
->poll(net
->nc
, false);
243 if (net
->nc
->info
->type
== NET_CLIENT_DRIVER_TAP
) {
244 qemu_set_fd_handler(net
->backend
, NULL
, NULL
, NULL
);
245 file
.fd
= net
->backend
;
246 for (file
.index
= 0; file
.index
< net
->dev
.nvqs
; ++file
.index
) {
247 r
= vhost_net_set_backend(&net
->dev
, &file
);
257 if (net
->nc
->info
->type
== NET_CLIENT_DRIVER_TAP
) {
258 while (file
.index
-- > 0) {
259 int r
= vhost_net_set_backend(&net
->dev
, &file
);
263 if (net
->nc
->info
->poll
) {
264 net
->nc
->info
->poll(net
->nc
, true);
266 vhost_dev_stop(&net
->dev
, dev
);
268 vhost_dev_disable_notifiers(&net
->dev
, dev
);
273 static void vhost_net_stop_one(struct vhost_net
*net
,
276 struct vhost_vring_file file
= { .fd
= -1 };
278 if (net
->nc
->info
->type
== NET_CLIENT_DRIVER_TAP
) {
279 for (file
.index
= 0; file
.index
< net
->dev
.nvqs
; ++file
.index
) {
280 int r
= vhost_net_set_backend(&net
->dev
, &file
);
284 if (net
->nc
->info
->poll
) {
285 net
->nc
->info
->poll(net
->nc
, true);
287 vhost_dev_stop(&net
->dev
, dev
);
288 vhost_dev_disable_notifiers(&net
->dev
, dev
);
291 int vhost_net_start(VirtIODevice
*dev
, NetClientState
*ncs
,
294 BusState
*qbus
= BUS(qdev_get_parent_bus(DEVICE(dev
)));
295 VirtioBusState
*vbus
= VIRTIO_BUS(qbus
);
296 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(vbus
);
299 if (!k
->set_guest_notifiers
) {
300 error_report("binding does not support guest notifiers");
304 for (i
= 0; i
< total_queues
; i
++) {
305 struct vhost_net
*net
;
307 net
= get_vhost_net(ncs
[i
].peer
);
308 vhost_net_set_vq_index(net
, i
* 2);
310 /* Suppress the masking guest notifiers on vhost user
311 * because vhost user doesn't interrupt masking/unmasking
314 if (net
->nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
) {
315 dev
->use_guest_notifier_mask
= false;
319 r
= k
->set_guest_notifiers(qbus
->parent
, total_queues
* 2, true);
321 error_report("Error binding guest notifier: %d", -r
);
325 for (i
= 0; i
< total_queues
; i
++) {
326 r
= vhost_net_start_one(get_vhost_net(ncs
[i
].peer
), dev
);
332 if (ncs
[i
].peer
->vring_enable
) {
333 /* restore vring enable state */
334 r
= vhost_set_vring_enable(ncs
[i
].peer
, ncs
[i
].peer
->vring_enable
);
346 vhost_net_stop_one(get_vhost_net(ncs
[i
].peer
), dev
);
348 e
= k
->set_guest_notifiers(qbus
->parent
, total_queues
* 2, false);
350 fprintf(stderr
, "vhost guest notifier cleanup failed: %d\n", e
);
357 void vhost_net_stop(VirtIODevice
*dev
, NetClientState
*ncs
,
360 BusState
*qbus
= BUS(qdev_get_parent_bus(DEVICE(dev
)));
361 VirtioBusState
*vbus
= VIRTIO_BUS(qbus
);
362 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(vbus
);
365 for (i
= 0; i
< total_queues
; i
++) {
366 vhost_net_stop_one(get_vhost_net(ncs
[i
].peer
), dev
);
369 r
= k
->set_guest_notifiers(qbus
->parent
, total_queues
* 2, false);
371 fprintf(stderr
, "vhost guest notifier cleanup failed: %d\n", r
);
377 void vhost_net_cleanup(struct vhost_net
*net
)
379 vhost_dev_cleanup(&net
->dev
);
382 int vhost_net_notify_migration_done(struct vhost_net
*net
, char* mac_addr
)
384 const VhostOps
*vhost_ops
= net
->dev
.vhost_ops
;
386 assert(vhost_ops
->backend_type
== VHOST_BACKEND_TYPE_USER
);
387 assert(vhost_ops
->vhost_migration_done
);
389 return vhost_ops
->vhost_migration_done(&net
->dev
, mac_addr
);
392 bool vhost_net_virtqueue_pending(VHostNetState
*net
, int idx
)
394 return vhost_virtqueue_pending(&net
->dev
, idx
);
397 void vhost_net_virtqueue_mask(VHostNetState
*net
, VirtIODevice
*dev
,
400 vhost_virtqueue_mask(&net
->dev
, dev
, idx
, mask
);
403 VHostNetState
*get_vhost_net(NetClientState
*nc
)
405 VHostNetState
*vhost_net
= 0;
411 switch (nc
->info
->type
) {
412 case NET_CLIENT_DRIVER_TAP
:
413 vhost_net
= tap_get_vhost_net(nc
);
415 case NET_CLIENT_DRIVER_VHOST_USER
:
416 vhost_net
= vhost_user_get_vhost_net(nc
);
426 int vhost_set_vring_enable(NetClientState
*nc
, int enable
)
428 VHostNetState
*net
= get_vhost_net(nc
);
429 const VhostOps
*vhost_ops
= net
->dev
.vhost_ops
;
431 nc
->vring_enable
= enable
;
433 if (vhost_ops
&& vhost_ops
->vhost_set_vring_enable
) {
434 return vhost_ops
->vhost_set_vring_enable(&net
->dev
, enable
);
440 int vhost_net_set_mtu(struct vhost_net
*net
, uint16_t mtu
)
442 const VhostOps
*vhost_ops
= net
->dev
.vhost_ops
;
444 if (!vhost_ops
->vhost_net_set_mtu
) {
448 return vhost_ops
->vhost_net_set_mtu(&net
->dev
, mtu
);
452 uint64_t vhost_net_get_max_queues(VHostNetState
*net
)
457 struct vhost_net
*vhost_net_init(VhostNetOptions
*options
)
459 error_report("vhost-net support is not compiled in");
463 int vhost_net_start(VirtIODevice
*dev
,
469 void vhost_net_stop(VirtIODevice
*dev
,
475 void vhost_net_cleanup(struct vhost_net
*net
)
479 uint64_t vhost_net_get_features(struct vhost_net
*net
, uint64_t features
)
484 void vhost_net_ack_features(struct vhost_net
*net
, uint64_t features
)
488 uint64_t vhost_net_get_acked_features(VHostNetState
*net
)
493 bool vhost_net_virtqueue_pending(VHostNetState
*net
, int idx
)
498 void vhost_net_virtqueue_mask(VHostNetState
*net
, VirtIODevice
*dev
,
503 int vhost_net_notify_migration_done(struct vhost_net
*net
, char* mac_addr
)
508 VHostNetState
*get_vhost_net(NetClientState
*nc
)
513 int vhost_set_vring_enable(NetClientState
*nc
, int enable
)
518 int vhost_net_set_mtu(struct vhost_net
*net
, uint16_t mtu
)