]>
Commit | Line | Data |
---|---|---|
6f97dba0 AL |
1 | /* |
2 | * QEMU System Emulator | |
3 | * | |
4 | * Copyright (c) 2003-2008 Fabrice Bellard | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
e688df6b | 24 | |
d38ea87a | 25 | #include "qemu/osdep.h" |
f348b6d1 | 26 | #include "qemu/cutils.h" |
83c9089e | 27 | #include "monitor/monitor.h" |
c3054a6e | 28 | #include "monitor/qmp-helpers.h" |
213dcb06 | 29 | #include "qemu/config-file.h" |
d49b6836 | 30 | #include "qemu/error-report.h" |
ef2fd6f1 | 31 | #include "qemu/qemu-print.h" |
8228e353 | 32 | #include "chardev/char.h" |
e688df6b | 33 | #include "qapi/error.h" |
9af23989 | 34 | #include "qapi/qapi-commands-char.h" |
0dd13589 | 35 | #include "qapi/qmp/qerror.h" |
33577b47 | 36 | #include "sysemu/replay.h" |
517b3d40 | 37 | #include "qemu/help_option.h" |
0b8fa32f | 38 | #include "qemu/module.h" |
922a01a0 | 39 | #include "qemu/option.h" |
1e419ee6 | 40 | #include "qemu/id.h" |
2158fa1b | 41 | #include "qemu/coroutine.h" |
feb774ca | 42 | #include "qemu/yank.h" |
6f97dba0 | 43 | |
ffa0f7eb | 44 | #include "chardev-internal.h" |
df85a78b | 45 | |
6f97dba0 AL |
46 | /***********************************************************/ |
47 | /* character device */ | |
48 | ||
30827bad | 49 | Object *get_chardevs_root(void) |
2f5d45a1 MAL |
50 | { |
51 | return container_get(object_get_root(), "/chardevs"); | |
52 | } | |
2970a6c9 | 53 | |
2fa9044a | 54 | static void chr_be_event(Chardev *s, QEMUChrEvent event) |
6f97dba0 | 55 | { |
a4afa548 MAL |
56 | CharBackend *be = s->be; |
57 | ||
d09c4a47 MAL |
58 | if (!be || !be->chr_event) { |
59 | return; | |
60 | } | |
61 | ||
62 | be->chr_event(be->opaque, event); | |
63 | } | |
64 | ||
2fa9044a | 65 | void qemu_chr_be_event(Chardev *s, QEMUChrEvent event) |
d09c4a47 | 66 | { |
73cdf3f2 AG |
67 | /* Keep track if the char device is open */ |
68 | switch (event) { | |
69 | case CHR_EVENT_OPENED: | |
16665b94 | 70 | s->be_open = 1; |
73cdf3f2 AG |
71 | break; |
72 | case CHR_EVENT_CLOSED: | |
16665b94 | 73 | s->be_open = 0; |
73cdf3f2 | 74 | break; |
71f8d3b0 PMD |
75 | case CHR_EVENT_BREAK: |
76 | case CHR_EVENT_MUX_IN: | |
77 | case CHR_EVENT_MUX_OUT: | |
78 | /* Ignore */ | |
79 | break; | |
73cdf3f2 AG |
80 | } |
81 | ||
d09c4a47 | 82 | CHARDEV_GET_CLASS(s)->chr_be_event(s, event); |
6f97dba0 AL |
83 | } |
84 | ||
d0d7708b DB |
85 | /* Not reporting errors from writing to logfile, as logs are |
86 | * defined to be "best effort" only */ | |
a9b1ca38 | 87 | static void qemu_chr_write_log(Chardev *s, const uint8_t *buf, size_t len) |
d0d7708b DB |
88 | { |
89 | size_t done = 0; | |
90 | ssize_t ret; | |
91 | ||
92 | if (s->logfd < 0) { | |
93 | return; | |
94 | } | |
95 | ||
96 | while (done < len) { | |
53628efb DB |
97 | retry: |
98 | ret = write(s->logfd, buf + done, len - done); | |
99 | if (ret == -1 && errno == EAGAIN) { | |
100 | g_usleep(100); | |
101 | goto retry; | |
102 | } | |
d0d7708b DB |
103 | |
104 | if (ret <= 0) { | |
105 | return; | |
106 | } | |
107 | done += ret; | |
108 | } | |
109 | } | |
110 | ||
a9b1ca38 MAL |
111 | static int qemu_chr_write_buffer(Chardev *s, |
112 | const uint8_t *buf, int len, | |
113 | int *offset, bool write_all) | |
33577b47 | 114 | { |
777357d7 | 115 | ChardevClass *cc = CHARDEV_GET_CLASS(s); |
33577b47 PD |
116 | int res = 0; |
117 | *offset = 0; | |
118 | ||
119 | qemu_mutex_lock(&s->chr_write_lock); | |
120 | while (*offset < len) { | |
53628efb | 121 | retry: |
777357d7 | 122 | res = cc->chr_write(s, buf + *offset, len - *offset); |
c90e9392 | 123 | if (res < 0 && errno == EAGAIN && write_all) { |
2158fa1b LS |
124 | if (qemu_in_coroutine()) { |
125 | qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000); | |
126 | } else { | |
127 | g_usleep(100); | |
128 | } | |
53628efb DB |
129 | goto retry; |
130 | } | |
33577b47 PD |
131 | |
132 | if (res <= 0) { | |
133 | break; | |
134 | } | |
135 | ||
136 | *offset += res; | |
c90e9392 MAL |
137 | if (!write_all) { |
138 | break; | |
139 | } | |
33577b47 PD |
140 | } |
141 | if (*offset > 0) { | |
d96aa5db DB |
142 | /* |
143 | * If some data was written by backend, we should | |
144 | * only log what was actually written. This method | |
145 | * may be invoked again to write the remaining | |
146 | * method, thus we'll log the remainder at that time. | |
147 | */ | |
a9b1ca38 | 148 | qemu_chr_write_log(s, buf, *offset); |
d96aa5db DB |
149 | } else if (res < 0) { |
150 | /* | |
151 | * If a fatal error was reported by the backend, | |
152 | * assume this method won't be invoked again with | |
153 | * this buffer, so log it all right away. | |
154 | */ | |
155 | qemu_chr_write_log(s, buf, len); | |
33577b47 PD |
156 | } |
157 | qemu_mutex_unlock(&s->chr_write_lock); | |
158 | ||
159 | return res; | |
160 | } | |
161 | ||
4d43a603 | 162 | int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all) |
cd18720a | 163 | { |
c90e9392 | 164 | int offset = 0; |
33577b47 | 165 | int res; |
cd18720a | 166 | |
5ebd6703 | 167 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { |
33577b47 PD |
168 | replay_char_write_event_load(&res, &offset); |
169 | assert(offset <= len); | |
a9b1ca38 | 170 | qemu_chr_write_buffer(s, buf, offset, &offset, true); |
33577b47 PD |
171 | return res; |
172 | } | |
cd18720a | 173 | |
7b571ef3 AB |
174 | if (replay_mode == REPLAY_MODE_RECORD) { |
175 | /* | |
176 | * When recording we don't want temporary conditions to | |
177 | * perturb the result. By ensuring we write everything we can | |
178 | * while recording we avoid playback being out of sync if it | |
179 | * doesn't encounter the same temporary conditions (usually | |
180 | * triggered by external programs not reading the chardev fast | |
181 | * enough and pipes filling up). | |
182 | */ | |
183 | write_all = true; | |
184 | } | |
185 | ||
a9b1ca38 | 186 | res = qemu_chr_write_buffer(s, buf, len, &offset, write_all); |
cd18720a | 187 | |
5ebd6703 | 188 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { |
33577b47 | 189 | replay_char_write_event_save(res, offset); |
cd18720a AL |
190 | } |
191 | ||
9005b2a7 PB |
192 | if (res < 0) { |
193 | return res; | |
194 | } | |
cd18720a AL |
195 | return offset; |
196 | } | |
197 | ||
0ec7b3e7 | 198 | int qemu_chr_be_can_write(Chardev *s) |
6f97dba0 | 199 | { |
a4afa548 MAL |
200 | CharBackend *be = s->be; |
201 | ||
202 | if (!be || !be->chr_can_read) { | |
6f97dba0 | 203 | return 0; |
a4afa548 MAL |
204 | } |
205 | ||
206 | return be->chr_can_read(be->opaque); | |
6f97dba0 AL |
207 | } |
208 | ||
8f9abdf5 | 209 | void qemu_chr_be_write_impl(Chardev *s, const uint8_t *buf, int len) |
6f97dba0 | 210 | { |
a4afa548 MAL |
211 | CharBackend *be = s->be; |
212 | ||
213 | if (be && be->chr_read) { | |
214 | be->chr_read(be->opaque, buf, len); | |
ac310734 | 215 | } |
6f97dba0 AL |
216 | } |
217 | ||
8f9abdf5 | 218 | void qemu_chr_be_write(Chardev *s, const uint8_t *buf, int len) |
33577b47 | 219 | { |
5ebd6703 | 220 | if (qemu_chr_replay(s)) { |
33577b47 PD |
221 | if (replay_mode == REPLAY_MODE_PLAY) { |
222 | return; | |
223 | } | |
224 | replay_chr_be_write(s, buf, len); | |
225 | } else { | |
226 | qemu_chr_be_write_impl(s, buf, len); | |
227 | } | |
228 | } | |
229 | ||
07241c20 PX |
230 | void qemu_chr_be_update_read_handlers(Chardev *s, |
231 | GMainContext *context) | |
232 | { | |
233 | ChardevClass *cc = CHARDEV_GET_CLASS(s); | |
234 | ||
9ac3788b MAL |
235 | assert(qemu_chr_has_feature(s, QEMU_CHAR_FEATURE_GCONTEXT) |
236 | || !context); | |
95eeeba6 | 237 | s->gcontext = context; |
07241c20 | 238 | if (cc->chr_update_read_handler) { |
bb86d05f | 239 | cc->chr_update_read_handler(s); |
07241c20 PX |
240 | } |
241 | } | |
242 | ||
0ec7b3e7 | 243 | int qemu_chr_add_client(Chardev *s, int fd) |
13661089 | 244 | { |
777357d7 MAL |
245 | return CHARDEV_GET_CLASS(s)->chr_add_client ? |
246 | CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1; | |
13661089 DB |
247 | } |
248 | ||
777357d7 MAL |
249 | static void qemu_char_open(Chardev *chr, ChardevBackend *backend, |
250 | bool *be_opened, Error **errp) | |
6f97dba0 | 251 | { |
777357d7 MAL |
252 | ChardevClass *cc = CHARDEV_GET_CLASS(chr); |
253 | /* Any ChardevCommon member would work */ | |
254 | ChardevCommon *common = backend ? backend->u.null.data : NULL; | |
255 | ||
8de69efa | 256 | if (common && common->logfile) { |
692277f3 | 257 | int flags = O_WRONLY; |
777357d7 MAL |
258 | if (common->has_logappend && |
259 | common->logappend) { | |
260 | flags |= O_APPEND; | |
261 | } else { | |
262 | flags |= O_TRUNC; | |
263 | } | |
692277f3 | 264 | chr->logfd = qemu_create(common->logfile, flags, 0666, errp); |
777357d7 | 265 | if (chr->logfd < 0) { |
777357d7 MAL |
266 | return; |
267 | } | |
268 | } | |
269 | ||
270 | if (cc->open) { | |
271 | cc->open(chr, backend, be_opened, errp); | |
272 | } | |
6f97dba0 AL |
273 | } |
274 | ||
777357d7 | 275 | static void char_init(Object *obj) |
6f97dba0 | 276 | { |
777357d7 | 277 | Chardev *chr = CHARDEV(obj); |
6f97dba0 | 278 | |
feb774ca | 279 | chr->handover_yank_instance = false; |
777357d7 MAL |
280 | chr->logfd = -1; |
281 | qemu_mutex_init(&chr->chr_write_lock); | |
9ac3788b MAL |
282 | |
283 | /* | |
284 | * Assume if chr_update_read_handler is implemented it will | |
285 | * take the updated gcontext into account. | |
286 | */ | |
287 | if (CHARDEV_GET_CLASS(chr)->chr_update_read_handler) { | |
288 | qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT); | |
289 | } | |
290 | ||
777357d7 MAL |
291 | } |
292 | ||
eb314a94 MAL |
293 | static int null_chr_write(Chardev *chr, const uint8_t *buf, int len) |
294 | { | |
295 | return len; | |
296 | } | |
297 | ||
298 | static void char_class_init(ObjectClass *oc, void *data) | |
299 | { | |
300 | ChardevClass *cc = CHARDEV_CLASS(oc); | |
301 | ||
302 | cc->chr_write = null_chr_write; | |
d09c4a47 | 303 | cc->chr_be_event = chr_be_event; |
eb314a94 MAL |
304 | } |
305 | ||
777357d7 MAL |
306 | static void char_finalize(Object *obj) |
307 | { | |
308 | Chardev *chr = CHARDEV(obj); | |
309 | ||
310 | if (chr->be) { | |
311 | chr->be->chr = NULL; | |
312 | } | |
313 | g_free(chr->filename); | |
314 | g_free(chr->label); | |
315 | if (chr->logfd != -1) { | |
316 | close(chr->logfd); | |
d0d7708b | 317 | } |
777357d7 MAL |
318 | qemu_mutex_destroy(&chr->chr_write_lock); |
319 | } | |
320 | ||
321 | static const TypeInfo char_type_info = { | |
322 | .name = TYPE_CHARDEV, | |
323 | .parent = TYPE_OBJECT, | |
324 | .instance_size = sizeof(Chardev), | |
325 | .instance_init = char_init, | |
326 | .instance_finalize = char_finalize, | |
327 | .abstract = true, | |
328 | .class_size = sizeof(ChardevClass), | |
eb314a94 | 329 | .class_init = char_class_init, |
777357d7 MAL |
330 | }; |
331 | ||
0ec7b3e7 | 332 | static bool qemu_chr_is_busy(Chardev *s) |
a4afa548 | 333 | { |
777357d7 MAL |
334 | if (CHARDEV_IS_MUX(s)) { |
335 | MuxChardev *d = MUX_CHARDEV(s); | |
a4afa548 MAL |
336 | return d->mux_cnt >= 0; |
337 | } else { | |
338 | return s->be != NULL; | |
339 | } | |
340 | } | |
341 | ||
d24ca4b8 | 342 | int qemu_chr_wait_connected(Chardev *chr, Error **errp) |
6b6723c3 | 343 | { |
777357d7 MAL |
344 | ChardevClass *cc = CHARDEV_GET_CLASS(chr); |
345 | ||
346 | if (cc->chr_wait_connected) { | |
347 | return cc->chr_wait_connected(chr, errp); | |
6b6723c3 MAL |
348 | } |
349 | ||
350 | return 0; | |
351 | } | |
352 | ||
95e30b2a MAL |
353 | QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename, |
354 | bool permit_mux_mon) | |
191bc01b | 355 | { |
6ea314d9 | 356 | char host[65], port[33], width[8], height[8]; |
aeb2c47a | 357 | int pos; |
7d31544f | 358 | const char *p; |
191bc01b | 359 | QemuOpts *opts; |
8be7e7e4 | 360 | Error *local_err = NULL; |
191bc01b | 361 | |
8be7e7e4 | 362 | opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err); |
84d18f06 | 363 | if (local_err) { |
33394884 | 364 | error_report_err(local_err); |
191bc01b | 365 | return NULL; |
8be7e7e4 | 366 | } |
191bc01b | 367 | |
7591c5c1 | 368 | if (strstart(filename, "mon:", &p)) { |
95e30b2a MAL |
369 | if (!permit_mux_mon) { |
370 | error_report("mon: isn't supported in this context"); | |
371 | return NULL; | |
372 | } | |
7591c5c1 | 373 | filename = p; |
f43e47db | 374 | qemu_opt_set(opts, "mux", "on", &error_abort); |
02c4bdf1 PB |
375 | if (strcmp(filename, "stdio") == 0) { |
376 | /* Monitor is muxed to stdio: do not exit on Ctrl+C by default | |
377 | * but pass it to the guest. Handle this only for compat syntax, | |
378 | * for -chardev syntax we have special option for this. | |
379 | * This is what -nographic did, redirecting+muxing serial+monitor | |
380 | * to stdio causing Ctrl+C to be passed to guest. */ | |
f43e47db | 381 | qemu_opt_set(opts, "signal", "off", &error_abort); |
02c4bdf1 | 382 | } |
7591c5c1 GH |
383 | } |
384 | ||
f0457e8d GH |
385 | if (strcmp(filename, "null") == 0 || |
386 | strcmp(filename, "pty") == 0 || | |
387 | strcmp(filename, "msmouse") == 0 || | |
378af961 | 388 | strcmp(filename, "wctablet") == 0 || |
dc1c21e6 | 389 | strcmp(filename, "braille") == 0 || |
5692399f | 390 | strcmp(filename, "testdev") == 0 || |
f0457e8d | 391 | strcmp(filename, "stdio") == 0) { |
f43e47db | 392 | qemu_opt_set(opts, "backend", filename, &error_abort); |
191bc01b GH |
393 | return opts; |
394 | } | |
6ea314d9 | 395 | if (strstart(filename, "vc", &p)) { |
f43e47db | 396 | qemu_opt_set(opts, "backend", "vc", &error_abort); |
6ea314d9 | 397 | if (*p == ':') { |
49aa4058 | 398 | if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) { |
6ea314d9 | 399 | /* pixels */ |
f43e47db MA |
400 | qemu_opt_set(opts, "width", width, &error_abort); |
401 | qemu_opt_set(opts, "height", height, &error_abort); | |
49aa4058 | 402 | } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) { |
6ea314d9 | 403 | /* chars */ |
f43e47db MA |
404 | qemu_opt_set(opts, "cols", width, &error_abort); |
405 | qemu_opt_set(opts, "rows", height, &error_abort); | |
6ea314d9 GH |
406 | } else { |
407 | goto fail; | |
408 | } | |
409 | } | |
410 | return opts; | |
411 | } | |
d6c983cd | 412 | if (strcmp(filename, "con:") == 0) { |
f43e47db | 413 | qemu_opt_set(opts, "backend", "console", &error_abort); |
d6c983cd GH |
414 | return opts; |
415 | } | |
48b76496 | 416 | if (strstart(filename, "COM", NULL)) { |
f43e47db MA |
417 | qemu_opt_set(opts, "backend", "serial", &error_abort); |
418 | qemu_opt_set(opts, "path", filename, &error_abort); | |
48b76496 GH |
419 | return opts; |
420 | } | |
7d31544f | 421 | if (strstart(filename, "file:", &p)) { |
f43e47db MA |
422 | qemu_opt_set(opts, "backend", "file", &error_abort); |
423 | qemu_opt_set(opts, "path", p, &error_abort); | |
7d31544f GH |
424 | return opts; |
425 | } | |
426 | if (strstart(filename, "pipe:", &p)) { | |
f43e47db MA |
427 | qemu_opt_set(opts, "backend", "pipe", &error_abort); |
428 | qemu_opt_set(opts, "path", p, &error_abort); | |
7d31544f GH |
429 | return opts; |
430 | } | |
aeb2c47a | 431 | if (strstart(filename, "tcp:", &p) || |
ae92cbd5 | 432 | strstart(filename, "telnet:", &p) || |
981b06e7 JS |
433 | strstart(filename, "tn3270:", &p) || |
434 | strstart(filename, "websocket:", &p)) { | |
aeb2c47a GH |
435 | if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { |
436 | host[0] = 0; | |
437 | if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) | |
438 | goto fail; | |
439 | } | |
f43e47db MA |
440 | qemu_opt_set(opts, "backend", "socket", &error_abort); |
441 | qemu_opt_set(opts, "host", host, &error_abort); | |
442 | qemu_opt_set(opts, "port", port, &error_abort); | |
aeb2c47a | 443 | if (p[pos] == ',') { |
235e59cf | 444 | if (!qemu_opts_do_parse(opts, p + pos + 1, NULL, &local_err)) { |
dc523cd3 | 445 | error_report_err(local_err); |
aeb2c47a | 446 | goto fail; |
dc523cd3 | 447 | } |
aeb2c47a | 448 | } |
ae92cbd5 | 449 | if (strstart(filename, "telnet:", &p)) { |
f43e47db | 450 | qemu_opt_set(opts, "telnet", "on", &error_abort); |
ae92cbd5 JL |
451 | } else if (strstart(filename, "tn3270:", &p)) { |
452 | qemu_opt_set(opts, "tn3270", "on", &error_abort); | |
981b06e7 JS |
453 | } else if (strstart(filename, "websocket:", &p)) { |
454 | qemu_opt_set(opts, "websocket", "on", &error_abort); | |
ae92cbd5 | 455 | } |
aeb2c47a GH |
456 | return opts; |
457 | } | |
7e1b35b4 | 458 | if (strstart(filename, "udp:", &p)) { |
f43e47db | 459 | qemu_opt_set(opts, "backend", "udp", &error_abort); |
7e1b35b4 GH |
460 | if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) { |
461 | host[0] = 0; | |
39324ca4 | 462 | if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) { |
7e1b35b4 GH |
463 | goto fail; |
464 | } | |
465 | } | |
f43e47db MA |
466 | qemu_opt_set(opts, "host", host, &error_abort); |
467 | qemu_opt_set(opts, "port", port, &error_abort); | |
7e1b35b4 GH |
468 | if (p[pos] == '@') { |
469 | p += pos + 1; | |
470 | if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { | |
471 | host[0] = 0; | |
472 | if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) { | |
7e1b35b4 GH |
473 | goto fail; |
474 | } | |
475 | } | |
f43e47db MA |
476 | qemu_opt_set(opts, "localaddr", host, &error_abort); |
477 | qemu_opt_set(opts, "localport", port, &error_abort); | |
7e1b35b4 GH |
478 | } |
479 | return opts; | |
480 | } | |
aeb2c47a | 481 | if (strstart(filename, "unix:", &p)) { |
f43e47db | 482 | qemu_opt_set(opts, "backend", "socket", &error_abort); |
235e59cf | 483 | if (!qemu_opts_do_parse(opts, p, "path", &local_err)) { |
dc523cd3 | 484 | error_report_err(local_err); |
aeb2c47a | 485 | goto fail; |
dc523cd3 | 486 | } |
aeb2c47a GH |
487 | return opts; |
488 | } | |
48b76496 GH |
489 | if (strstart(filename, "/dev/parport", NULL) || |
490 | strstart(filename, "/dev/ppi", NULL)) { | |
73119c28 | 491 | qemu_opt_set(opts, "backend", "parallel", &error_abort); |
f43e47db | 492 | qemu_opt_set(opts, "path", filename, &error_abort); |
48b76496 GH |
493 | return opts; |
494 | } | |
495 | if (strstart(filename, "/dev/", NULL)) { | |
73119c28 | 496 | qemu_opt_set(opts, "backend", "serial", &error_abort); |
f43e47db | 497 | qemu_opt_set(opts, "path", filename, &error_abort); |
48b76496 GH |
498 | return opts; |
499 | } | |
191bc01b | 500 | |
0bf62dc8 DB |
501 | error_report("'%s' is not a valid char driver", filename); |
502 | ||
aeb2c47a | 503 | fail: |
191bc01b GH |
504 | qemu_opts_del(opts); |
505 | return NULL; | |
506 | } | |
507 | ||
21a933ea | 508 | void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend) |
d0d7708b DB |
509 | { |
510 | const char *logfile = qemu_opt_get(opts, "logfile"); | |
511 | ||
e1f98fe4 | 512 | backend->logfile = g_strdup(logfile); |
d0d7708b DB |
513 | backend->has_logappend = true; |
514 | backend->logappend = qemu_opt_get_bool(opts, "logappend", false); | |
515 | } | |
516 | ||
88cace9f MAL |
517 | static const ChardevClass *char_get_class(const char *driver, Error **errp) |
518 | { | |
519 | ObjectClass *oc; | |
520 | const ChardevClass *cc; | |
521 | char *typename = g_strdup_printf("chardev-%s", driver); | |
522 | ||
ef138c77 | 523 | oc = module_object_class_by_name(typename); |
88cace9f MAL |
524 | g_free(typename); |
525 | ||
526 | if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) { | |
527 | error_setg(errp, "'%s' is not a valid char driver name", driver); | |
528 | return NULL; | |
529 | } | |
d654f34e | 530 | |
88cace9f MAL |
531 | if (object_class_is_abstract(oc)) { |
532 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver", | |
4ad87cd4 | 533 | "a non-abstract device type"); |
88cace9f MAL |
534 | return NULL; |
535 | } | |
536 | ||
537 | cc = CHARDEV_CLASS(oc); | |
538 | if (cc->internal) { | |
539 | error_setg(errp, "'%s' is not a valid char driver name", driver); | |
540 | return NULL; | |
541 | } | |
542 | ||
543 | return cc; | |
544 | } | |
545 | ||
88cace9f | 546 | typedef struct ChadevClassFE { |
f3b70e07 | 547 | void (*fn)(const char *name, void *opaque); |
88cace9f MAL |
548 | void *opaque; |
549 | } ChadevClassFE; | |
550 | ||
551 | static void | |
552 | chardev_class_foreach(ObjectClass *klass, void *opaque) | |
2c5f4882 | 553 | { |
88cace9f MAL |
554 | ChadevClassFE *fe = opaque; |
555 | ||
556 | assert(g_str_has_prefix(object_class_get_name(klass), "chardev-")); | |
557 | if (CHARDEV_CLASS(klass)->internal) { | |
558 | return; | |
559 | } | |
560 | ||
f3b70e07 | 561 | fe->fn(object_class_get_name(klass) + 8, fe->opaque); |
88cace9f MAL |
562 | } |
563 | ||
564 | static void | |
f3b70e07 | 565 | chardev_name_foreach(void (*fn)(const char *name, void *opaque), |
1254bd39 | 566 | void *opaque) |
88cace9f MAL |
567 | { |
568 | ChadevClassFE fe = { .fn = fn, .opaque = opaque }; | |
88cace9f MAL |
569 | |
570 | object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe); | |
88cace9f MAL |
571 | } |
572 | ||
573 | static void | |
f3b70e07 | 574 | help_string_append(const char *name, void *opaque) |
88cace9f MAL |
575 | { |
576 | GString *str = opaque; | |
577 | ||
8513ec28 | 578 | g_string_append_printf(str, "\n %s", name); |
2c5f4882 GH |
579 | } |
580 | ||
75b60160 | 581 | ChardevBackend *qemu_chr_parse_opts(QemuOpts *opts, Error **errp) |
191bc01b | 582 | { |
0aff637e | 583 | Error *local_err = NULL; |
88cace9f | 584 | const ChardevClass *cc; |
0b663b7d | 585 | ChardevBackend *backend = NULL; |
6f9f6308 | 586 | const char *name = qemu_opt_get(opts, "backend"); |
191bc01b | 587 | |
0b812f31 | 588 | if (name == NULL) { |
312fd5f2 | 589 | error_setg(errp, "chardev: \"%s\" missing backend", |
bd2d80b2 | 590 | qemu_opts_id(opts)); |
0b663b7d | 591 | return NULL; |
1bbd185f | 592 | } |
517b3d40 | 593 | |
313e45b5 AN |
594 | cc = char_get_class(name, errp); |
595 | if (cc == NULL) { | |
596 | return NULL; | |
597 | } | |
598 | ||
599 | backend = g_new0(ChardevBackend, 1); | |
600 | backend->type = CHARDEV_BACKEND_KIND_NULL; | |
601 | ||
602 | if (cc->parse) { | |
603 | cc->parse(opts, backend, &local_err); | |
604 | if (local_err) { | |
605 | error_propagate(errp, local_err); | |
606 | qapi_free_ChardevBackend(backend); | |
607 | return NULL; | |
608 | } | |
609 | } else { | |
610 | ChardevCommon *ccom = g_new0(ChardevCommon, 1); | |
611 | qemu_chr_parse_common(opts, ccom); | |
612 | backend->u.null.data = ccom; /* Any ChardevCommon member would work */ | |
613 | } | |
614 | ||
615 | return backend; | |
616 | } | |
617 | ||
4ad6f6cb PB |
618 | Chardev *qemu_chr_new_from_opts(QemuOpts *opts, GMainContext *context, |
619 | Error **errp) | |
313e45b5 AN |
620 | { |
621 | const ChardevClass *cc; | |
622 | Chardev *chr = NULL; | |
623 | ChardevBackend *backend = NULL; | |
6f9f6308 | 624 | const char *name = qemu_opt_get(opts, "backend"); |
313e45b5 AN |
625 | const char *id = qemu_opts_id(opts); |
626 | char *bid = NULL; | |
627 | ||
628 | if (name && is_help_option(name)) { | |
776a32a0 | 629 | GString *str = g_string_new(""); |
88cace9f MAL |
630 | |
631 | chardev_name_foreach(help_string_append, str); | |
776a32a0 | 632 | |
ef2fd6f1 | 633 | qemu_printf("Available chardev backend types: %s\n", str->str); |
776a32a0 | 634 | g_string_free(str, true); |
0ec846bf | 635 | return NULL; |
517b3d40 LM |
636 | } |
637 | ||
638 | if (id == NULL) { | |
639 | error_setg(errp, "chardev: no id specified"); | |
0b663b7d | 640 | return NULL; |
517b3d40 LM |
641 | } |
642 | ||
313e45b5 AN |
643 | backend = qemu_chr_parse_opts(opts, errp); |
644 | if (backend == NULL) { | |
645 | return NULL; | |
191bc01b | 646 | } |
88cace9f MAL |
647 | |
648 | cc = char_get_class(name, errp); | |
649 | if (cc == NULL) { | |
313e45b5 | 650 | goto out; |
191bc01b GH |
651 | } |
652 | ||
a61ae7f8 PM |
653 | if (qemu_opt_get_bool(opts, "mux", 0)) { |
654 | bid = g_strdup_printf("%s-base", id); | |
655 | } | |
2c5f4882 | 656 | |
c5749f7c | 657 | chr = qemu_chardev_new(bid ? bid : id, |
0b663b7d | 658 | object_class_get_name(OBJECT_CLASS(cc)), |
4ad6f6cb | 659 | backend, context, errp); |
c5749f7c | 660 | |
0b663b7d MAL |
661 | if (chr == NULL) { |
662 | goto out; | |
191bc01b GH |
663 | } |
664 | ||
a61ae7f8 | 665 | if (bid) { |
0b663b7d | 666 | Chardev *mux; |
a61ae7f8 | 667 | qapi_free_ChardevBackend(backend); |
a61ae7f8 | 668 | backend = g_new0(ChardevBackend, 1); |
130257dc | 669 | backend->type = CHARDEV_BACKEND_KIND_MUX; |
0b663b7d | 670 | backend->u.mux.data = g_new0(ChardevMux, 1); |
32bafa8f | 671 | backend->u.mux.data->chardev = g_strdup(bid); |
4ad6f6cb | 672 | mux = qemu_chardev_new(id, TYPE_CHARDEV_MUX, backend, context, errp); |
0b663b7d | 673 | if (mux == NULL) { |
2f5d45a1 | 674 | object_unparent(OBJECT(chr)); |
a61ae7f8 | 675 | chr = NULL; |
0b663b7d | 676 | goto out; |
a61ae7f8 | 677 | } |
0b663b7d | 678 | chr = mux; |
bd5c51ee | 679 | } |
7591c5c1 | 680 | |
0b663b7d | 681 | out: |
a61ae7f8 | 682 | qapi_free_ChardevBackend(backend); |
a61ae7f8 | 683 | g_free(bid); |
191bc01b GH |
684 | return chr; |
685 | } | |
686 | ||
95e30b2a | 687 | Chardev *qemu_chr_new_noreplay(const char *label, const char *filename, |
4ad6f6cb | 688 | bool permit_mux_mon, GMainContext *context) |
6f97dba0 AL |
689 | { |
690 | const char *p; | |
0ec7b3e7 | 691 | Chardev *chr; |
191bc01b | 692 | QemuOpts *opts; |
bd2d80b2 | 693 | Error *err = NULL; |
191bc01b | 694 | |
c845f401 GH |
695 | if (strstart(filename, "chardev:", &p)) { |
696 | return qemu_chr_find(p); | |
697 | } | |
698 | ||
95e30b2a | 699 | opts = qemu_chr_parse_compat(label, filename, permit_mux_mon); |
7e1b35b4 GH |
700 | if (!opts) |
701 | return NULL; | |
6f97dba0 | 702 | |
4ad6f6cb | 703 | chr = qemu_chr_new_from_opts(opts, context, &err); |
95e30b2a | 704 | if (!chr) { |
565f65d2 | 705 | error_report_err(err); |
95e30b2a | 706 | goto out; |
bd2d80b2 | 707 | } |
95e30b2a MAL |
708 | |
709 | if (qemu_opt_get_bool(opts, "mux", 0)) { | |
710 | assert(permit_mux_mon); | |
8e9119a8 KW |
711 | monitor_init_hmp(chr, true, &err); |
712 | if (err) { | |
713 | error_report_err(err); | |
714 | object_unparent(OBJECT(chr)); | |
715 | chr = NULL; | |
716 | goto out; | |
717 | } | |
6f97dba0 | 718 | } |
95e30b2a MAL |
719 | |
720 | out: | |
0a73336d | 721 | qemu_opts_del(opts); |
6f97dba0 AL |
722 | return chr; |
723 | } | |
724 | ||
95e30b2a MAL |
725 | static Chardev *qemu_chr_new_permit_mux_mon(const char *label, |
726 | const char *filename, | |
4ad6f6cb PB |
727 | bool permit_mux_mon, |
728 | GMainContext *context) | |
33577b47 | 729 | { |
0ec7b3e7 | 730 | Chardev *chr; |
4ad6f6cb | 731 | chr = qemu_chr_new_noreplay(label, filename, permit_mux_mon, context); |
33577b47 | 732 | if (chr) { |
5ebd6703 MAL |
733 | if (replay_mode != REPLAY_MODE_NONE) { |
734 | qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY); | |
735 | } | |
777357d7 | 736 | if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) { |
776a32a0 MAL |
737 | error_report("Replay: ioctl is not supported " |
738 | "for serial devices yet"); | |
33577b47 PD |
739 | } |
740 | replay_register_char_driver(chr); | |
741 | } | |
742 | return chr; | |
743 | } | |
744 | ||
4ad6f6cb PB |
745 | Chardev *qemu_chr_new(const char *label, const char *filename, |
746 | GMainContext *context) | |
95e30b2a | 747 | { |
4ad6f6cb | 748 | return qemu_chr_new_permit_mux_mon(label, filename, false, context); |
95e30b2a MAL |
749 | } |
750 | ||
4ad6f6cb PB |
751 | Chardev *qemu_chr_new_mux_mon(const char *label, const char *filename, |
752 | GMainContext *context) | |
95e30b2a | 753 | { |
4ad6f6cb | 754 | return qemu_chr_new_permit_mux_mon(label, filename, true, context); |
95e30b2a MAL |
755 | } |
756 | ||
6061162e | 757 | static int qmp_query_chardev_foreach(Object *obj, void *data) |
1ad78ea5 | 758 | { |
6061162e MAL |
759 | Chardev *chr = CHARDEV(obj); |
760 | ChardevInfoList **list = data; | |
54aa3de7 | 761 | ChardevInfo *value = g_malloc0(sizeof(*value)); |
6061162e | 762 | |
54aa3de7 EB |
763 | value->label = g_strdup(chr->label); |
764 | value->filename = g_strdup(chr->filename); | |
67b5595d | 765 | value->frontend_open = chr->be && chr->be->fe_is_open; |
6061162e | 766 | |
54aa3de7 | 767 | QAPI_LIST_PREPEND(*list, value); |
6061162e MAL |
768 | |
769 | return 0; | |
1ad78ea5 MAL |
770 | } |
771 | ||
c5a415a0 | 772 | ChardevInfoList *qmp_query_chardev(Error **errp) |
6f97dba0 | 773 | { |
c5a415a0 | 774 | ChardevInfoList *chr_list = NULL; |
6f97dba0 | 775 | |
6061162e MAL |
776 | object_child_foreach(get_chardevs_root(), |
777 | qmp_query_chardev_foreach, &chr_list); | |
588b3832 | 778 | |
c5a415a0 | 779 | return chr_list; |
6f97dba0 | 780 | } |
c845f401 | 781 | |
88cace9f | 782 | static void |
f3b70e07 | 783 | qmp_prepend_backend(const char *name, void *opaque) |
0b812f31 | 784 | { |
88cace9f | 785 | ChardevBackendInfoList **list = opaque; |
1254bd39 | 786 | ChardevBackendInfo *value; |
88cace9f | 787 | |
1254bd39 | 788 | value = g_new0(ChardevBackendInfo, 1); |
54aa3de7 EB |
789 | value->name = g_strdup(name); |
790 | QAPI_LIST_PREPEND(*list, value); | |
0b812f31 MAL |
791 | } |
792 | ||
77d1c3c6 MK |
793 | ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp) |
794 | { | |
795 | ChardevBackendInfoList *backend_list = NULL; | |
a1698bf1 | 796 | |
88cace9f | 797 | chardev_name_foreach(qmp_prepend_backend, &backend_list); |
77d1c3c6 MK |
798 | |
799 | return backend_list; | |
800 | } | |
801 | ||
0ec7b3e7 | 802 | Chardev *qemu_chr_find(const char *name) |
c845f401 | 803 | { |
6061162e | 804 | Object *obj = object_resolve_path_component(get_chardevs_root(), name); |
c845f401 | 805 | |
6061162e | 806 | return obj ? CHARDEV(obj) : NULL; |
c845f401 | 807 | } |
0beb4942 | 808 | |
4d454574 PB |
809 | QemuOptsList qemu_chardev_opts = { |
810 | .name = "chardev", | |
811 | .implied_opt_name = "backend", | |
812 | .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), | |
813 | .desc = { | |
814 | { | |
815 | .name = "backend", | |
816 | .type = QEMU_OPT_STRING, | |
817 | },{ | |
818 | .name = "path", | |
819 | .type = QEMU_OPT_STRING, | |
5b18a6bf PM |
820 | },{ |
821 | .name = "input-path", | |
822 | .type = QEMU_OPT_STRING, | |
4d454574 PB |
823 | },{ |
824 | .name = "host", | |
825 | .type = QEMU_OPT_STRING, | |
826 | },{ | |
827 | .name = "port", | |
828 | .type = QEMU_OPT_STRING, | |
0935700f DB |
829 | },{ |
830 | .name = "fd", | |
831 | .type = QEMU_OPT_STRING, | |
4d454574 PB |
832 | },{ |
833 | .name = "localaddr", | |
834 | .type = QEMU_OPT_STRING, | |
835 | },{ | |
836 | .name = "localport", | |
837 | .type = QEMU_OPT_STRING, | |
838 | },{ | |
839 | .name = "to", | |
840 | .type = QEMU_OPT_NUMBER, | |
841 | },{ | |
842 | .name = "ipv4", | |
843 | .type = QEMU_OPT_BOOL, | |
844 | },{ | |
845 | .name = "ipv6", | |
846 | .type = QEMU_OPT_BOOL, | |
847 | },{ | |
848 | .name = "wait", | |
849 | .type = QEMU_OPT_BOOL, | |
850 | },{ | |
851 | .name = "server", | |
852 | .type = QEMU_OPT_BOOL, | |
853 | },{ | |
854 | .name = "delay", | |
855 | .type = QEMU_OPT_BOOL, | |
a9b1315f PB |
856 | },{ |
857 | .name = "nodelay", | |
858 | .type = QEMU_OPT_BOOL, | |
5dd1f02b CM |
859 | },{ |
860 | .name = "reconnect", | |
861 | .type = QEMU_OPT_NUMBER, | |
4d454574 PB |
862 | },{ |
863 | .name = "telnet", | |
864 | .type = QEMU_OPT_BOOL, | |
ae92cbd5 JL |
865 | },{ |
866 | .name = "tn3270", | |
867 | .type = QEMU_OPT_BOOL, | |
a8fb5427 DB |
868 | },{ |
869 | .name = "tls-creds", | |
870 | .type = QEMU_OPT_STRING, | |
fd4a5fd4 DB |
871 | },{ |
872 | .name = "tls-authz", | |
873 | .type = QEMU_OPT_STRING, | |
981b06e7 JS |
874 | },{ |
875 | .name = "websocket", | |
876 | .type = QEMU_OPT_BOOL, | |
4d454574 PB |
877 | },{ |
878 | .name = "width", | |
879 | .type = QEMU_OPT_NUMBER, | |
880 | },{ | |
881 | .name = "height", | |
882 | .type = QEMU_OPT_NUMBER, | |
883 | },{ | |
884 | .name = "cols", | |
885 | .type = QEMU_OPT_NUMBER, | |
886 | },{ | |
887 | .name = "rows", | |
888 | .type = QEMU_OPT_NUMBER, | |
889 | },{ | |
890 | .name = "mux", | |
891 | .type = QEMU_OPT_BOOL, | |
892 | },{ | |
893 | .name = "signal", | |
894 | .type = QEMU_OPT_BOOL, | |
895 | },{ | |
896 | .name = "name", | |
897 | .type = QEMU_OPT_STRING, | |
898 | },{ | |
899 | .name = "debug", | |
900 | .type = QEMU_OPT_NUMBER, | |
51767e7c | 901 | },{ |
3949e594 | 902 | .name = "size", |
de1cc36e | 903 | .type = QEMU_OPT_SIZE, |
bb6fb7c0 GH |
904 | },{ |
905 | .name = "chardev", | |
906 | .type = QEMU_OPT_STRING, | |
31e38a22 OK |
907 | },{ |
908 | .name = "append", | |
909 | .type = QEMU_OPT_BOOL, | |
d0d7708b DB |
910 | },{ |
911 | .name = "logfile", | |
912 | .type = QEMU_OPT_STRING, | |
913 | },{ | |
914 | .name = "logappend", | |
915 | .type = QEMU_OPT_BOOL, | |
56081919 GH |
916 | },{ |
917 | .name = "mouse", | |
918 | .type = QEMU_OPT_BOOL, | |
f0349f4d GH |
919 | },{ |
920 | .name = "clipboard", | |
921 | .type = QEMU_OPT_BOOL, | |
8acefc79 | 922 | #ifdef CONFIG_LINUX |
776b97d3 XZ |
923 | },{ |
924 | .name = "tight", | |
925 | .type = QEMU_OPT_BOOL, | |
926 | .def_value_str = "on", | |
927 | },{ | |
928 | .name = "abstract", | |
929 | .type = QEMU_OPT_BOOL, | |
8acefc79 | 930 | #endif |
4d454574 PB |
931 | }, |
932 | { /* end of list */ } | |
933 | }, | |
934 | }; | |
f1a1a356 | 935 | |
0ec7b3e7 | 936 | bool qemu_chr_has_feature(Chardev *chr, |
279b066e | 937 | ChardevFeature feature) |
0a73336d DB |
938 | { |
939 | return test_bit(feature, chr->features); | |
940 | } | |
941 | ||
0ec7b3e7 | 942 | void qemu_chr_set_feature(Chardev *chr, |
279b066e | 943 | ChardevFeature feature) |
0a73336d DB |
944 | { |
945 | return set_bit(feature, chr->features); | |
946 | } | |
947 | ||
1e419ee6 MAL |
948 | static Chardev *chardev_new(const char *id, const char *typename, |
949 | ChardevBackend *backend, | |
950 | GMainContext *gcontext, | |
feb774ca | 951 | bool handover_yank_instance, |
1e419ee6 | 952 | Error **errp) |
f1a1a356 | 953 | { |
2f5d45a1 | 954 | Object *obj; |
0ec7b3e7 | 955 | Chardev *chr = NULL; |
eaeba653 | 956 | Error *local_err = NULL; |
82878dac | 957 | bool be_opened = true; |
f1a1a356 | 958 | |
777357d7 | 959 | assert(g_str_has_prefix(typename, "chardev-")); |
f36b0efd | 960 | assert(id); |
f1a1a356 | 961 | |
2f5d45a1 MAL |
962 | obj = object_new(typename); |
963 | chr = CHARDEV(obj); | |
feb774ca | 964 | chr->handover_yank_instance = handover_yank_instance; |
777357d7 | 965 | chr->label = g_strdup(id); |
4ad6f6cb | 966 | chr->gcontext = gcontext; |
4ca17281 | 967 | |
777357d7 | 968 | qemu_char_open(chr, backend, &be_opened, &local_err); |
a1698bf1 | 969 | if (local_err) { |
789fd693 LS |
970 | error_propagate(errp, local_err); |
971 | object_unref(obj); | |
972 | return NULL; | |
eaeba653 PB |
973 | } |
974 | ||
eaeba653 | 975 | if (!chr->filename) { |
777357d7 | 976 | chr->filename = g_strdup(typename + 8); |
f1a1a356 | 977 | } |
82878dac | 978 | if (be_opened) { |
eaeba653 PB |
979 | qemu_chr_be_event(chr, CHR_EVENT_OPENED); |
980 | } | |
777357d7 MAL |
981 | |
982 | return chr; | |
983 | } | |
984 | ||
1e419ee6 MAL |
985 | Chardev *qemu_chardev_new(const char *id, const char *typename, |
986 | ChardevBackend *backend, | |
987 | GMainContext *gcontext, | |
988 | Error **errp) | |
989 | { | |
789fd693 | 990 | Chardev *chr; |
1e419ee6 MAL |
991 | g_autofree char *genid = NULL; |
992 | ||
993 | if (!id) { | |
994 | genid = id_generate(ID_CHR); | |
995 | id = genid; | |
996 | } | |
997 | ||
feb774ca | 998 | chr = chardev_new(id, typename, backend, gcontext, false, errp); |
789fd693 LS |
999 | if (!chr) { |
1000 | return NULL; | |
1001 | } | |
1002 | ||
1003 | if (!object_property_try_add_child(get_chardevs_root(), id, OBJECT(chr), | |
1004 | errp)) { | |
1005 | object_unref(OBJECT(chr)); | |
1006 | return NULL; | |
1007 | } | |
1008 | object_unref(OBJECT(chr)); | |
1009 | ||
1010 | return chr; | |
1e419ee6 MAL |
1011 | } |
1012 | ||
777357d7 MAL |
1013 | ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, |
1014 | Error **errp) | |
1015 | { | |
64195b0d | 1016 | ERRP_GUARD(); |
777357d7 MAL |
1017 | const ChardevClass *cc; |
1018 | ChardevReturn *ret; | |
64195b0d | 1019 | g_autoptr(Chardev) chr = NULL; |
777357d7 | 1020 | |
a68403b0 MAL |
1021 | if (qemu_chr_find(id)) { |
1022 | error_setg(errp, "Chardev with id '%s' already exists", id); | |
1023 | return NULL; | |
1024 | } | |
1025 | ||
977c736f | 1026 | cc = char_get_class(ChardevBackendKind_str(backend->type), errp); |
777357d7 | 1027 | if (!cc) { |
64195b0d | 1028 | goto err; |
777357d7 MAL |
1029 | } |
1030 | ||
1e419ee6 | 1031 | chr = chardev_new(id, object_class_get_name(OBJECT_CLASS(cc)), |
feb774ca | 1032 | backend, NULL, false, errp); |
777357d7 | 1033 | if (!chr) { |
64195b0d | 1034 | goto err; |
777357d7 MAL |
1035 | } |
1036 | ||
789fd693 LS |
1037 | if (!object_property_try_add_child(get_chardevs_root(), id, OBJECT(chr), |
1038 | errp)) { | |
64195b0d | 1039 | goto err; |
789fd693 | 1040 | } |
789fd693 | 1041 | |
777357d7 MAL |
1042 | ret = g_new0(ChardevReturn, 1); |
1043 | if (CHARDEV_IS_PTY(chr)) { | |
1044 | ret->pty = g_strdup(chr->filename + 4); | |
777357d7 MAL |
1045 | } |
1046 | ||
eaeba653 | 1047 | return ret; |
64195b0d MAL |
1048 | |
1049 | err: | |
1050 | error_prepend(errp, "Failed to add chardev '%s': ", id); | |
1051 | return NULL; | |
f1a1a356 GH |
1052 | } |
1053 | ||
7bb86085 AN |
1054 | ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend, |
1055 | Error **errp) | |
1056 | { | |
1057 | CharBackend *be; | |
feb774ca | 1058 | const ChardevClass *cc, *cc_new; |
7bb86085 AN |
1059 | Chardev *chr, *chr_new; |
1060 | bool closed_sent = false; | |
feb774ca | 1061 | bool handover_yank_instance; |
7bb86085 AN |
1062 | ChardevReturn *ret; |
1063 | ||
1064 | chr = qemu_chr_find(id); | |
1065 | if (!chr) { | |
1066 | error_setg(errp, "Chardev '%s' does not exist", id); | |
1067 | return NULL; | |
1068 | } | |
1069 | ||
1070 | if (CHARDEV_IS_MUX(chr)) { | |
1071 | error_setg(errp, "Mux device hotswap not supported yet"); | |
1072 | return NULL; | |
1073 | } | |
1074 | ||
1075 | if (qemu_chr_replay(chr)) { | |
1076 | error_setg(errp, | |
1077 | "Chardev '%s' cannot be changed in record/replay mode", id); | |
1078 | return NULL; | |
1079 | } | |
1080 | ||
1081 | be = chr->be; | |
1082 | if (!be) { | |
1083 | /* easy case */ | |
1084 | object_unparent(OBJECT(chr)); | |
1085 | return qmp_chardev_add(id, backend, errp); | |
1086 | } | |
1087 | ||
1088 | if (!be->chr_be_change) { | |
1089 | error_setg(errp, "Chardev user does not support chardev hotswap"); | |
1090 | return NULL; | |
1091 | } | |
1092 | ||
feb774ca LS |
1093 | cc = CHARDEV_GET_CLASS(chr); |
1094 | cc_new = char_get_class(ChardevBackendKind_str(backend->type), errp); | |
1095 | if (!cc_new) { | |
7bb86085 AN |
1096 | return NULL; |
1097 | } | |
1098 | ||
feb774ca LS |
1099 | /* |
1100 | * The new chardev should not register a yank instance if the current | |
1101 | * chardev has registered one already. | |
1102 | */ | |
1103 | handover_yank_instance = cc->supports_yank && cc_new->supports_yank; | |
1104 | ||
1105 | chr_new = chardev_new(id, object_class_get_name(OBJECT_CLASS(cc_new)), | |
1106 | backend, chr->gcontext, handover_yank_instance, errp); | |
7bb86085 AN |
1107 | if (!chr_new) { |
1108 | return NULL; | |
1109 | } | |
7bb86085 AN |
1110 | |
1111 | if (chr->be_open && !chr_new->be_open) { | |
1112 | qemu_chr_be_event(chr, CHR_EVENT_CLOSED); | |
1113 | closed_sent = true; | |
1114 | } | |
1115 | ||
1116 | chr->be = NULL; | |
1117 | qemu_chr_fe_init(be, chr_new, &error_abort); | |
1118 | ||
1119 | if (be->chr_be_change(be->opaque) < 0) { | |
1120 | error_setg(errp, "Chardev '%s' change failed", chr_new->label); | |
1121 | chr_new->be = NULL; | |
1122 | qemu_chr_fe_init(be, chr, &error_abort); | |
1123 | if (closed_sent) { | |
1124 | qemu_chr_be_event(chr, CHR_EVENT_OPENED); | |
1125 | } | |
1126 | object_unref(OBJECT(chr_new)); | |
1127 | return NULL; | |
1128 | } | |
1129 | ||
0a19d879 | 1130 | /* change successful, clean up */ |
feb774ca LS |
1131 | chr_new->handover_yank_instance = false; |
1132 | ||
1133 | /* | |
1134 | * When the old chardev is freed, it should not unregister the yank | |
1135 | * instance if the new chardev needs it. | |
1136 | */ | |
1137 | chr->handover_yank_instance = handover_yank_instance; | |
1138 | ||
7bb86085 AN |
1139 | object_unparent(OBJECT(chr)); |
1140 | object_property_add_child(get_chardevs_root(), chr_new->label, | |
d2623129 | 1141 | OBJECT(chr_new)); |
7bb86085 AN |
1142 | object_unref(OBJECT(chr_new)); |
1143 | ||
1144 | ret = g_new0(ChardevReturn, 1); | |
1145 | if (CHARDEV_IS_PTY(chr_new)) { | |
1146 | ret->pty = g_strdup(chr_new->filename + 4); | |
7bb86085 AN |
1147 | } |
1148 | ||
1149 | return ret; | |
1150 | } | |
1151 | ||
f1a1a356 GH |
1152 | void qmp_chardev_remove(const char *id, Error **errp) |
1153 | { | |
0ec7b3e7 | 1154 | Chardev *chr; |
f1a1a356 GH |
1155 | |
1156 | chr = qemu_chr_find(id); | |
8108fd3e | 1157 | if (chr == NULL) { |
f1a1a356 GH |
1158 | error_setg(errp, "Chardev '%s' not found", id); |
1159 | return; | |
1160 | } | |
a4afa548 | 1161 | if (qemu_chr_is_busy(chr)) { |
f1a1a356 GH |
1162 | error_setg(errp, "Chardev '%s' is busy", id); |
1163 | return; | |
1164 | } | |
5ebd6703 | 1165 | if (qemu_chr_replay(chr)) { |
33577b47 PD |
1166 | error_setg(errp, |
1167 | "Chardev '%s' cannot be unplugged in record/replay mode", id); | |
1168 | return; | |
1169 | } | |
2f5d45a1 | 1170 | object_unparent(OBJECT(chr)); |
f1a1a356 | 1171 | } |
d654f34e | 1172 | |
bd1d5ad9 SF |
1173 | void qmp_chardev_send_break(const char *id, Error **errp) |
1174 | { | |
1175 | Chardev *chr; | |
1176 | ||
1177 | chr = qemu_chr_find(id); | |
1178 | if (chr == NULL) { | |
1179 | error_setg(errp, "Chardev '%s' not found", id); | |
1180 | return; | |
1181 | } | |
1182 | qemu_chr_be_event(chr, CHR_EVENT_BREAK); | |
1183 | } | |
1184 | ||
c3054a6e MA |
1185 | bool qmp_add_client_char(int fd, bool has_skipauth, bool skipauth, |
1186 | bool has_tls, bool tls, const char *protocol, | |
1187 | Error **errp) | |
1188 | { | |
1189 | Chardev *s = qemu_chr_find(protocol); | |
1190 | ||
1191 | if (!s) { | |
1192 | error_setg(errp, "protocol '%s' is invalid", protocol); | |
c3054a6e MA |
1193 | return false; |
1194 | } | |
1195 | if (qemu_chr_add_client(s, fd) < 0) { | |
1196 | error_setg(errp, "failed to add client"); | |
c3054a6e MA |
1197 | return false; |
1198 | } | |
1199 | return true; | |
1200 | } | |
1201 | ||
2c716ba1 PX |
1202 | /* |
1203 | * Add a timeout callback for the chardev (in milliseconds), return | |
1204 | * the GSource object created. Please use this to add timeout hook for | |
1205 | * chardev instead of g_timeout_add() and g_timeout_add_seconds(), to | |
1206 | * make sure the gcontext that the task bound to is correct. | |
1207 | */ | |
1208 | GSource *qemu_chr_timeout_add_ms(Chardev *chr, guint ms, | |
1209 | GSourceFunc func, void *private) | |
1210 | { | |
1211 | GSource *source = g_timeout_source_new(ms); | |
1212 | ||
1213 | assert(func); | |
1214 | g_source_set_callback(source, func, private, NULL); | |
1215 | g_source_attach(source, chr->gcontext); | |
1216 | ||
1217 | return source; | |
1218 | } | |
1219 | ||
aa5cb7f5 | 1220 | void qemu_chr_cleanup(void) |
c1111a24 | 1221 | { |
2f5d45a1 | 1222 | object_unparent(get_chardevs_root()); |
c1111a24 MAL |
1223 | } |
1224 | ||
d654f34e AL |
1225 | static void register_types(void) |
1226 | { | |
88cace9f | 1227 | type_register_static(&char_type_info); |
d654f34e AL |
1228 | } |
1229 | ||
1230 | type_init(register_types); |