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 "sysemu/char.h"
16 #include "qemu/config-file.h"
17 #include "qemu/error-report.h"
18 #include "qmp-commands.h"
21 typedef struct VhostUserState
{
24 VHostNetState
*vhost_net
;
26 uint64_t acked_features
;
29 typedef struct VhostUserChardevProps
{
32 } VhostUserChardevProps
;
34 VHostNetState
*vhost_user_get_vhost_net(NetClientState
*nc
)
36 VhostUserState
*s
= DO_UPCAST(VhostUserState
, nc
, nc
);
37 assert(nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
41 uint64_t vhost_user_get_acked_features(NetClientState
*nc
)
43 VhostUserState
*s
= DO_UPCAST(VhostUserState
, 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(VhostUserState
, 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
[])
71 VhostNetOptions options
;
72 struct vhost_net
*net
= NULL
;
77 options
.backend_type
= VHOST_BACKEND_TYPE_USER
;
79 for (i
= 0; i
< queues
; i
++) {
80 assert(ncs
[i
]->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
82 s
= DO_UPCAST(VhostUserState
, nc
, ncs
[i
]);
84 options
.net_backend
= ncs
[i
];
85 options
.opaque
= s
->chr
;
86 options
.busyloop_timeout
= 0;
87 net
= vhost_net_init(&options
);
89 error_report("failed to init vhost_net for queue %d", i
);
94 max_queues
= vhost_net_get_max_queues(net
);
95 if (queues
> max_queues
) {
96 error_report("you are asking more queues than supported: %d",
103 vhost_net_cleanup(s
->vhost_net
);
104 g_free(s
->vhost_net
);
113 vhost_net_cleanup(net
);
115 vhost_user_stop(i
, ncs
);
119 static ssize_t
vhost_user_receive(NetClientState
*nc
, const uint8_t *buf
,
122 /* In case of RARP (message size is 60) notify backup to send a fake RARP.
123 This fake RARP will be sent by backend only for guest
124 without GUEST_ANNOUNCE capability.
127 VhostUserState
*s
= DO_UPCAST(VhostUserState
, nc
, nc
);
129 static int display_rarp_failure
= 1;
132 /* extract guest mac address from the RARP message */
133 memcpy(mac_addr
, &buf
[6], 6);
135 r
= vhost_net_notify_migration_done(s
->vhost_net
, mac_addr
);
137 if ((r
!= 0) && (display_rarp_failure
)) {
139 "Vhost user backend fails to broadcast fake RARP\n");
141 display_rarp_failure
= 0;
148 static void vhost_user_cleanup(NetClientState
*nc
)
150 VhostUserState
*s
= DO_UPCAST(VhostUserState
, nc
, nc
);
153 vhost_net_cleanup(s
->vhost_net
);
154 g_free(s
->vhost_net
);
158 qemu_chr_add_handlers(s
->chr
, NULL
, NULL
, NULL
, NULL
);
159 qemu_chr_fe_release(s
->chr
);
163 qemu_purge_queued_packets(nc
);
166 static bool vhost_user_has_vnet_hdr(NetClientState
*nc
)
168 assert(nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
173 static bool vhost_user_has_ufo(NetClientState
*nc
)
175 assert(nc
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
180 static NetClientInfo net_vhost_user_info
= {
181 .type
= NET_CLIENT_DRIVER_VHOST_USER
,
182 .size
= sizeof(VhostUserState
),
183 .receive
= vhost_user_receive
,
184 .cleanup
= vhost_user_cleanup
,
185 .has_vnet_hdr
= vhost_user_has_vnet_hdr
,
186 .has_ufo
= vhost_user_has_ufo
,
189 static gboolean
net_vhost_user_watch(GIOChannel
*chan
, GIOCondition cond
,
192 VhostUserState
*s
= opaque
;
194 qemu_chr_disconnect(s
->chr
);
199 static void net_vhost_user_event(void *opaque
, int event
)
201 const char *name
= opaque
;
202 NetClientState
*ncs
[MAX_QUEUE_NUM
];
207 queues
= qemu_find_net_clients_except(name
, ncs
,
208 NET_CLIENT_DRIVER_NIC
,
210 assert(queues
< MAX_QUEUE_NUM
);
212 s
= DO_UPCAST(VhostUserState
, nc
, ncs
[0]);
213 trace_vhost_user_event(s
->chr
->label
, event
);
215 case CHR_EVENT_OPENED
:
216 s
->watch
= qemu_chr_fe_add_watch(s
->chr
, G_IO_HUP
,
217 net_vhost_user_watch
, s
);
218 if (vhost_user_start(queues
, ncs
) < 0) {
219 qemu_chr_disconnect(s
->chr
);
222 qmp_set_link(name
, true, &err
);
224 case CHR_EVENT_CLOSED
:
225 qmp_set_link(name
, false, &err
);
226 vhost_user_stop(queues
, ncs
);
227 g_source_remove(s
->watch
);
233 error_report_err(err
);
237 static int net_vhost_user_init(NetClientState
*peer
, const char *device
,
238 const char *name
, CharDriverState
*chr
,
248 for (i
= 0; i
< queues
; i
++) {
249 nc
= qemu_new_net_client(&net_vhost_user_info
, peer
, device
, name
);
251 snprintf(nc
->info_str
, sizeof(nc
->info_str
), "vhost-user%d to %s",
256 s
= DO_UPCAST(VhostUserState
, nc
, nc
);
260 qemu_chr_add_handlers(chr
, NULL
, NULL
, net_vhost_user_event
, nc
[0].name
);
265 static int net_vhost_chardev_opts(void *opaque
,
266 const char *name
, const char *value
,
269 VhostUserChardevProps
*props
= opaque
;
271 if (strcmp(name
, "backend") == 0 && strcmp(value
, "socket") == 0) {
272 props
->is_socket
= true;
273 } else if (strcmp(name
, "path") == 0) {
274 props
->is_unix
= true;
275 } else if (strcmp(name
, "server") == 0) {
278 "vhost-user does not support a chardev with option %s=%s",
285 static CharDriverState
*net_vhost_parse_chardev(
286 const NetdevVhostUserOptions
*opts
, Error
**errp
)
288 CharDriverState
*chr
= qemu_chr_find(opts
->chardev
);
289 VhostUserChardevProps props
;
292 error_setg(errp
, "chardev \"%s\" not found", opts
->chardev
);
296 /* inspect chardev opts */
297 memset(&props
, 0, sizeof(props
));
298 if (qemu_opt_foreach(chr
->opts
, net_vhost_chardev_opts
, &props
, errp
)) {
302 if (!props
.is_socket
|| !props
.is_unix
) {
303 error_setg(errp
, "chardev \"%s\" is not a unix socket",
308 qemu_chr_fe_claim_no_fail(chr
);
313 static int net_vhost_check_net(void *opaque
, QemuOpts
*opts
, Error
**errp
)
315 const char *name
= opaque
;
316 const char *driver
, *netdev
;
318 driver
= qemu_opt_get(opts
, "driver");
319 netdev
= qemu_opt_get(opts
, "netdev");
321 if (!driver
|| !netdev
) {
325 if (strcmp(netdev
, name
) == 0 &&
326 !g_str_has_prefix(driver
, "virtio-net-")) {
327 error_setg(errp
, "vhost-user requires frontend driver virtio-net-*");
334 int net_init_vhost_user(const Netdev
*netdev
, const char *name
,
335 NetClientState
*peer
, Error
**errp
)
338 const NetdevVhostUserOptions
*vhost_user_opts
;
339 CharDriverState
*chr
;
341 assert(netdev
->type
== NET_CLIENT_DRIVER_VHOST_USER
);
342 vhost_user_opts
= &netdev
->u
.vhost_user
;
344 chr
= net_vhost_parse_chardev(vhost_user_opts
, errp
);
349 /* verify net frontend */
350 if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net
,
351 (char *)name
, errp
)) {
355 queues
= vhost_user_opts
->has_queues
? vhost_user_opts
->queues
: 1;
356 if (queues
< 1 || queues
> MAX_QUEUE_NUM
) {
358 "vhost-user number of queues must be in range [1, %d]",
363 return net_vhost_user_init(peer
, "vhost_user", name
, chr
, queues
);