]>
Commit | Line | Data |
---|---|---|
d314f586 NN |
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" | |
03ce5744 | 15 | #include "qemu/config-file.h" |
d314f586 NN |
16 | #include "qemu/error-report.h" |
17 | ||
18 | typedef struct VhostUserState { | |
19 | NetClientState nc; | |
20 | CharDriverState *chr; | |
d314f586 NN |
21 | VHostNetState *vhost_net; |
22 | } VhostUserState; | |
23 | ||
03ce5744 NN |
24 | typedef struct VhostUserChardevProps { |
25 | bool is_socket; | |
26 | bool is_unix; | |
27 | bool is_server; | |
28 | } VhostUserChardevProps; | |
29 | ||
d314f586 NN |
30 | VHostNetState *vhost_user_get_vhost_net(NetClientState *nc) |
31 | { | |
32 | VhostUserState *s = DO_UPCAST(VhostUserState, nc, nc); | |
03ce5744 | 33 | assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER); |
d314f586 NN |
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; | |
d314f586 NN |
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 = { | |
03ce5744 | 91 | .type = NET_CLIENT_OPTIONS_KIND_VHOST_USER, |
d314f586 NN |
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); | |
d345ed2d | 123 | error_report("chardev \"%s\" went up", s->chr->label); |
d314f586 NN |
124 | break; |
125 | case CHR_EVENT_CLOSED: | |
126 | net_vhost_link_down(s, true); | |
127 | vhost_user_stop(s); | |
d345ed2d | 128 | error_report("chardev \"%s\" went down", s->chr->label); |
d314f586 NN |
129 | break; |
130 | } | |
131 | } | |
132 | ||
133 | static int net_vhost_user_init(NetClientState *peer, const char *device, | |
d345ed2d | 134 | const char *name, CharDriverState *chr) |
d314f586 NN |
135 | { |
136 | NetClientState *nc; | |
137 | VhostUserState *s; | |
138 | ||
d345ed2d | 139 | nc = qemu_new_net_client(&net_vhost_user_info, peer, device, name); |
d314f586 | 140 | |
d345ed2d MT |
141 | snprintf(nc->info_str, sizeof(nc->info_str), "vhost-user to %s", |
142 | chr->label); | |
d314f586 | 143 | |
d345ed2d | 144 | s = DO_UPCAST(VhostUserState, nc, nc); |
d314f586 | 145 | |
d345ed2d MT |
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); | |
d314f586 NN |
151 | |
152 | return 0; | |
153 | } | |
154 | ||
71df1d83 MA |
155 | static int net_vhost_chardev_opts(void *opaque, |
156 | const char *name, const char *value, | |
157 | Error **errp) | |
03ce5744 NN |
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 { | |
81904831 MA |
168 | error_setg(errp, |
169 | "vhost-user does not support a chardev with option %s=%s", | |
170 | name, value); | |
03ce5744 NN |
171 | return -1; |
172 | } | |
173 | return 0; | |
174 | } | |
175 | ||
81904831 MA |
176 | static CharDriverState *net_vhost_parse_chardev( |
177 | const NetdevVhostUserOptions *opts, Error **errp) | |
03ce5744 NN |
178 | { |
179 | CharDriverState *chr = qemu_chr_find(opts->chardev); | |
180 | VhostUserChardevProps props; | |
181 | ||
182 | if (chr == NULL) { | |
81904831 | 183 | error_setg(errp, "chardev \"%s\" not found", opts->chardev); |
03ce5744 NN |
184 | return NULL; |
185 | } | |
186 | ||
187 | /* inspect chardev opts */ | |
188 | memset(&props, 0, sizeof(props)); | |
81904831 | 189 | if (qemu_opt_foreach(chr->opts, net_vhost_chardev_opts, &props, errp)) { |
03ce5744 NN |
190 | return NULL; |
191 | } | |
192 | ||
193 | if (!props.is_socket || !props.is_unix) { | |
81904831 MA |
194 | error_setg(errp, "chardev \"%s\" is not a unix socket", |
195 | opts->chardev); | |
03ce5744 NN |
196 | return NULL; |
197 | } | |
198 | ||
199 | qemu_chr_fe_claim_no_fail(chr); | |
200 | ||
201 | return chr; | |
202 | } | |
203 | ||
28d0de7a | 204 | static int net_vhost_check_net(void *opaque, QemuOpts *opts, Error **errp) |
03ce5744 NN |
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) { | |
81904831 | 219 | error_setg(errp, "vhost-user requires frontend driver virtio-net-*"); |
03ce5744 NN |
220 | return -1; |
221 | } | |
222 | ||
223 | return 0; | |
224 | } | |
225 | ||
d314f586 | 226 | int net_init_vhost_user(const NetClientOptions *opts, const char *name, |
a30ecde6 | 227 | NetClientState *peer, Error **errp) |
d314f586 | 228 | { |
03ce5744 NN |
229 | const NetdevVhostUserOptions *vhost_user_opts; |
230 | CharDriverState *chr; | |
03ce5744 NN |
231 | |
232 | assert(opts->kind == NET_CLIENT_OPTIONS_KIND_VHOST_USER); | |
233 | vhost_user_opts = opts->vhost_user; | |
234 | ||
81904831 | 235 | chr = net_vhost_parse_chardev(vhost_user_opts, errp); |
03ce5744 | 236 | if (!chr) { |
03ce5744 NN |
237 | return -1; |
238 | } | |
239 | ||
240 | /* verify net frontend */ | |
241 | if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net, | |
81904831 | 242 | (char *)name, errp)) { |
03ce5744 NN |
243 | return -1; |
244 | } | |
245 | ||
03ce5744 | 246 | |
d345ed2d | 247 | return net_vhost_user_init(peer, "vhost_user", name, chr); |
d314f586 | 248 | } |