Revert "vhost-user: add multi queue support"
[qemu.git] / net / vhost-user.c
1 /*
2 * vhost-user.c
3 *
4 * Copyright (c) 2013 Virtual Open Systems Sarl.
5 *
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.
8 *
9 */
10
11 #include "clients.h"
12 #include "net/vhost_net.h"
13 #include "net/vhost-user.h"
14 #include "sysemu/char.h"
15 #include "qemu/config-file.h"
16 #include "qemu/error-report.h"
17
18 typedef struct VhostUserState {
19 NetClientState nc;
20 CharDriverState *chr;
21 VHostNetState *vhost_net;
22 } VhostUserState;
23
24 typedef struct VhostUserChardevProps {
25 bool is_socket;
26 bool is_unix;
27 bool is_server;
28 } VhostUserChardevProps;
29
30 VHostNetState *vhost_user_get_vhost_net(NetClientState *nc)
31 {
32 VhostUserState *s = DO_UPCAST(VhostUserState, nc, nc);
33 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER);
34 return s->vhost_net;
35 }
36
37 static int vhost_user_running(VhostUserState *s)
38 {
39 return (s->vhost_net) ? 1 : 0;
40 }
41
42 static int vhost_user_start(VhostUserState *s)
43 {
44 VhostNetOptions options;
45
46 if (vhost_user_running(s)) {
47 return 0;
48 }
49
50 options.backend_type = VHOST_BACKEND_TYPE_USER;
51 options.net_backend = &s->nc;
52 options.opaque = s->chr;
53
54 s->vhost_net = vhost_net_init(&options);
55
56 return vhost_user_running(s) ? 0 : -1;
57 }
58
59 static void vhost_user_stop(VhostUserState *s)
60 {
61 if (vhost_user_running(s)) {
62 vhost_net_cleanup(s->vhost_net);
63 }
64
65 s->vhost_net = 0;
66 }
67
68 static void vhost_user_cleanup(NetClientState *nc)
69 {
70 VhostUserState *s = DO_UPCAST(VhostUserState, nc, nc);
71
72 vhost_user_stop(s);
73 qemu_purge_queued_packets(nc);
74 }
75
76 static bool vhost_user_has_vnet_hdr(NetClientState *nc)
77 {
78 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER);
79
80 return true;
81 }
82
83 static bool vhost_user_has_ufo(NetClientState *nc)
84 {
85 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER);
86
87 return true;
88 }
89
90 static NetClientInfo net_vhost_user_info = {
91 .type = NET_CLIENT_OPTIONS_KIND_VHOST_USER,
92 .size = sizeof(VhostUserState),
93 .cleanup = vhost_user_cleanup,
94 .has_vnet_hdr = vhost_user_has_vnet_hdr,
95 .has_ufo = vhost_user_has_ufo,
96 };
97
98 static void net_vhost_link_down(VhostUserState *s, bool link_down)
99 {
100 s->nc.link_down = link_down;
101
102 if (s->nc.peer) {
103 s->nc.peer->link_down = link_down;
104 }
105
106 if (s->nc.info->link_status_changed) {
107 s->nc.info->link_status_changed(&s->nc);
108 }
109
110 if (s->nc.peer && s->nc.peer->info->link_status_changed) {
111 s->nc.peer->info->link_status_changed(s->nc.peer);
112 }
113 }
114
115 static void net_vhost_user_event(void *opaque, int event)
116 {
117 VhostUserState *s = opaque;
118
119 switch (event) {
120 case CHR_EVENT_OPENED:
121 vhost_user_start(s);
122 net_vhost_link_down(s, false);
123 error_report("chardev \"%s\" went up", s->chr->label);
124 break;
125 case CHR_EVENT_CLOSED:
126 net_vhost_link_down(s, true);
127 vhost_user_stop(s);
128 error_report("chardev \"%s\" went down", s->chr->label);
129 break;
130 }
131 }
132
133 static int net_vhost_user_init(NetClientState *peer, const char *device,
134 const char *name, CharDriverState *chr)
135 {
136 NetClientState *nc;
137 VhostUserState *s;
138
139 nc = qemu_new_net_client(&net_vhost_user_info, peer, device, name);
140
141 snprintf(nc->info_str, sizeof(nc->info_str), "vhost-user to %s",
142 chr->label);
143
144 s = DO_UPCAST(VhostUserState, nc, nc);
145
146 /* We don't provide a receive callback */
147 s->nc.receive_disabled = 1;
148 s->chr = chr;
149
150 qemu_chr_add_handlers(s->chr, NULL, NULL, net_vhost_user_event, s);
151
152 return 0;
153 }
154
155 static int net_vhost_chardev_opts(void *opaque,
156 const char *name, const char *value,
157 Error **errp)
158 {
159 VhostUserChardevProps *props = opaque;
160
161 if (strcmp(name, "backend") == 0 && strcmp(value, "socket") == 0) {
162 props->is_socket = true;
163 } else if (strcmp(name, "path") == 0) {
164 props->is_unix = true;
165 } else if (strcmp(name, "server") == 0) {
166 props->is_server = true;
167 } else {
168 error_setg(errp,
169 "vhost-user does not support a chardev with option %s=%s",
170 name, value);
171 return -1;
172 }
173 return 0;
174 }
175
176 static CharDriverState *net_vhost_parse_chardev(
177 const NetdevVhostUserOptions *opts, Error **errp)
178 {
179 CharDriverState *chr = qemu_chr_find(opts->chardev);
180 VhostUserChardevProps props;
181
182 if (chr == NULL) {
183 error_setg(errp, "chardev \"%s\" not found", opts->chardev);
184 return NULL;
185 }
186
187 /* inspect chardev opts */
188 memset(&props, 0, sizeof(props));
189 if (qemu_opt_foreach(chr->opts, net_vhost_chardev_opts, &props, errp)) {
190 return NULL;
191 }
192
193 if (!props.is_socket || !props.is_unix) {
194 error_setg(errp, "chardev \"%s\" is not a unix socket",
195 opts->chardev);
196 return NULL;
197 }
198
199 qemu_chr_fe_claim_no_fail(chr);
200
201 return chr;
202 }
203
204 static int net_vhost_check_net(void *opaque, QemuOpts *opts, Error **errp)
205 {
206 const char *name = opaque;
207 const char *driver, *netdev;
208 const char virtio_name[] = "virtio-net-";
209
210 driver = qemu_opt_get(opts, "driver");
211 netdev = qemu_opt_get(opts, "netdev");
212
213 if (!driver || !netdev) {
214 return 0;
215 }
216
217 if (strcmp(netdev, name) == 0 &&
218 strncmp(driver, virtio_name, strlen(virtio_name)) != 0) {
219 error_setg(errp, "vhost-user requires frontend driver virtio-net-*");
220 return -1;
221 }
222
223 return 0;
224 }
225
226 int net_init_vhost_user(const NetClientOptions *opts, const char *name,
227 NetClientState *peer, Error **errp)
228 {
229 const NetdevVhostUserOptions *vhost_user_opts;
230 CharDriverState *chr;
231
232 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_VHOST_USER);
233 vhost_user_opts = opts->vhost_user;
234
235 chr = net_vhost_parse_chardev(vhost_user_opts, errp);
236 if (!chr) {
237 return -1;
238 }
239
240 /* verify net frontend */
241 if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net,
242 (char *)name, errp)) {
243 return -1;
244 }
245
246
247 return net_vhost_user_init(peer, "vhost_user", name, chr);
248 }