]>
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" |
9c17d615 | 28 | #include "sysemu/sysemu.h" |
213dcb06 | 29 | #include "qemu/config-file.h" |
d49b6836 | 30 | #include "qemu/error-report.h" |
8228e353 | 31 | #include "chardev/char.h" |
e688df6b | 32 | #include "qapi/error.h" |
9af23989 | 33 | #include "qapi/qapi-commands-char.h" |
0dd13589 | 34 | #include "qapi/qmp/qerror.h" |
33577b47 | 35 | #include "sysemu/replay.h" |
517b3d40 | 36 | #include "qemu/help_option.h" |
922a01a0 | 37 | #include "qemu/option.h" |
6f97dba0 | 38 | |
8228e353 | 39 | #include "chardev/char-mux.h" |
df85a78b | 40 | |
6f97dba0 AL |
41 | /***********************************************************/ |
42 | /* character device */ | |
43 | ||
2f5d45a1 MAL |
44 | static Object *get_chardevs_root(void) |
45 | { | |
46 | return container_get(object_get_root(), "/chardevs"); | |
47 | } | |
2970a6c9 | 48 | |
d09c4a47 | 49 | static void chr_be_event(Chardev *s, int event) |
6f97dba0 | 50 | { |
a4afa548 MAL |
51 | CharBackend *be = s->be; |
52 | ||
d09c4a47 MAL |
53 | if (!be || !be->chr_event) { |
54 | return; | |
55 | } | |
56 | ||
57 | be->chr_event(be->opaque, event); | |
58 | } | |
59 | ||
60 | void qemu_chr_be_event(Chardev *s, int event) | |
61 | { | |
73cdf3f2 AG |
62 | /* Keep track if the char device is open */ |
63 | switch (event) { | |
64 | case CHR_EVENT_OPENED: | |
16665b94 | 65 | s->be_open = 1; |
73cdf3f2 AG |
66 | break; |
67 | case CHR_EVENT_CLOSED: | |
16665b94 | 68 | s->be_open = 0; |
73cdf3f2 AG |
69 | break; |
70 | } | |
71 | ||
d09c4a47 | 72 | CHARDEV_GET_CLASS(s)->chr_be_event(s, event); |
6f97dba0 AL |
73 | } |
74 | ||
d0d7708b DB |
75 | /* Not reporting errors from writing to logfile, as logs are |
76 | * defined to be "best effort" only */ | |
a9b1ca38 | 77 | static void qemu_chr_write_log(Chardev *s, const uint8_t *buf, size_t len) |
d0d7708b DB |
78 | { |
79 | size_t done = 0; | |
80 | ssize_t ret; | |
81 | ||
82 | if (s->logfd < 0) { | |
83 | return; | |
84 | } | |
85 | ||
86 | while (done < len) { | |
53628efb DB |
87 | retry: |
88 | ret = write(s->logfd, buf + done, len - done); | |
89 | if (ret == -1 && errno == EAGAIN) { | |
90 | g_usleep(100); | |
91 | goto retry; | |
92 | } | |
d0d7708b DB |
93 | |
94 | if (ret <= 0) { | |
95 | return; | |
96 | } | |
97 | done += ret; | |
98 | } | |
99 | } | |
100 | ||
a9b1ca38 MAL |
101 | static int qemu_chr_write_buffer(Chardev *s, |
102 | const uint8_t *buf, int len, | |
103 | int *offset, bool write_all) | |
33577b47 | 104 | { |
777357d7 | 105 | ChardevClass *cc = CHARDEV_GET_CLASS(s); |
33577b47 PD |
106 | int res = 0; |
107 | *offset = 0; | |
108 | ||
109 | qemu_mutex_lock(&s->chr_write_lock); | |
110 | while (*offset < len) { | |
53628efb | 111 | retry: |
777357d7 | 112 | res = cc->chr_write(s, buf + *offset, len - *offset); |
c90e9392 | 113 | if (res < 0 && errno == EAGAIN && write_all) { |
53628efb DB |
114 | g_usleep(100); |
115 | goto retry; | |
116 | } | |
33577b47 PD |
117 | |
118 | if (res <= 0) { | |
119 | break; | |
120 | } | |
121 | ||
122 | *offset += res; | |
c90e9392 MAL |
123 | if (!write_all) { |
124 | break; | |
125 | } | |
33577b47 PD |
126 | } |
127 | if (*offset > 0) { | |
a9b1ca38 | 128 | qemu_chr_write_log(s, buf, *offset); |
33577b47 PD |
129 | } |
130 | qemu_mutex_unlock(&s->chr_write_lock); | |
131 | ||
132 | return res; | |
133 | } | |
134 | ||
4d43a603 | 135 | int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all) |
cd18720a | 136 | { |
c90e9392 | 137 | int offset = 0; |
33577b47 | 138 | int res; |
cd18720a | 139 | |
5ebd6703 | 140 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { |
33577b47 PD |
141 | replay_char_write_event_load(&res, &offset); |
142 | assert(offset <= len); | |
a9b1ca38 | 143 | qemu_chr_write_buffer(s, buf, offset, &offset, true); |
33577b47 PD |
144 | return res; |
145 | } | |
cd18720a | 146 | |
a9b1ca38 | 147 | res = qemu_chr_write_buffer(s, buf, len, &offset, write_all); |
cd18720a | 148 | |
5ebd6703 | 149 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { |
33577b47 | 150 | replay_char_write_event_save(res, offset); |
cd18720a AL |
151 | } |
152 | ||
9005b2a7 PB |
153 | if (res < 0) { |
154 | return res; | |
155 | } | |
cd18720a AL |
156 | return offset; |
157 | } | |
158 | ||
0ec7b3e7 | 159 | int qemu_chr_be_can_write(Chardev *s) |
6f97dba0 | 160 | { |
a4afa548 MAL |
161 | CharBackend *be = s->be; |
162 | ||
163 | if (!be || !be->chr_can_read) { | |
6f97dba0 | 164 | return 0; |
a4afa548 MAL |
165 | } |
166 | ||
167 | return be->chr_can_read(be->opaque); | |
6f97dba0 AL |
168 | } |
169 | ||
0ec7b3e7 | 170 | void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len) |
6f97dba0 | 171 | { |
a4afa548 MAL |
172 | CharBackend *be = s->be; |
173 | ||
174 | if (be && be->chr_read) { | |
175 | be->chr_read(be->opaque, buf, len); | |
ac310734 | 176 | } |
6f97dba0 AL |
177 | } |
178 | ||
0ec7b3e7 | 179 | void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len) |
33577b47 | 180 | { |
5ebd6703 | 181 | if (qemu_chr_replay(s)) { |
33577b47 PD |
182 | if (replay_mode == REPLAY_MODE_PLAY) { |
183 | return; | |
184 | } | |
185 | replay_chr_be_write(s, buf, len); | |
186 | } else { | |
187 | qemu_chr_be_write_impl(s, buf, len); | |
188 | } | |
189 | } | |
190 | ||
07241c20 PX |
191 | void qemu_chr_be_update_read_handlers(Chardev *s, |
192 | GMainContext *context) | |
193 | { | |
194 | ChardevClass *cc = CHARDEV_GET_CLASS(s); | |
195 | ||
95eeeba6 | 196 | s->gcontext = context; |
07241c20 | 197 | if (cc->chr_update_read_handler) { |
bb86d05f | 198 | cc->chr_update_read_handler(s); |
07241c20 PX |
199 | } |
200 | } | |
201 | ||
0ec7b3e7 | 202 | int qemu_chr_add_client(Chardev *s, int fd) |
13661089 | 203 | { |
777357d7 MAL |
204 | return CHARDEV_GET_CLASS(s)->chr_add_client ? |
205 | CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1; | |
13661089 DB |
206 | } |
207 | ||
777357d7 MAL |
208 | static void qemu_char_open(Chardev *chr, ChardevBackend *backend, |
209 | bool *be_opened, Error **errp) | |
6f97dba0 | 210 | { |
777357d7 MAL |
211 | ChardevClass *cc = CHARDEV_GET_CLASS(chr); |
212 | /* Any ChardevCommon member would work */ | |
213 | ChardevCommon *common = backend ? backend->u.null.data : NULL; | |
214 | ||
215 | if (common && common->has_logfile) { | |
216 | int flags = O_WRONLY | O_CREAT; | |
217 | if (common->has_logappend && | |
218 | common->logappend) { | |
219 | flags |= O_APPEND; | |
220 | } else { | |
221 | flags |= O_TRUNC; | |
222 | } | |
223 | chr->logfd = qemu_open(common->logfile, flags, 0666); | |
224 | if (chr->logfd < 0) { | |
225 | error_setg_errno(errp, errno, | |
226 | "Unable to open logfile %s", | |
227 | common->logfile); | |
228 | return; | |
229 | } | |
230 | } | |
231 | ||
232 | if (cc->open) { | |
233 | cc->open(chr, backend, be_opened, errp); | |
234 | } | |
6f97dba0 AL |
235 | } |
236 | ||
777357d7 | 237 | static void char_init(Object *obj) |
6f97dba0 | 238 | { |
777357d7 | 239 | Chardev *chr = CHARDEV(obj); |
6f97dba0 | 240 | |
777357d7 MAL |
241 | chr->logfd = -1; |
242 | qemu_mutex_init(&chr->chr_write_lock); | |
243 | } | |
244 | ||
eb314a94 MAL |
245 | static int null_chr_write(Chardev *chr, const uint8_t *buf, int len) |
246 | { | |
247 | return len; | |
248 | } | |
249 | ||
250 | static void char_class_init(ObjectClass *oc, void *data) | |
251 | { | |
252 | ChardevClass *cc = CHARDEV_CLASS(oc); | |
253 | ||
254 | cc->chr_write = null_chr_write; | |
d09c4a47 | 255 | cc->chr_be_event = chr_be_event; |
eb314a94 MAL |
256 | } |
257 | ||
777357d7 MAL |
258 | static void char_finalize(Object *obj) |
259 | { | |
260 | Chardev *chr = CHARDEV(obj); | |
261 | ||
262 | if (chr->be) { | |
263 | chr->be->chr = NULL; | |
264 | } | |
265 | g_free(chr->filename); | |
266 | g_free(chr->label); | |
267 | if (chr->logfd != -1) { | |
268 | close(chr->logfd); | |
d0d7708b | 269 | } |
777357d7 MAL |
270 | qemu_mutex_destroy(&chr->chr_write_lock); |
271 | } | |
272 | ||
273 | static const TypeInfo char_type_info = { | |
274 | .name = TYPE_CHARDEV, | |
275 | .parent = TYPE_OBJECT, | |
276 | .instance_size = sizeof(Chardev), | |
277 | .instance_init = char_init, | |
278 | .instance_finalize = char_finalize, | |
279 | .abstract = true, | |
280 | .class_size = sizeof(ChardevClass), | |
eb314a94 | 281 | .class_init = char_class_init, |
777357d7 MAL |
282 | }; |
283 | ||
c7278b43 | 284 | static int chardev_machine_done_notify_one(Object *child, void *opaque) |
7b7ab18d | 285 | { |
c7278b43 PX |
286 | Chardev *chr = (Chardev *)child; |
287 | ChardevClass *class = CHARDEV_GET_CLASS(chr); | |
288 | ||
289 | if (class->chr_machine_done) { | |
290 | return class->chr_machine_done(chr); | |
6061162e | 291 | } |
7b7ab18d | 292 | |
6061162e MAL |
293 | return 0; |
294 | } | |
7b7ab18d | 295 | |
c7278b43 | 296 | static void chardev_machine_done_hook(Notifier *notifier, void *unused) |
6061162e | 297 | { |
c7278b43 PX |
298 | int ret = object_child_foreach(get_chardevs_root(), |
299 | chardev_machine_done_notify_one, NULL); | |
300 | ||
301 | if (ret) { | |
302 | error_report("Failed to call chardev machine_done hooks"); | |
303 | exit(1); | |
304 | } | |
7b7ab18d MR |
305 | } |
306 | ||
c7278b43 PX |
307 | static Notifier chardev_machine_done_notify = { |
308 | .notify = chardev_machine_done_hook, | |
7b7ab18d MR |
309 | }; |
310 | ||
0ec7b3e7 | 311 | static bool qemu_chr_is_busy(Chardev *s) |
a4afa548 | 312 | { |
777357d7 MAL |
313 | if (CHARDEV_IS_MUX(s)) { |
314 | MuxChardev *d = MUX_CHARDEV(s); | |
a4afa548 MAL |
315 | return d->mux_cnt >= 0; |
316 | } else { | |
317 | return s->be != NULL; | |
318 | } | |
319 | } | |
320 | ||
d24ca4b8 | 321 | int qemu_chr_wait_connected(Chardev *chr, Error **errp) |
6b6723c3 | 322 | { |
777357d7 MAL |
323 | ChardevClass *cc = CHARDEV_GET_CLASS(chr); |
324 | ||
325 | if (cc->chr_wait_connected) { | |
326 | return cc->chr_wait_connected(chr, errp); | |
6b6723c3 MAL |
327 | } |
328 | ||
329 | return 0; | |
330 | } | |
331 | ||
95e30b2a MAL |
332 | QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename, |
333 | bool permit_mux_mon) | |
191bc01b | 334 | { |
6ea314d9 | 335 | char host[65], port[33], width[8], height[8]; |
aeb2c47a | 336 | int pos; |
7d31544f | 337 | const char *p; |
191bc01b | 338 | QemuOpts *opts; |
8be7e7e4 | 339 | Error *local_err = NULL; |
191bc01b | 340 | |
8be7e7e4 | 341 | opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err); |
84d18f06 | 342 | if (local_err) { |
33394884 | 343 | error_report_err(local_err); |
191bc01b | 344 | return NULL; |
8be7e7e4 | 345 | } |
191bc01b | 346 | |
7591c5c1 | 347 | if (strstart(filename, "mon:", &p)) { |
95e30b2a MAL |
348 | if (!permit_mux_mon) { |
349 | error_report("mon: isn't supported in this context"); | |
350 | return NULL; | |
351 | } | |
7591c5c1 | 352 | filename = p; |
f43e47db | 353 | qemu_opt_set(opts, "mux", "on", &error_abort); |
02c4bdf1 PB |
354 | if (strcmp(filename, "stdio") == 0) { |
355 | /* Monitor is muxed to stdio: do not exit on Ctrl+C by default | |
356 | * but pass it to the guest. Handle this only for compat syntax, | |
357 | * for -chardev syntax we have special option for this. | |
358 | * This is what -nographic did, redirecting+muxing serial+monitor | |
359 | * to stdio causing Ctrl+C to be passed to guest. */ | |
f43e47db | 360 | qemu_opt_set(opts, "signal", "off", &error_abort); |
02c4bdf1 | 361 | } |
7591c5c1 GH |
362 | } |
363 | ||
f0457e8d GH |
364 | if (strcmp(filename, "null") == 0 || |
365 | strcmp(filename, "pty") == 0 || | |
366 | strcmp(filename, "msmouse") == 0 || | |
378af961 | 367 | strcmp(filename, "wctablet") == 0 || |
dc1c21e6 | 368 | strcmp(filename, "braille") == 0 || |
5692399f | 369 | strcmp(filename, "testdev") == 0 || |
f0457e8d | 370 | strcmp(filename, "stdio") == 0) { |
f43e47db | 371 | qemu_opt_set(opts, "backend", filename, &error_abort); |
191bc01b GH |
372 | return opts; |
373 | } | |
6ea314d9 | 374 | if (strstart(filename, "vc", &p)) { |
f43e47db | 375 | qemu_opt_set(opts, "backend", "vc", &error_abort); |
6ea314d9 | 376 | if (*p == ':') { |
49aa4058 | 377 | if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) { |
6ea314d9 | 378 | /* pixels */ |
f43e47db MA |
379 | qemu_opt_set(opts, "width", width, &error_abort); |
380 | qemu_opt_set(opts, "height", height, &error_abort); | |
49aa4058 | 381 | } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) { |
6ea314d9 | 382 | /* chars */ |
f43e47db MA |
383 | qemu_opt_set(opts, "cols", width, &error_abort); |
384 | qemu_opt_set(opts, "rows", height, &error_abort); | |
6ea314d9 GH |
385 | } else { |
386 | goto fail; | |
387 | } | |
388 | } | |
389 | return opts; | |
390 | } | |
d6c983cd | 391 | if (strcmp(filename, "con:") == 0) { |
f43e47db | 392 | qemu_opt_set(opts, "backend", "console", &error_abort); |
d6c983cd GH |
393 | return opts; |
394 | } | |
48b76496 | 395 | if (strstart(filename, "COM", NULL)) { |
f43e47db MA |
396 | qemu_opt_set(opts, "backend", "serial", &error_abort); |
397 | qemu_opt_set(opts, "path", filename, &error_abort); | |
48b76496 GH |
398 | return opts; |
399 | } | |
7d31544f | 400 | if (strstart(filename, "file:", &p)) { |
f43e47db MA |
401 | qemu_opt_set(opts, "backend", "file", &error_abort); |
402 | qemu_opt_set(opts, "path", p, &error_abort); | |
7d31544f GH |
403 | return opts; |
404 | } | |
405 | if (strstart(filename, "pipe:", &p)) { | |
f43e47db MA |
406 | qemu_opt_set(opts, "backend", "pipe", &error_abort); |
407 | qemu_opt_set(opts, "path", p, &error_abort); | |
7d31544f GH |
408 | return opts; |
409 | } | |
aeb2c47a | 410 | if (strstart(filename, "tcp:", &p) || |
ae92cbd5 JL |
411 | strstart(filename, "telnet:", &p) || |
412 | strstart(filename, "tn3270:", &p)) { | |
aeb2c47a GH |
413 | if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { |
414 | host[0] = 0; | |
415 | if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) | |
416 | goto fail; | |
417 | } | |
f43e47db MA |
418 | qemu_opt_set(opts, "backend", "socket", &error_abort); |
419 | qemu_opt_set(opts, "host", host, &error_abort); | |
420 | qemu_opt_set(opts, "port", port, &error_abort); | |
aeb2c47a | 421 | if (p[pos] == ',') { |
dc523cd3 MA |
422 | qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err); |
423 | if (local_err) { | |
424 | error_report_err(local_err); | |
aeb2c47a | 425 | goto fail; |
dc523cd3 | 426 | } |
aeb2c47a | 427 | } |
ae92cbd5 | 428 | if (strstart(filename, "telnet:", &p)) { |
f43e47db | 429 | qemu_opt_set(opts, "telnet", "on", &error_abort); |
ae92cbd5 JL |
430 | } else if (strstart(filename, "tn3270:", &p)) { |
431 | qemu_opt_set(opts, "tn3270", "on", &error_abort); | |
432 | } | |
aeb2c47a GH |
433 | return opts; |
434 | } | |
7e1b35b4 | 435 | if (strstart(filename, "udp:", &p)) { |
f43e47db | 436 | qemu_opt_set(opts, "backend", "udp", &error_abort); |
7e1b35b4 GH |
437 | if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) { |
438 | host[0] = 0; | |
39324ca4 | 439 | if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) { |
7e1b35b4 GH |
440 | goto fail; |
441 | } | |
442 | } | |
f43e47db MA |
443 | qemu_opt_set(opts, "host", host, &error_abort); |
444 | qemu_opt_set(opts, "port", port, &error_abort); | |
7e1b35b4 GH |
445 | if (p[pos] == '@') { |
446 | p += pos + 1; | |
447 | if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { | |
448 | host[0] = 0; | |
449 | if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) { | |
7e1b35b4 GH |
450 | goto fail; |
451 | } | |
452 | } | |
f43e47db MA |
453 | qemu_opt_set(opts, "localaddr", host, &error_abort); |
454 | qemu_opt_set(opts, "localport", port, &error_abort); | |
7e1b35b4 GH |
455 | } |
456 | return opts; | |
457 | } | |
aeb2c47a | 458 | if (strstart(filename, "unix:", &p)) { |
f43e47db | 459 | qemu_opt_set(opts, "backend", "socket", &error_abort); |
dc523cd3 MA |
460 | qemu_opts_do_parse(opts, p, "path", &local_err); |
461 | if (local_err) { | |
462 | error_report_err(local_err); | |
aeb2c47a | 463 | goto fail; |
dc523cd3 | 464 | } |
aeb2c47a GH |
465 | return opts; |
466 | } | |
48b76496 GH |
467 | if (strstart(filename, "/dev/parport", NULL) || |
468 | strstart(filename, "/dev/ppi", NULL)) { | |
73119c28 | 469 | qemu_opt_set(opts, "backend", "parallel", &error_abort); |
f43e47db | 470 | qemu_opt_set(opts, "path", filename, &error_abort); |
48b76496 GH |
471 | return opts; |
472 | } | |
473 | if (strstart(filename, "/dev/", NULL)) { | |
73119c28 | 474 | qemu_opt_set(opts, "backend", "serial", &error_abort); |
f43e47db | 475 | qemu_opt_set(opts, "path", filename, &error_abort); |
48b76496 GH |
476 | return opts; |
477 | } | |
191bc01b | 478 | |
aeb2c47a | 479 | fail: |
191bc01b GH |
480 | qemu_opts_del(opts); |
481 | return NULL; | |
482 | } | |
483 | ||
21a933ea | 484 | void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend) |
d0d7708b DB |
485 | { |
486 | const char *logfile = qemu_opt_get(opts, "logfile"); | |
487 | ||
488 | backend->has_logfile = logfile != NULL; | |
e1f98fe4 | 489 | backend->logfile = g_strdup(logfile); |
d0d7708b DB |
490 | |
491 | backend->has_logappend = true; | |
492 | backend->logappend = qemu_opt_get_bool(opts, "logappend", false); | |
493 | } | |
494 | ||
88cace9f MAL |
495 | static const ChardevClass *char_get_class(const char *driver, Error **errp) |
496 | { | |
497 | ObjectClass *oc; | |
498 | const ChardevClass *cc; | |
499 | char *typename = g_strdup_printf("chardev-%s", driver); | |
500 | ||
501 | oc = object_class_by_name(typename); | |
502 | g_free(typename); | |
503 | ||
504 | if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) { | |
505 | error_setg(errp, "'%s' is not a valid char driver name", driver); | |
506 | return NULL; | |
507 | } | |
d654f34e | 508 | |
88cace9f MAL |
509 | if (object_class_is_abstract(oc)) { |
510 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver", | |
511 | "abstract device type"); | |
512 | return NULL; | |
513 | } | |
514 | ||
515 | cc = CHARDEV_CLASS(oc); | |
516 | if (cc->internal) { | |
517 | error_setg(errp, "'%s' is not a valid char driver name", driver); | |
518 | return NULL; | |
519 | } | |
520 | ||
521 | return cc; | |
522 | } | |
523 | ||
524 | static const struct ChardevAlias { | |
525 | const char *typename; | |
526 | const char *alias; | |
527 | } chardev_alias_table[] = { | |
528 | #ifdef HAVE_CHARDEV_PARPORT | |
529 | { "parallel", "parport" }, | |
530 | #endif | |
531 | #ifdef HAVE_CHARDEV_SERIAL | |
532 | { "serial", "tty" }, | |
533 | #endif | |
534 | }; | |
535 | ||
536 | typedef struct ChadevClassFE { | |
537 | void (*fn)(const char *name, void *opaque); | |
538 | void *opaque; | |
539 | } ChadevClassFE; | |
540 | ||
541 | static void | |
542 | chardev_class_foreach(ObjectClass *klass, void *opaque) | |
2c5f4882 | 543 | { |
88cace9f MAL |
544 | ChadevClassFE *fe = opaque; |
545 | ||
546 | assert(g_str_has_prefix(object_class_get_name(klass), "chardev-")); | |
547 | if (CHARDEV_CLASS(klass)->internal) { | |
548 | return; | |
549 | } | |
550 | ||
551 | fe->fn(object_class_get_name(klass) + 8, fe->opaque); | |
552 | } | |
553 | ||
554 | static void | |
555 | chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque) | |
556 | { | |
557 | ChadevClassFE fe = { .fn = fn, .opaque = opaque }; | |
558 | int i; | |
559 | ||
560 | object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe); | |
561 | ||
c7e47c63 | 562 | for (i = 0; i < (int)ARRAY_SIZE(chardev_alias_table); i++) { |
88cace9f MAL |
563 | fn(chardev_alias_table[i].alias, opaque); |
564 | } | |
565 | } | |
566 | ||
567 | static void | |
568 | help_string_append(const char *name, void *opaque) | |
569 | { | |
570 | GString *str = opaque; | |
571 | ||
572 | g_string_append_printf(str, "\n%s", name); | |
2c5f4882 GH |
573 | } |
574 | ||
313e45b5 AN |
575 | static const char *chardev_alias_translate(const char *name) |
576 | { | |
577 | int i; | |
578 | for (i = 0; i < (int)ARRAY_SIZE(chardev_alias_table); i++) { | |
579 | if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) { | |
580 | return chardev_alias_table[i].typename; | |
581 | } | |
582 | } | |
583 | return name; | |
584 | } | |
585 | ||
75b60160 | 586 | ChardevBackend *qemu_chr_parse_opts(QemuOpts *opts, Error **errp) |
191bc01b | 587 | { |
0aff637e | 588 | Error *local_err = NULL; |
88cace9f | 589 | const ChardevClass *cc; |
0b663b7d | 590 | ChardevBackend *backend = NULL; |
313e45b5 | 591 | const char *name = chardev_alias_translate(qemu_opt_get(opts, "backend")); |
191bc01b | 592 | |
0b812f31 | 593 | if (name == NULL) { |
312fd5f2 | 594 | error_setg(errp, "chardev: \"%s\" missing backend", |
bd2d80b2 | 595 | qemu_opts_id(opts)); |
0b663b7d | 596 | return NULL; |
1bbd185f | 597 | } |
517b3d40 | 598 | |
313e45b5 AN |
599 | cc = char_get_class(name, errp); |
600 | if (cc == NULL) { | |
601 | return NULL; | |
602 | } | |
603 | ||
604 | backend = g_new0(ChardevBackend, 1); | |
605 | backend->type = CHARDEV_BACKEND_KIND_NULL; | |
606 | ||
607 | if (cc->parse) { | |
608 | cc->parse(opts, backend, &local_err); | |
609 | if (local_err) { | |
610 | error_propagate(errp, local_err); | |
611 | qapi_free_ChardevBackend(backend); | |
612 | return NULL; | |
613 | } | |
614 | } else { | |
615 | ChardevCommon *ccom = g_new0(ChardevCommon, 1); | |
616 | qemu_chr_parse_common(opts, ccom); | |
617 | backend->u.null.data = ccom; /* Any ChardevCommon member would work */ | |
618 | } | |
619 | ||
620 | return backend; | |
621 | } | |
622 | ||
623 | Chardev *qemu_chr_new_from_opts(QemuOpts *opts, Error **errp) | |
624 | { | |
625 | const ChardevClass *cc; | |
626 | Chardev *chr = NULL; | |
627 | ChardevBackend *backend = NULL; | |
628 | const char *name = chardev_alias_translate(qemu_opt_get(opts, "backend")); | |
629 | const char *id = qemu_opts_id(opts); | |
630 | char *bid = NULL; | |
631 | ||
632 | if (name && is_help_option(name)) { | |
776a32a0 | 633 | GString *str = g_string_new(""); |
88cace9f MAL |
634 | |
635 | chardev_name_foreach(help_string_append, str); | |
776a32a0 | 636 | |
b1b769b0 | 637 | error_printf("Available chardev backend types: %s\n", str->str); |
776a32a0 | 638 | g_string_free(str, true); |
0ec846bf | 639 | return NULL; |
517b3d40 LM |
640 | } |
641 | ||
642 | if (id == NULL) { | |
643 | error_setg(errp, "chardev: no id specified"); | |
0b663b7d | 644 | return NULL; |
517b3d40 LM |
645 | } |
646 | ||
313e45b5 AN |
647 | backend = qemu_chr_parse_opts(opts, errp); |
648 | if (backend == NULL) { | |
649 | return NULL; | |
191bc01b | 650 | } |
88cace9f MAL |
651 | |
652 | cc = char_get_class(name, errp); | |
653 | if (cc == NULL) { | |
313e45b5 | 654 | goto out; |
191bc01b GH |
655 | } |
656 | ||
a61ae7f8 PM |
657 | if (qemu_opt_get_bool(opts, "mux", 0)) { |
658 | bid = g_strdup_printf("%s-base", id); | |
659 | } | |
2c5f4882 | 660 | |
c5749f7c | 661 | chr = qemu_chardev_new(bid ? bid : id, |
0b663b7d MAL |
662 | object_class_get_name(OBJECT_CLASS(cc)), |
663 | backend, errp); | |
c5749f7c | 664 | |
0b663b7d MAL |
665 | if (chr == NULL) { |
666 | goto out; | |
191bc01b GH |
667 | } |
668 | ||
a61ae7f8 | 669 | if (bid) { |
0b663b7d | 670 | Chardev *mux; |
a61ae7f8 | 671 | qapi_free_ChardevBackend(backend); |
a61ae7f8 | 672 | backend = g_new0(ChardevBackend, 1); |
130257dc | 673 | backend->type = CHARDEV_BACKEND_KIND_MUX; |
0b663b7d | 674 | backend->u.mux.data = g_new0(ChardevMux, 1); |
32bafa8f | 675 | backend->u.mux.data->chardev = g_strdup(bid); |
c5749f7c | 676 | mux = qemu_chardev_new(id, TYPE_CHARDEV_MUX, backend, errp); |
0b663b7d | 677 | if (mux == NULL) { |
2f5d45a1 | 678 | object_unparent(OBJECT(chr)); |
a61ae7f8 | 679 | chr = NULL; |
0b663b7d | 680 | goto out; |
a61ae7f8 | 681 | } |
0b663b7d | 682 | chr = mux; |
bd5c51ee | 683 | } |
7591c5c1 | 684 | |
0b663b7d | 685 | out: |
a61ae7f8 | 686 | qapi_free_ChardevBackend(backend); |
a61ae7f8 | 687 | g_free(bid); |
191bc01b GH |
688 | return chr; |
689 | } | |
690 | ||
95e30b2a MAL |
691 | Chardev *qemu_chr_new_noreplay(const char *label, const char *filename, |
692 | bool permit_mux_mon) | |
6f97dba0 AL |
693 | { |
694 | const char *p; | |
0ec7b3e7 | 695 | Chardev *chr; |
191bc01b | 696 | QemuOpts *opts; |
bd2d80b2 | 697 | Error *err = NULL; |
191bc01b | 698 | |
c845f401 GH |
699 | if (strstart(filename, "chardev:", &p)) { |
700 | return qemu_chr_find(p); | |
701 | } | |
702 | ||
95e30b2a | 703 | opts = qemu_chr_parse_compat(label, filename, permit_mux_mon); |
7e1b35b4 GH |
704 | if (!opts) |
705 | return NULL; | |
6f97dba0 | 706 | |
b4948be9 | 707 | chr = qemu_chr_new_from_opts(opts, &err); |
95e30b2a | 708 | if (!chr) { |
565f65d2 | 709 | error_report_err(err); |
95e30b2a | 710 | goto out; |
bd2d80b2 | 711 | } |
95e30b2a MAL |
712 | |
713 | if (qemu_opt_get_bool(opts, "mux", 0)) { | |
714 | assert(permit_mux_mon); | |
7e1b35b4 | 715 | monitor_init(chr, MONITOR_USE_READLINE); |
6f97dba0 | 716 | } |
95e30b2a MAL |
717 | |
718 | out: | |
0a73336d | 719 | qemu_opts_del(opts); |
6f97dba0 AL |
720 | return chr; |
721 | } | |
722 | ||
95e30b2a MAL |
723 | static Chardev *qemu_chr_new_permit_mux_mon(const char *label, |
724 | const char *filename, | |
725 | bool permit_mux_mon) | |
33577b47 | 726 | { |
0ec7b3e7 | 727 | Chardev *chr; |
95e30b2a | 728 | chr = qemu_chr_new_noreplay(label, filename, permit_mux_mon); |
33577b47 | 729 | if (chr) { |
5ebd6703 MAL |
730 | if (replay_mode != REPLAY_MODE_NONE) { |
731 | qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY); | |
732 | } | |
777357d7 | 733 | if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) { |
776a32a0 MAL |
734 | error_report("Replay: ioctl is not supported " |
735 | "for serial devices yet"); | |
33577b47 PD |
736 | } |
737 | replay_register_char_driver(chr); | |
738 | } | |
739 | return chr; | |
740 | } | |
741 | ||
95e30b2a MAL |
742 | Chardev *qemu_chr_new(const char *label, const char *filename) |
743 | { | |
744 | return qemu_chr_new_permit_mux_mon(label, filename, false); | |
745 | } | |
746 | ||
747 | Chardev *qemu_chr_new_mux_mon(const char *label, const char *filename) | |
748 | { | |
749 | return qemu_chr_new_permit_mux_mon(label, filename, true); | |
750 | } | |
751 | ||
6061162e | 752 | static int qmp_query_chardev_foreach(Object *obj, void *data) |
1ad78ea5 | 753 | { |
6061162e MAL |
754 | Chardev *chr = CHARDEV(obj); |
755 | ChardevInfoList **list = data; | |
756 | ChardevInfoList *info = g_malloc0(sizeof(*info)); | |
757 | ||
758 | info->value = g_malloc0(sizeof(*info->value)); | |
759 | info->value->label = g_strdup(chr->label); | |
760 | info->value->filename = g_strdup(chr->filename); | |
761 | info->value->frontend_open = chr->be && chr->be->fe_open; | |
762 | ||
763 | info->next = *list; | |
764 | *list = info; | |
765 | ||
766 | return 0; | |
1ad78ea5 MAL |
767 | } |
768 | ||
c5a415a0 | 769 | ChardevInfoList *qmp_query_chardev(Error **errp) |
6f97dba0 | 770 | { |
c5a415a0 | 771 | ChardevInfoList *chr_list = NULL; |
6f97dba0 | 772 | |
6061162e MAL |
773 | object_child_foreach(get_chardevs_root(), |
774 | qmp_query_chardev_foreach, &chr_list); | |
588b3832 | 775 | |
c5a415a0 | 776 | return chr_list; |
6f97dba0 | 777 | } |
c845f401 | 778 | |
88cace9f MAL |
779 | static void |
780 | qmp_prepend_backend(const char *name, void *opaque) | |
0b812f31 | 781 | { |
88cace9f | 782 | ChardevBackendInfoList **list = opaque; |
0b812f31 | 783 | ChardevBackendInfoList *info = g_malloc0(sizeof(*info)); |
88cace9f | 784 | |
0b812f31 MAL |
785 | info->value = g_malloc0(sizeof(*info->value)); |
786 | info->value->name = g_strdup(name); | |
88cace9f MAL |
787 | info->next = *list; |
788 | *list = info; | |
0b812f31 MAL |
789 | } |
790 | ||
77d1c3c6 MK |
791 | ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp) |
792 | { | |
793 | ChardevBackendInfoList *backend_list = NULL; | |
a1698bf1 | 794 | |
88cace9f | 795 | chardev_name_foreach(qmp_prepend_backend, &backend_list); |
77d1c3c6 MK |
796 | |
797 | return backend_list; | |
798 | } | |
799 | ||
0ec7b3e7 | 800 | Chardev *qemu_chr_find(const char *name) |
c845f401 | 801 | { |
6061162e | 802 | Object *obj = object_resolve_path_component(get_chardevs_root(), name); |
c845f401 | 803 | |
6061162e | 804 | return obj ? CHARDEV(obj) : NULL; |
c845f401 | 805 | } |
0beb4942 | 806 | |
4d454574 PB |
807 | QemuOptsList qemu_chardev_opts = { |
808 | .name = "chardev", | |
809 | .implied_opt_name = "backend", | |
810 | .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), | |
811 | .desc = { | |
812 | { | |
813 | .name = "backend", | |
814 | .type = QEMU_OPT_STRING, | |
815 | },{ | |
816 | .name = "path", | |
817 | .type = QEMU_OPT_STRING, | |
818 | },{ | |
819 | .name = "host", | |
820 | .type = QEMU_OPT_STRING, | |
821 | },{ | |
822 | .name = "port", | |
823 | .type = QEMU_OPT_STRING, | |
0935700f DB |
824 | },{ |
825 | .name = "fd", | |
826 | .type = QEMU_OPT_STRING, | |
4d454574 PB |
827 | },{ |
828 | .name = "localaddr", | |
829 | .type = QEMU_OPT_STRING, | |
830 | },{ | |
831 | .name = "localport", | |
832 | .type = QEMU_OPT_STRING, | |
833 | },{ | |
834 | .name = "to", | |
835 | .type = QEMU_OPT_NUMBER, | |
836 | },{ | |
837 | .name = "ipv4", | |
838 | .type = QEMU_OPT_BOOL, | |
839 | },{ | |
840 | .name = "ipv6", | |
841 | .type = QEMU_OPT_BOOL, | |
842 | },{ | |
843 | .name = "wait", | |
844 | .type = QEMU_OPT_BOOL, | |
845 | },{ | |
846 | .name = "server", | |
847 | .type = QEMU_OPT_BOOL, | |
848 | },{ | |
849 | .name = "delay", | |
850 | .type = QEMU_OPT_BOOL, | |
5dd1f02b CM |
851 | },{ |
852 | .name = "reconnect", | |
853 | .type = QEMU_OPT_NUMBER, | |
4d454574 PB |
854 | },{ |
855 | .name = "telnet", | |
856 | .type = QEMU_OPT_BOOL, | |
ae92cbd5 JL |
857 | },{ |
858 | .name = "tn3270", | |
859 | .type = QEMU_OPT_BOOL, | |
a8fb5427 DB |
860 | },{ |
861 | .name = "tls-creds", | |
862 | .type = QEMU_OPT_STRING, | |
4d454574 PB |
863 | },{ |
864 | .name = "width", | |
865 | .type = QEMU_OPT_NUMBER, | |
866 | },{ | |
867 | .name = "height", | |
868 | .type = QEMU_OPT_NUMBER, | |
869 | },{ | |
870 | .name = "cols", | |
871 | .type = QEMU_OPT_NUMBER, | |
872 | },{ | |
873 | .name = "rows", | |
874 | .type = QEMU_OPT_NUMBER, | |
875 | },{ | |
876 | .name = "mux", | |
877 | .type = QEMU_OPT_BOOL, | |
878 | },{ | |
879 | .name = "signal", | |
880 | .type = QEMU_OPT_BOOL, | |
881 | },{ | |
882 | .name = "name", | |
883 | .type = QEMU_OPT_STRING, | |
884 | },{ | |
885 | .name = "debug", | |
886 | .type = QEMU_OPT_NUMBER, | |
51767e7c | 887 | },{ |
3949e594 | 888 | .name = "size", |
de1cc36e | 889 | .type = QEMU_OPT_SIZE, |
bb6fb7c0 GH |
890 | },{ |
891 | .name = "chardev", | |
892 | .type = QEMU_OPT_STRING, | |
31e38a22 OK |
893 | },{ |
894 | .name = "append", | |
895 | .type = QEMU_OPT_BOOL, | |
d0d7708b DB |
896 | },{ |
897 | .name = "logfile", | |
898 | .type = QEMU_OPT_STRING, | |
899 | },{ | |
900 | .name = "logappend", | |
901 | .type = QEMU_OPT_BOOL, | |
4d454574 PB |
902 | }, |
903 | { /* end of list */ } | |
904 | }, | |
905 | }; | |
f1a1a356 | 906 | |
0ec7b3e7 | 907 | bool qemu_chr_has_feature(Chardev *chr, |
279b066e | 908 | ChardevFeature feature) |
0a73336d DB |
909 | { |
910 | return test_bit(feature, chr->features); | |
911 | } | |
912 | ||
0ec7b3e7 | 913 | void qemu_chr_set_feature(Chardev *chr, |
279b066e | 914 | ChardevFeature feature) |
0a73336d DB |
915 | { |
916 | return set_bit(feature, chr->features); | |
917 | } | |
918 | ||
777357d7 | 919 | Chardev *qemu_chardev_new(const char *id, const char *typename, |
2f5d45a1 MAL |
920 | ChardevBackend *backend, |
921 | Error **errp) | |
f1a1a356 | 922 | { |
2f5d45a1 | 923 | Object *obj; |
0ec7b3e7 | 924 | Chardev *chr = NULL; |
eaeba653 | 925 | Error *local_err = NULL; |
82878dac | 926 | bool be_opened = true; |
f1a1a356 | 927 | |
777357d7 | 928 | assert(g_str_has_prefix(typename, "chardev-")); |
f1a1a356 | 929 | |
2f5d45a1 MAL |
930 | obj = object_new(typename); |
931 | chr = CHARDEV(obj); | |
777357d7 | 932 | chr->label = g_strdup(id); |
4ca17281 | 933 | |
777357d7 | 934 | qemu_char_open(chr, backend, &be_opened, &local_err); |
a1698bf1 | 935 | if (local_err) { |
2f5d45a1 | 936 | goto end; |
eaeba653 PB |
937 | } |
938 | ||
eaeba653 | 939 | if (!chr->filename) { |
777357d7 | 940 | chr->filename = g_strdup(typename + 8); |
f1a1a356 | 941 | } |
82878dac | 942 | if (be_opened) { |
eaeba653 PB |
943 | qemu_chr_be_event(chr, CHR_EVENT_OPENED); |
944 | } | |
777357d7 | 945 | |
2f5d45a1 MAL |
946 | if (id) { |
947 | object_property_add_child(get_chardevs_root(), id, obj, &local_err); | |
948 | if (local_err) { | |
949 | goto end; | |
950 | } | |
951 | object_unref(obj); | |
952 | } | |
953 | ||
954 | end: | |
955 | if (local_err) { | |
956 | error_propagate(errp, local_err); | |
957 | object_unref(obj); | |
958 | return NULL; | |
959 | } | |
960 | ||
777357d7 MAL |
961 | return chr; |
962 | } | |
963 | ||
964 | ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, | |
965 | Error **errp) | |
966 | { | |
967 | const ChardevClass *cc; | |
968 | ChardevReturn *ret; | |
969 | Chardev *chr; | |
970 | ||
977c736f | 971 | cc = char_get_class(ChardevBackendKind_str(backend->type), errp); |
777357d7 MAL |
972 | if (!cc) { |
973 | return NULL; | |
974 | } | |
975 | ||
c5749f7c | 976 | chr = qemu_chardev_new(id, object_class_get_name(OBJECT_CLASS(cc)), |
777357d7 MAL |
977 | backend, errp); |
978 | if (!chr) { | |
979 | return NULL; | |
980 | } | |
981 | ||
982 | ret = g_new0(ChardevReturn, 1); | |
983 | if (CHARDEV_IS_PTY(chr)) { | |
984 | ret->pty = g_strdup(chr->filename + 4); | |
985 | ret->has_pty = true; | |
986 | } | |
987 | ||
eaeba653 | 988 | return ret; |
f1a1a356 GH |
989 | } |
990 | ||
7bb86085 AN |
991 | ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend, |
992 | Error **errp) | |
993 | { | |
994 | CharBackend *be; | |
995 | const ChardevClass *cc; | |
996 | Chardev *chr, *chr_new; | |
997 | bool closed_sent = false; | |
998 | ChardevReturn *ret; | |
999 | ||
1000 | chr = qemu_chr_find(id); | |
1001 | if (!chr) { | |
1002 | error_setg(errp, "Chardev '%s' does not exist", id); | |
1003 | return NULL; | |
1004 | } | |
1005 | ||
1006 | if (CHARDEV_IS_MUX(chr)) { | |
1007 | error_setg(errp, "Mux device hotswap not supported yet"); | |
1008 | return NULL; | |
1009 | } | |
1010 | ||
1011 | if (qemu_chr_replay(chr)) { | |
1012 | error_setg(errp, | |
1013 | "Chardev '%s' cannot be changed in record/replay mode", id); | |
1014 | return NULL; | |
1015 | } | |
1016 | ||
1017 | be = chr->be; | |
1018 | if (!be) { | |
1019 | /* easy case */ | |
1020 | object_unparent(OBJECT(chr)); | |
1021 | return qmp_chardev_add(id, backend, errp); | |
1022 | } | |
1023 | ||
1024 | if (!be->chr_be_change) { | |
1025 | error_setg(errp, "Chardev user does not support chardev hotswap"); | |
1026 | return NULL; | |
1027 | } | |
1028 | ||
977c736f | 1029 | cc = char_get_class(ChardevBackendKind_str(backend->type), errp); |
7bb86085 AN |
1030 | if (!cc) { |
1031 | return NULL; | |
1032 | } | |
1033 | ||
1034 | chr_new = qemu_chardev_new(NULL, object_class_get_name(OBJECT_CLASS(cc)), | |
1035 | backend, errp); | |
1036 | if (!chr_new) { | |
1037 | return NULL; | |
1038 | } | |
1039 | chr_new->label = g_strdup(id); | |
1040 | ||
1041 | if (chr->be_open && !chr_new->be_open) { | |
1042 | qemu_chr_be_event(chr, CHR_EVENT_CLOSED); | |
1043 | closed_sent = true; | |
1044 | } | |
1045 | ||
1046 | chr->be = NULL; | |
1047 | qemu_chr_fe_init(be, chr_new, &error_abort); | |
1048 | ||
1049 | if (be->chr_be_change(be->opaque) < 0) { | |
1050 | error_setg(errp, "Chardev '%s' change failed", chr_new->label); | |
1051 | chr_new->be = NULL; | |
1052 | qemu_chr_fe_init(be, chr, &error_abort); | |
1053 | if (closed_sent) { | |
1054 | qemu_chr_be_event(chr, CHR_EVENT_OPENED); | |
1055 | } | |
1056 | object_unref(OBJECT(chr_new)); | |
1057 | return NULL; | |
1058 | } | |
1059 | ||
1060 | object_unparent(OBJECT(chr)); | |
1061 | object_property_add_child(get_chardevs_root(), chr_new->label, | |
1062 | OBJECT(chr_new), &error_abort); | |
1063 | object_unref(OBJECT(chr_new)); | |
1064 | ||
1065 | ret = g_new0(ChardevReturn, 1); | |
1066 | if (CHARDEV_IS_PTY(chr_new)) { | |
1067 | ret->pty = g_strdup(chr_new->filename + 4); | |
1068 | ret->has_pty = true; | |
1069 | } | |
1070 | ||
1071 | return ret; | |
1072 | } | |
1073 | ||
f1a1a356 GH |
1074 | void qmp_chardev_remove(const char *id, Error **errp) |
1075 | { | |
0ec7b3e7 | 1076 | Chardev *chr; |
f1a1a356 GH |
1077 | |
1078 | chr = qemu_chr_find(id); | |
8108fd3e | 1079 | if (chr == NULL) { |
f1a1a356 GH |
1080 | error_setg(errp, "Chardev '%s' not found", id); |
1081 | return; | |
1082 | } | |
a4afa548 | 1083 | if (qemu_chr_is_busy(chr)) { |
f1a1a356 GH |
1084 | error_setg(errp, "Chardev '%s' is busy", id); |
1085 | return; | |
1086 | } | |
5ebd6703 | 1087 | if (qemu_chr_replay(chr)) { |
33577b47 PD |
1088 | error_setg(errp, |
1089 | "Chardev '%s' cannot be unplugged in record/replay mode", id); | |
1090 | return; | |
1091 | } | |
2f5d45a1 | 1092 | object_unparent(OBJECT(chr)); |
f1a1a356 | 1093 | } |
d654f34e | 1094 | |
bd1d5ad9 SF |
1095 | void qmp_chardev_send_break(const char *id, Error **errp) |
1096 | { | |
1097 | Chardev *chr; | |
1098 | ||
1099 | chr = qemu_chr_find(id); | |
1100 | if (chr == NULL) { | |
1101 | error_setg(errp, "Chardev '%s' not found", id); | |
1102 | return; | |
1103 | } | |
1104 | qemu_chr_be_event(chr, CHR_EVENT_BREAK); | |
1105 | } | |
1106 | ||
2c716ba1 PX |
1107 | /* |
1108 | * Add a timeout callback for the chardev (in milliseconds), return | |
1109 | * the GSource object created. Please use this to add timeout hook for | |
1110 | * chardev instead of g_timeout_add() and g_timeout_add_seconds(), to | |
1111 | * make sure the gcontext that the task bound to is correct. | |
1112 | */ | |
1113 | GSource *qemu_chr_timeout_add_ms(Chardev *chr, guint ms, | |
1114 | GSourceFunc func, void *private) | |
1115 | { | |
1116 | GSource *source = g_timeout_source_new(ms); | |
1117 | ||
1118 | assert(func); | |
1119 | g_source_set_callback(source, func, private, NULL); | |
1120 | g_source_attach(source, chr->gcontext); | |
1121 | ||
1122 | return source; | |
1123 | } | |
1124 | ||
aa5cb7f5 | 1125 | void qemu_chr_cleanup(void) |
c1111a24 | 1126 | { |
2f5d45a1 | 1127 | object_unparent(get_chardevs_root()); |
c1111a24 MAL |
1128 | } |
1129 | ||
d654f34e AL |
1130 | static void register_types(void) |
1131 | { | |
88cace9f | 1132 | type_register_static(&char_type_info); |
0b812f31 | 1133 | |
7b7ab18d MR |
1134 | /* this must be done after machine init, since we register FEs with muxes |
1135 | * as part of realize functions like serial_isa_realizefn when -nographic | |
1136 | * is specified | |
1137 | */ | |
c7278b43 | 1138 | qemu_add_machine_init_done_notifier(&chardev_machine_done_notify); |
d654f34e AL |
1139 | } |
1140 | ||
1141 | type_init(register_types); |