4 * Copyright (c) 2013 Virtual Open Systems Sarl.
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
11 #include "qemu/osdep.h"
13 #include "net/vhost_net.h"
14 #include "net/vhost-user.h"
15 #include "hw/virtio/vhost-user.h"
16 #include "chardev/char-fe.h"
17 #include "qapi/error.h"
18 #include "qapi/qapi-commands-net.h"
19 #include "qemu/config-file.h"
20 #include "qemu/error-report.h"
21 #include "qemu/option.h"
24 typedef struct NetVhostUserState
{
26 CharBackend chr
; /* only queue index 0 */
27 VhostUserState
*vhost_user
;
28 VHostNetState
*vhost_net
;
30 uint64_t acked_features
;
34 VHostNetState
*vhost_user_get_vhost_net(NetClientState
*nc
)
36 NetVhostUserState
*s
= DO_UPCAST(NetVhostUserState
, nc
, nc
);
37 assert(nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
41 uint64_t vhost_user_get_acked_features(NetClientState
*nc
)
43 NetVhostUserState
*s
= DO_UPCAST(NetVhostUserState
, nc
, nc
);
44 assert(nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
45 return s
->acked_features
;
48 static void vhost_user_stop(int queues
, NetClientState
*ncs
[])
53 for (i
= 0; i
< queues
; i
++) {
54 assert(ncs
[i
]->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
56 s
= DO_UPCAST(NetVhostUserState
, nc
, ncs
[i
]);
59 /* save acked features */
60 uint64_t features
= vhost_net_get_acked_features(s
->vhost_net
);
62 s
->acked_features
= features
;
64 vhost_net_cleanup(s
->vhost_net
);
69 static int vhost_user_start(int queues
, NetClientState
*ncs
[],
72 VhostNetOptions options
;
73 struct vhost_net
*net
= NULL
;
78 options
.backend_type
= VHOST_BACKEND_TYPE_USER
;
80 for (i
= 0; i
< queues
; i
++) {
81 assert(ncs
[i
]->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
83 s
= DO_UPCAST(NetVhostUserState
, nc
, ncs
[i
]);
85 options
.net_backend
= ncs
[i
];
87 options
.busyloop_timeout
= 0;
88 net
= vhost_net_init(&options
);
90 error_report("failed to init vhost_net for queue %d", i
);
95 max_queues
= vhost_net_get_max_queues(net
);
96 if (queues
> max_queues
) {
97 error_report("you are asking more queues than supported: %d",
104 vhost_net_cleanup(s
->vhost_net
);
105 g_free(s
->vhost_net
);
114 vhost_net_cleanup(net
);
117 vhost_user_stop(i
, ncs
);
121 static ssize_t
vhost_user_receive(NetClientState
*nc
, const uint8_t *buf
,
124 /* In case of RARP (message size is 60) notify backup to send a fake RARP.
125 This fake RARP will be sent by backend only for guest
126 without GUEST_ANNOUNCE capability.
129 NetVhostUserState
*s
= DO_UPCAST(NetVhostUserState
, nc
, nc
);
131 static int display_rarp_failure
= 1;
134 /* extract guest mac address from the RARP message */
135 memcpy(mac_addr
, &buf
[6], 6);
137 r
= vhost_net_notify_migration_done(s
->vhost_net
, mac_addr
);
139 if ((r
!= 0) && (display_rarp_failure
)) {
141 "Vhost user backend fails to broadcast fake RARP\n");
143 display_rarp_failure
= 0;
150 static void net_vhost_user_cleanup(NetClientState
*nc
)
152 NetVhostUserState
*s
= DO_UPCAST(NetVhostUserState
, nc
, nc
);
155 vhost_net_cleanup(s
->vhost_net
);
156 g_free(s
->vhost_net
);
159 if (nc
->queue_index
== 0) {
161 g_source_remove(s
->watch
);
164 qemu_chr_fe_deinit(&s
->chr
, true);
166 vhost_user_cleanup(s
->vhost_user
);
167 g_free(s
->vhost_user
);
168 s
->vhost_user
= NULL
;
172 qemu_purge_queued_packets(nc
);
175 static int vhost_user_set_vnet_endianness(NetClientState
*nc
,
178 /* Nothing to do. If the server supports
179 * VHOST_USER_PROTOCOL_F_CROSS_ENDIAN, it will get the
180 * vnet header endianness from there. If it doesn't, negotiation
186 static bool vhost_user_has_vnet_hdr(NetClientState
*nc
)
188 assert(nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
193 static bool vhost_user_has_ufo(NetClientState
*nc
)
195 assert(nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
200 static NetClientInfo net_vhost_user_info
= {
201 .type
= NET_CLIENT_DRIVER_VHOST_USER
,
202 .size
= sizeof(NetVhostUserState
),
203 .receive
= vhost_user_receive
,
204 .cleanup
= net_vhost_user_cleanup
,
205 .has_vnet_hdr
= vhost_user_has_vnet_hdr
,
206 .has_ufo
= vhost_user_has_ufo
,
207 .set_vnet_be
= vhost_user_set_vnet_endianness
,
208 .set_vnet_le
= vhost_user_set_vnet_endianness
,
211 static gboolean
net_vhost_user_watch(GIOChannel
*chan
, GIOCondition cond
,
214 NetVhostUserState
*s
= opaque
;
216 qemu_chr_fe_disconnect(&s
->chr
);
221 static void net_vhost_user_event(void *opaque
, int event
);
223 static void chr_closed_bh(void *opaque
)
225 const char *name
= opaque
;
226 NetClientState
*ncs
[MAX_QUEUE_NUM
];
227 NetVhostUserState
*s
;
231 queues
= qemu_find_net_clients_except(name
, ncs
,
232 NET_CLIENT_DRIVER_NIC
,
234 assert(queues
< MAX_QUEUE_NUM
);
236 s
= DO_UPCAST(NetVhostUserState
, nc
, ncs
[0]);
238 qmp_set_link(name
, false, &err
);
240 qemu_chr_fe_set_handlers(&s
->chr
, NULL
, NULL
, net_vhost_user_event
,
241 NULL
, opaque
, NULL
, true);
244 error_report_err(err
);
248 static void net_vhost_user_event(void *opaque
, int event
)
250 const char *name
= opaque
;
251 NetClientState
*ncs
[MAX_QUEUE_NUM
];
252 NetVhostUserState
*s
;
257 queues
= qemu_find_net_clients_except(name
, ncs
,
258 NET_CLIENT_DRIVER_NIC
,
260 assert(queues
< MAX_QUEUE_NUM
);
262 s
= DO_UPCAST(NetVhostUserState
, nc
, ncs
[0]);
263 chr
= qemu_chr_fe_get_driver(&s
->chr
);
264 trace_vhost_user_event(chr
->label
, event
);
266 case CHR_EVENT_OPENED
:
267 if (vhost_user_start(queues
, ncs
, s
->vhost_user
) < 0) {
268 qemu_chr_fe_disconnect(&s
->chr
);
271 s
->watch
= qemu_chr_fe_add_watch(&s
->chr
, G_IO_HUP
,
272 net_vhost_user_watch
, s
);
273 qmp_set_link(name
, true, &err
);
276 case CHR_EVENT_CLOSED
:
277 /* a close event may happen during a read/write, but vhost
278 * code assumes the vhost_dev remains setup, so delay the
279 * stop & clear to idle.
280 * FIXME: better handle failure in vhost code, remove bh
283 AioContext
*ctx
= qemu_get_current_aio_context();
285 g_source_remove(s
->watch
);
287 qemu_chr_fe_set_handlers(&s
->chr
, NULL
, NULL
, NULL
, NULL
,
290 aio_bh_schedule_oneshot(ctx
, chr_closed_bh
, opaque
);
296 error_report_err(err
);
300 static int net_vhost_user_init(NetClientState
*peer
, const char *device
,
301 const char *name
, Chardev
*chr
,
305 NetClientState
*nc
, *nc0
= NULL
;
306 NetVhostUserState
*s
= NULL
;
307 VhostUserState
*user
;
313 user
= g_new0(struct VhostUserState
, 1);
314 for (i
= 0; i
< queues
; i
++) {
315 nc
= qemu_new_net_client(&net_vhost_user_info
, peer
, device
, name
);
316 snprintf(nc
->info_str
, sizeof(nc
->info_str
), "vhost-user%d to %s",
321 s
= DO_UPCAST(NetVhostUserState
, nc
, nc
);
322 if (!qemu_chr_fe_init(&s
->chr
, chr
, &err
) ||
323 !vhost_user_init(user
, &s
->chr
, &err
)) {
324 error_report_err(err
);
328 s
= DO_UPCAST(NetVhostUserState
, nc
, nc
);
329 s
->vhost_user
= user
;
332 s
= DO_UPCAST(NetVhostUserState
, nc
, nc0
);
334 if (qemu_chr_fe_wait_connected(&s
->chr
, &err
) < 0) {
335 error_report_err(err
);
338 qemu_chr_fe_set_handlers(&s
->chr
, NULL
, NULL
,
339 net_vhost_user_event
, NULL
, nc0
->name
, NULL
,
341 } while (!s
->started
);
343 assert(s
->vhost_net
);
349 vhost_user_cleanup(user
);
352 s
->vhost_user
= NULL
;
356 qemu_del_net_client(nc0
);
362 static Chardev
*net_vhost_claim_chardev(
363 const NetdevVhostUserOptions
*opts
, Error
**errp
)
365 Chardev
*chr
= qemu_chr_find(opts
->chardev
);
368 error_setg(errp
, "chardev \"%s\" not found", opts
->chardev
);
372 if (!qemu_chr_has_feature(chr
, QEMU_CHAR_FEATURE_RECONNECTABLE
)) {
373 error_setg(errp
, "chardev \"%s\" is not reconnectable",
377 if (!qemu_chr_has_feature(chr
, QEMU_CHAR_FEATURE_FD_PASS
)) {
378 error_setg(errp
, "chardev \"%s\" does not support FD passing",
386 static int net_vhost_check_net(void *opaque
, QemuOpts
*opts
, Error
**errp
)
388 const char *name
= opaque
;
389 const char *driver
, *netdev
;
391 driver
= qemu_opt_get(opts
, "driver");
392 netdev
= qemu_opt_get(opts
, "netdev");
394 if (!driver
|| !netdev
) {
398 if (strcmp(netdev
, name
) == 0 &&
399 !g_str_has_prefix(driver
, "virtio-net-")) {
400 error_setg(errp
, "vhost-user requires frontend driver virtio-net-*");
407 int net_init_vhost_user(const Netdev
*netdev
, const char *name
,
408 NetClientState
*peer
, Error
**errp
)
411 const NetdevVhostUserOptions
*vhost_user_opts
;
414 assert(netdev
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
415 vhost_user_opts
= &netdev
->u
.vhost_user
;
417 chr
= net_vhost_claim_chardev(vhost_user_opts
, errp
);
422 /* verify net frontend */
423 if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net
,
424 (char *)name
, errp
)) {
428 queues
= vhost_user_opts
->has_queues
? vhost_user_opts
->queues
: 1;
429 if (queues
< 1 || queues
> MAX_QUEUE_NUM
) {
431 "vhost-user number of queues must be in range [1, %d]",
436 return net_vhost_user_init(peer
, "vhost_user", name
, chr
, queues
);