]>
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 | */ | |
d38ea87a | 24 | #include "qemu/osdep.h" |
6f97dba0 | 25 | #include "qemu-common.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" |
dccfcd0e | 31 | #include "sysemu/char.h" |
c5a415a0 | 32 | #include "qmp-commands.h" |
cfb429cb | 33 | #include "qapi-visit.h" |
33577b47 | 34 | #include "sysemu/replay.h" |
517b3d40 | 35 | #include "qemu/help_option.h" |
6f97dba0 | 36 | |
df85a78b | 37 | #include "char-mux.h" |
a6da7ffa | 38 | #include "char-io.h" |
6aa0f0c9 | 39 | #include "char-parallel.h" |
2b2f23da | 40 | #include "char-serial.h" |
df85a78b | 41 | |
6f97dba0 AL |
42 | /***********************************************************/ |
43 | /* character device */ | |
44 | ||
2f5d45a1 MAL |
45 | static Object *get_chardevs_root(void) |
46 | { | |
47 | return container_get(object_get_root(), "/chardevs"); | |
48 | } | |
2970a6c9 | 49 | |
0ec7b3e7 | 50 | void qemu_chr_be_event(Chardev *s, int event) |
6f97dba0 | 51 | { |
a4afa548 MAL |
52 | CharBackend *be = s->be; |
53 | ||
73cdf3f2 AG |
54 | /* Keep track if the char device is open */ |
55 | switch (event) { | |
56 | case CHR_EVENT_OPENED: | |
16665b94 | 57 | s->be_open = 1; |
73cdf3f2 AG |
58 | break; |
59 | case CHR_EVENT_CLOSED: | |
16665b94 | 60 | s->be_open = 0; |
73cdf3f2 AG |
61 | break; |
62 | } | |
63 | ||
a4afa548 | 64 | if (!be || !be->chr_event) { |
6f97dba0 | 65 | return; |
a4afa548 MAL |
66 | } |
67 | ||
68 | be->chr_event(be->opaque, event); | |
6f97dba0 AL |
69 | } |
70 | ||
d0d7708b DB |
71 | /* Not reporting errors from writing to logfile, as logs are |
72 | * defined to be "best effort" only */ | |
0ec7b3e7 | 73 | static void qemu_chr_fe_write_log(Chardev *s, |
d0d7708b DB |
74 | const uint8_t *buf, size_t len) |
75 | { | |
76 | size_t done = 0; | |
77 | ssize_t ret; | |
78 | ||
79 | if (s->logfd < 0) { | |
80 | return; | |
81 | } | |
82 | ||
83 | while (done < len) { | |
53628efb DB |
84 | retry: |
85 | ret = write(s->logfd, buf + done, len - done); | |
86 | if (ret == -1 && errno == EAGAIN) { | |
87 | g_usleep(100); | |
88 | goto retry; | |
89 | } | |
d0d7708b DB |
90 | |
91 | if (ret <= 0) { | |
92 | return; | |
93 | } | |
94 | done += ret; | |
95 | } | |
96 | } | |
97 | ||
0ec7b3e7 MAL |
98 | static int qemu_chr_fe_write_buffer(Chardev *s, |
99 | const uint8_t *buf, int len, int *offset) | |
33577b47 | 100 | { |
777357d7 | 101 | ChardevClass *cc = CHARDEV_GET_CLASS(s); |
33577b47 PD |
102 | int res = 0; |
103 | *offset = 0; | |
104 | ||
105 | qemu_mutex_lock(&s->chr_write_lock); | |
106 | while (*offset < len) { | |
53628efb | 107 | retry: |
777357d7 | 108 | res = cc->chr_write(s, buf + *offset, len - *offset); |
53628efb DB |
109 | if (res < 0 && errno == EAGAIN) { |
110 | g_usleep(100); | |
111 | goto retry; | |
112 | } | |
33577b47 PD |
113 | |
114 | if (res <= 0) { | |
115 | break; | |
116 | } | |
117 | ||
118 | *offset += res; | |
119 | } | |
120 | if (*offset > 0) { | |
121 | qemu_chr_fe_write_log(s, buf, *offset); | |
122 | } | |
123 | qemu_mutex_unlock(&s->chr_write_lock); | |
124 | ||
125 | return res; | |
126 | } | |
127 | ||
0ec7b3e7 | 128 | static bool qemu_chr_replay(Chardev *chr) |
5ebd6703 MAL |
129 | { |
130 | return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY); | |
131 | } | |
132 | ||
5345fdb4 | 133 | int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len) |
6f97dba0 | 134 | { |
0ec7b3e7 | 135 | Chardev *s = be->chr; |
777357d7 | 136 | ChardevClass *cc; |
9005b2a7 PB |
137 | int ret; |
138 | ||
fa394ed6 MAL |
139 | if (!s) { |
140 | return 0; | |
141 | } | |
142 | ||
5ebd6703 | 143 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { |
33577b47 PD |
144 | int offset; |
145 | replay_char_write_event_load(&ret, &offset); | |
146 | assert(offset <= len); | |
147 | qemu_chr_fe_write_buffer(s, buf, offset, &offset); | |
148 | return ret; | |
149 | } | |
150 | ||
777357d7 | 151 | cc = CHARDEV_GET_CLASS(s); |
9005b2a7 | 152 | qemu_mutex_lock(&s->chr_write_lock); |
777357d7 | 153 | ret = cc->chr_write(s, buf, len); |
d0d7708b DB |
154 | |
155 | if (ret > 0) { | |
156 | qemu_chr_fe_write_log(s, buf, ret); | |
157 | } | |
158 | ||
9005b2a7 | 159 | qemu_mutex_unlock(&s->chr_write_lock); |
33577b47 | 160 | |
5ebd6703 | 161 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { |
33577b47 PD |
162 | replay_char_write_event_save(ret, ret < 0 ? 0 : ret); |
163 | } | |
164 | ||
9005b2a7 | 165 | return ret; |
6f97dba0 AL |
166 | } |
167 | ||
df85a78b | 168 | int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len) |
cd18720a | 169 | { |
33577b47 PD |
170 | int offset; |
171 | int res; | |
cd18720a | 172 | |
5ebd6703 | 173 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { |
33577b47 PD |
174 | replay_char_write_event_load(&res, &offset); |
175 | assert(offset <= len); | |
176 | qemu_chr_fe_write_buffer(s, buf, offset, &offset); | |
177 | return res; | |
178 | } | |
cd18720a | 179 | |
33577b47 | 180 | res = qemu_chr_fe_write_buffer(s, buf, len, &offset); |
cd18720a | 181 | |
5ebd6703 | 182 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { |
33577b47 | 183 | replay_char_write_event_save(res, offset); |
cd18720a AL |
184 | } |
185 | ||
9005b2a7 PB |
186 | if (res < 0) { |
187 | return res; | |
188 | } | |
cd18720a AL |
189 | return offset; |
190 | } | |
191 | ||
5345fdb4 | 192 | int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len) |
7b0bfdf5 | 193 | { |
0ec7b3e7 | 194 | Chardev *s = be->chr; |
5345fdb4 | 195 | |
fa394ed6 MAL |
196 | if (!s) { |
197 | return 0; | |
198 | } | |
199 | ||
5345fdb4 MAL |
200 | return qemu_chr_write_all(s, buf, len); |
201 | } | |
202 | ||
203 | int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len) | |
204 | { | |
0ec7b3e7 | 205 | Chardev *s = be->chr; |
7b0bfdf5 NN |
206 | int offset = 0, counter = 10; |
207 | int res; | |
208 | ||
777357d7 | 209 | if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) { |
7b0bfdf5 NN |
210 | return 0; |
211 | } | |
fa394ed6 | 212 | |
5ebd6703 | 213 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { |
33577b47 PD |
214 | return replay_char_read_all_load(buf); |
215 | } | |
7b0bfdf5 NN |
216 | |
217 | while (offset < len) { | |
53628efb | 218 | retry: |
777357d7 MAL |
219 | res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset, |
220 | len - offset); | |
53628efb DB |
221 | if (res == -1 && errno == EAGAIN) { |
222 | g_usleep(100); | |
223 | goto retry; | |
224 | } | |
7b0bfdf5 NN |
225 | |
226 | if (res == 0) { | |
227 | break; | |
228 | } | |
229 | ||
230 | if (res < 0) { | |
5ebd6703 | 231 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { |
33577b47 PD |
232 | replay_char_read_all_save_error(res); |
233 | } | |
7b0bfdf5 NN |
234 | return res; |
235 | } | |
236 | ||
237 | offset += res; | |
238 | ||
239 | if (!counter--) { | |
240 | break; | |
241 | } | |
242 | } | |
243 | ||
5ebd6703 | 244 | if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { |
33577b47 PD |
245 | replay_char_read_all_save_buf(buf, offset); |
246 | } | |
7b0bfdf5 NN |
247 | return offset; |
248 | } | |
249 | ||
5345fdb4 | 250 | int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg) |
6f97dba0 | 251 | { |
0ec7b3e7 | 252 | Chardev *s = be->chr; |
33577b47 | 253 | int res; |
fa394ed6 | 254 | |
777357d7 | 255 | if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) { |
33577b47 PD |
256 | res = -ENOTSUP; |
257 | } else { | |
777357d7 | 258 | res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg); |
33577b47 PD |
259 | } |
260 | ||
261 | return res; | |
6f97dba0 AL |
262 | } |
263 | ||
0ec7b3e7 | 264 | int qemu_chr_be_can_write(Chardev *s) |
6f97dba0 | 265 | { |
a4afa548 MAL |
266 | CharBackend *be = s->be; |
267 | ||
268 | if (!be || !be->chr_can_read) { | |
6f97dba0 | 269 | return 0; |
a4afa548 MAL |
270 | } |
271 | ||
272 | return be->chr_can_read(be->opaque); | |
6f97dba0 AL |
273 | } |
274 | ||
0ec7b3e7 | 275 | void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len) |
6f97dba0 | 276 | { |
a4afa548 MAL |
277 | CharBackend *be = s->be; |
278 | ||
279 | if (be && be->chr_read) { | |
280 | be->chr_read(be->opaque, buf, len); | |
ac310734 | 281 | } |
6f97dba0 AL |
282 | } |
283 | ||
0ec7b3e7 | 284 | void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len) |
33577b47 | 285 | { |
5ebd6703 | 286 | if (qemu_chr_replay(s)) { |
33577b47 PD |
287 | if (replay_mode == REPLAY_MODE_PLAY) { |
288 | return; | |
289 | } | |
290 | replay_chr_be_write(s, buf, len); | |
291 | } else { | |
292 | qemu_chr_be_write_impl(s, buf, len); | |
293 | } | |
294 | } | |
295 | ||
5345fdb4 | 296 | int qemu_chr_fe_get_msgfd(CharBackend *be) |
7d174059 | 297 | { |
0ec7b3e7 | 298 | Chardev *s = be->chr; |
c76bf6bb | 299 | int fd; |
5345fdb4 | 300 | int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1; |
5ebd6703 | 301 | if (s && qemu_chr_replay(s)) { |
776a32a0 MAL |
302 | error_report("Replay: get msgfd is not supported " |
303 | "for serial devices yet"); | |
33577b47 PD |
304 | exit(1); |
305 | } | |
306 | return res; | |
c76bf6bb NN |
307 | } |
308 | ||
5345fdb4 | 309 | int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len) |
c76bf6bb | 310 | { |
0ec7b3e7 | 311 | Chardev *s = be->chr; |
5345fdb4 | 312 | |
fa394ed6 MAL |
313 | if (!s) { |
314 | return -1; | |
315 | } | |
316 | ||
777357d7 MAL |
317 | return CHARDEV_GET_CLASS(s)->get_msgfds ? |
318 | CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1; | |
7d174059 MM |
319 | } |
320 | ||
5345fdb4 | 321 | int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num) |
d39aac7a | 322 | { |
0ec7b3e7 | 323 | Chardev *s = be->chr; |
5345fdb4 | 324 | |
fa394ed6 MAL |
325 | if (!s) { |
326 | return -1; | |
327 | } | |
328 | ||
777357d7 MAL |
329 | return CHARDEV_GET_CLASS(s)->set_msgfds ? |
330 | CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1; | |
d39aac7a NN |
331 | } |
332 | ||
0ec7b3e7 | 333 | int qemu_chr_add_client(Chardev *s, int fd) |
13661089 | 334 | { |
777357d7 MAL |
335 | return CHARDEV_GET_CLASS(s)->chr_add_client ? |
336 | CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1; | |
13661089 DB |
337 | } |
338 | ||
5345fdb4 | 339 | void qemu_chr_fe_accept_input(CharBackend *be) |
6f97dba0 | 340 | { |
0ec7b3e7 | 341 | Chardev *s = be->chr; |
5345fdb4 | 342 | |
fa394ed6 MAL |
343 | if (!s) { |
344 | return; | |
345 | } | |
346 | ||
777357d7 MAL |
347 | if (CHARDEV_GET_CLASS(s)->chr_accept_input) { |
348 | CHARDEV_GET_CLASS(s)->chr_accept_input(s); | |
b68e956a | 349 | } |
98c8ee1d | 350 | qemu_notify_event(); |
6f97dba0 AL |
351 | } |
352 | ||
5345fdb4 | 353 | void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...) |
6f97dba0 | 354 | { |
f612143a | 355 | char buf[CHR_READ_BUF_LEN]; |
6f97dba0 AL |
356 | va_list ap; |
357 | va_start(ap, fmt); | |
358 | vsnprintf(buf, sizeof(buf), fmt, ap); | |
90f998f5 DB |
359 | /* XXX this blocks entire thread. Rewrite to use |
360 | * qemu_chr_fe_write and background I/O callbacks */ | |
5345fdb4 | 361 | qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf)); |
6f97dba0 AL |
362 | va_end(ap); |
363 | } | |
364 | ||
777357d7 MAL |
365 | static void qemu_char_open(Chardev *chr, ChardevBackend *backend, |
366 | bool *be_opened, Error **errp) | |
6f97dba0 | 367 | { |
777357d7 MAL |
368 | ChardevClass *cc = CHARDEV_GET_CLASS(chr); |
369 | /* Any ChardevCommon member would work */ | |
370 | ChardevCommon *common = backend ? backend->u.null.data : NULL; | |
371 | ||
372 | if (common && common->has_logfile) { | |
373 | int flags = O_WRONLY | O_CREAT; | |
374 | if (common->has_logappend && | |
375 | common->logappend) { | |
376 | flags |= O_APPEND; | |
377 | } else { | |
378 | flags |= O_TRUNC; | |
379 | } | |
380 | chr->logfd = qemu_open(common->logfile, flags, 0666); | |
381 | if (chr->logfd < 0) { | |
382 | error_setg_errno(errp, errno, | |
383 | "Unable to open logfile %s", | |
384 | common->logfile); | |
385 | return; | |
386 | } | |
387 | } | |
388 | ||
389 | if (cc->open) { | |
390 | cc->open(chr, backend, be_opened, errp); | |
391 | } | |
6f97dba0 AL |
392 | } |
393 | ||
777357d7 | 394 | static void char_init(Object *obj) |
6f97dba0 | 395 | { |
777357d7 | 396 | Chardev *chr = CHARDEV(obj); |
6f97dba0 | 397 | |
777357d7 MAL |
398 | chr->logfd = -1; |
399 | qemu_mutex_init(&chr->chr_write_lock); | |
400 | } | |
401 | ||
eb314a94 MAL |
402 | static int null_chr_write(Chardev *chr, const uint8_t *buf, int len) |
403 | { | |
404 | return len; | |
405 | } | |
406 | ||
407 | static void char_class_init(ObjectClass *oc, void *data) | |
408 | { | |
409 | ChardevClass *cc = CHARDEV_CLASS(oc); | |
410 | ||
411 | cc->chr_write = null_chr_write; | |
412 | } | |
413 | ||
777357d7 MAL |
414 | static void char_finalize(Object *obj) |
415 | { | |
416 | Chardev *chr = CHARDEV(obj); | |
417 | ||
418 | if (chr->be) { | |
419 | chr->be->chr = NULL; | |
420 | } | |
421 | g_free(chr->filename); | |
422 | g_free(chr->label); | |
423 | if (chr->logfd != -1) { | |
424 | close(chr->logfd); | |
d0d7708b | 425 | } |
777357d7 MAL |
426 | qemu_mutex_destroy(&chr->chr_write_lock); |
427 | } | |
428 | ||
429 | static const TypeInfo char_type_info = { | |
430 | .name = TYPE_CHARDEV, | |
431 | .parent = TYPE_OBJECT, | |
432 | .instance_size = sizeof(Chardev), | |
433 | .instance_init = char_init, | |
434 | .instance_finalize = char_finalize, | |
435 | .abstract = true, | |
436 | .class_size = sizeof(ChardevClass), | |
eb314a94 | 437 | .class_init = char_class_init, |
777357d7 MAL |
438 | }; |
439 | ||
7b7ab18d MR |
440 | /** |
441 | * Called after processing of default and command-line-specified | |
442 | * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached | |
443 | * to a mux chardev. This is done here to ensure that | |
444 | * output/prompts/banners are only displayed for the FE that has | |
445 | * focus when initial command-line processing/machine init is | |
446 | * completed. | |
447 | * | |
448 | * After this point, any new FE attached to any new or existing | |
449 | * mux will receive CHR_EVENT_OPENED notifications for the BE | |
450 | * immediately. | |
451 | */ | |
6061162e | 452 | static int open_muxes(Object *child, void *opaque) |
7b7ab18d | 453 | { |
6061162e MAL |
454 | if (CHARDEV_IS_MUX(child)) { |
455 | /* send OPENED to all already-attached FEs */ | |
456 | mux_chr_send_all_event(CHARDEV(child), CHR_EVENT_OPENED); | |
457 | /* mark mux as OPENED so any new FEs will immediately receive | |
458 | * OPENED event | |
459 | */ | |
460 | qemu_chr_be_event(CHARDEV(child), CHR_EVENT_OPENED); | |
461 | } | |
7b7ab18d | 462 | |
6061162e MAL |
463 | return 0; |
464 | } | |
7b7ab18d | 465 | |
6061162e MAL |
466 | static void muxes_realize_done(Notifier *notifier, void *unused) |
467 | { | |
7b7ab18d | 468 | muxes_realized = true; |
6061162e | 469 | object_child_foreach(get_chardevs_root(), open_muxes, NULL); |
7b7ab18d MR |
470 | } |
471 | ||
472 | static Notifier muxes_realize_notify = { | |
473 | .notify = muxes_realize_done, | |
474 | }; | |
475 | ||
0ec7b3e7 | 476 | Chardev *qemu_chr_fe_get_driver(CharBackend *be) |
94a40fc5 MAL |
477 | { |
478 | return be->chr; | |
479 | } | |
480 | ||
0ec7b3e7 | 481 | bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp) |
94a40fc5 MAL |
482 | { |
483 | int tag = 0; | |
484 | ||
777357d7 MAL |
485 | if (CHARDEV_IS_MUX(s)) { |
486 | MuxChardev *d = MUX_CHARDEV(s); | |
3aef23d7 MAL |
487 | |
488 | if (d->mux_cnt >= MAX_MUX) { | |
489 | goto unavailable; | |
94a40fc5 | 490 | } |
3aef23d7 MAL |
491 | |
492 | d->backends[d->mux_cnt] = b; | |
493 | tag = d->mux_cnt++; | |
494 | } else if (s->be) { | |
495 | goto unavailable; | |
a4afa548 MAL |
496 | } else { |
497 | s->be = b; | |
94a40fc5 MAL |
498 | } |
499 | ||
830896af | 500 | b->fe_open = false; |
94a40fc5 MAL |
501 | b->tag = tag; |
502 | b->chr = s; | |
94a40fc5 | 503 | return true; |
3aef23d7 MAL |
504 | |
505 | unavailable: | |
506 | error_setg(errp, QERR_DEVICE_IN_USE, s->label); | |
507 | return false; | |
94a40fc5 MAL |
508 | } |
509 | ||
0ec7b3e7 | 510 | static bool qemu_chr_is_busy(Chardev *s) |
a4afa548 | 511 | { |
777357d7 MAL |
512 | if (CHARDEV_IS_MUX(s)) { |
513 | MuxChardev *d = MUX_CHARDEV(s); | |
a4afa548 MAL |
514 | return d->mux_cnt >= 0; |
515 | } else { | |
516 | return s->be != NULL; | |
517 | } | |
518 | } | |
519 | ||
c39860e6 MAL |
520 | void qemu_chr_fe_deinit(CharBackend *b) |
521 | { | |
522 | assert(b); | |
523 | ||
524 | if (b->chr) { | |
39ab61c6 | 525 | qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true); |
fb5e19d2 MAL |
526 | if (b->chr->be == b) { |
527 | b->chr->be = NULL; | |
528 | } | |
777357d7 MAL |
529 | if (CHARDEV_IS_MUX(b->chr)) { |
530 | MuxChardev *d = MUX_CHARDEV(b->chr); | |
a4afa548 MAL |
531 | d->backends[b->tag] = NULL; |
532 | } | |
c39860e6 MAL |
533 | b->chr = NULL; |
534 | } | |
535 | } | |
536 | ||
94a40fc5 MAL |
537 | void qemu_chr_fe_set_handlers(CharBackend *b, |
538 | IOCanReadHandler *fd_can_read, | |
539 | IOReadHandler *fd_read, | |
540 | IOEventHandler *fd_event, | |
541 | void *opaque, | |
39ab61c6 MAL |
542 | GMainContext *context, |
543 | bool set_open) | |
94a40fc5 | 544 | { |
0ec7b3e7 | 545 | Chardev *s; |
777357d7 | 546 | ChardevClass *cc; |
386f07d1 MAL |
547 | int fe_open; |
548 | ||
549 | s = b->chr; | |
550 | if (!s) { | |
94a40fc5 MAL |
551 | return; |
552 | } | |
553 | ||
777357d7 | 554 | cc = CHARDEV_GET_CLASS(s); |
386f07d1 MAL |
555 | if (!opaque && !fd_can_read && !fd_read && !fd_event) { |
556 | fe_open = 0; | |
8487ce45 | 557 | remove_fd_in_watch(s, context); |
386f07d1 MAL |
558 | } else { |
559 | fe_open = 1; | |
560 | } | |
a4afa548 MAL |
561 | b->chr_can_read = fd_can_read; |
562 | b->chr_read = fd_read; | |
563 | b->chr_event = fd_event; | |
564 | b->opaque = opaque; | |
777357d7 MAL |
565 | if (cc->chr_update_read_handler) { |
566 | cc->chr_update_read_handler(s, context); | |
386f07d1 MAL |
567 | } |
568 | ||
39ab61c6 | 569 | if (set_open) { |
386f07d1 MAL |
570 | qemu_chr_fe_set_open(b, fe_open); |
571 | } | |
94a40fc5 | 572 | |
386f07d1 MAL |
573 | if (fe_open) { |
574 | qemu_chr_fe_take_focus(b); | |
575 | /* We're connecting to an already opened device, so let's make sure we | |
576 | also get the open event */ | |
577 | if (s->be_open) { | |
63618135 | 578 | qemu_chr_be_event(s, CHR_EVENT_OPENED); |
386f07d1 MAL |
579 | } |
580 | } | |
581 | ||
777357d7 | 582 | if (CHARDEV_IS_MUX(s)) { |
386f07d1 | 583 | mux_chr_set_handlers(s, context); |
94a40fc5 MAL |
584 | } |
585 | } | |
586 | ||
587 | void qemu_chr_fe_take_focus(CharBackend *b) | |
588 | { | |
fa394ed6 MAL |
589 | if (!b->chr) { |
590 | return; | |
591 | } | |
592 | ||
777357d7 | 593 | if (CHARDEV_IS_MUX(b->chr)) { |
fb5e19d2 | 594 | mux_set_focus(b->chr, b->tag); |
94a40fc5 MAL |
595 | } |
596 | } | |
6f97dba0 | 597 | |
d24ca4b8 | 598 | int qemu_chr_wait_connected(Chardev *chr, Error **errp) |
6b6723c3 | 599 | { |
777357d7 MAL |
600 | ChardevClass *cc = CHARDEV_GET_CLASS(chr); |
601 | ||
602 | if (cc->chr_wait_connected) { | |
603 | return cc->chr_wait_connected(chr, errp); | |
6b6723c3 MAL |
604 | } |
605 | ||
606 | return 0; | |
607 | } | |
608 | ||
5345fdb4 MAL |
609 | int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp) |
610 | { | |
fa394ed6 MAL |
611 | if (!be->chr) { |
612 | error_setg(errp, "missing associated backend"); | |
613 | return -1; | |
614 | } | |
615 | ||
5345fdb4 MAL |
616 | return qemu_chr_wait_connected(be->chr, errp); |
617 | } | |
618 | ||
33521634 | 619 | QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename) |
191bc01b | 620 | { |
6ea314d9 | 621 | char host[65], port[33], width[8], height[8]; |
aeb2c47a | 622 | int pos; |
7d31544f | 623 | const char *p; |
191bc01b | 624 | QemuOpts *opts; |
8be7e7e4 | 625 | Error *local_err = NULL; |
191bc01b | 626 | |
8be7e7e4 | 627 | opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err); |
84d18f06 | 628 | if (local_err) { |
33394884 | 629 | error_report_err(local_err); |
191bc01b | 630 | return NULL; |
8be7e7e4 | 631 | } |
191bc01b | 632 | |
7591c5c1 GH |
633 | if (strstart(filename, "mon:", &p)) { |
634 | filename = p; | |
f43e47db | 635 | qemu_opt_set(opts, "mux", "on", &error_abort); |
02c4bdf1 PB |
636 | if (strcmp(filename, "stdio") == 0) { |
637 | /* Monitor is muxed to stdio: do not exit on Ctrl+C by default | |
638 | * but pass it to the guest. Handle this only for compat syntax, | |
639 | * for -chardev syntax we have special option for this. | |
640 | * This is what -nographic did, redirecting+muxing serial+monitor | |
641 | * to stdio causing Ctrl+C to be passed to guest. */ | |
f43e47db | 642 | qemu_opt_set(opts, "signal", "off", &error_abort); |
02c4bdf1 | 643 | } |
7591c5c1 GH |
644 | } |
645 | ||
f0457e8d GH |
646 | if (strcmp(filename, "null") == 0 || |
647 | strcmp(filename, "pty") == 0 || | |
648 | strcmp(filename, "msmouse") == 0 || | |
378af961 | 649 | strcmp(filename, "wctablet") == 0 || |
dc1c21e6 | 650 | strcmp(filename, "braille") == 0 || |
5692399f | 651 | strcmp(filename, "testdev") == 0 || |
f0457e8d | 652 | strcmp(filename, "stdio") == 0) { |
f43e47db | 653 | qemu_opt_set(opts, "backend", filename, &error_abort); |
191bc01b GH |
654 | return opts; |
655 | } | |
6ea314d9 | 656 | if (strstart(filename, "vc", &p)) { |
f43e47db | 657 | qemu_opt_set(opts, "backend", "vc", &error_abort); |
6ea314d9 | 658 | if (*p == ':') { |
49aa4058 | 659 | if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) { |
6ea314d9 | 660 | /* pixels */ |
f43e47db MA |
661 | qemu_opt_set(opts, "width", width, &error_abort); |
662 | qemu_opt_set(opts, "height", height, &error_abort); | |
49aa4058 | 663 | } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) { |
6ea314d9 | 664 | /* chars */ |
f43e47db MA |
665 | qemu_opt_set(opts, "cols", width, &error_abort); |
666 | qemu_opt_set(opts, "rows", height, &error_abort); | |
6ea314d9 GH |
667 | } else { |
668 | goto fail; | |
669 | } | |
670 | } | |
671 | return opts; | |
672 | } | |
d6c983cd | 673 | if (strcmp(filename, "con:") == 0) { |
f43e47db | 674 | qemu_opt_set(opts, "backend", "console", &error_abort); |
d6c983cd GH |
675 | return opts; |
676 | } | |
48b76496 | 677 | if (strstart(filename, "COM", NULL)) { |
f43e47db MA |
678 | qemu_opt_set(opts, "backend", "serial", &error_abort); |
679 | qemu_opt_set(opts, "path", filename, &error_abort); | |
48b76496 GH |
680 | return opts; |
681 | } | |
7d31544f | 682 | if (strstart(filename, "file:", &p)) { |
f43e47db MA |
683 | qemu_opt_set(opts, "backend", "file", &error_abort); |
684 | qemu_opt_set(opts, "path", p, &error_abort); | |
7d31544f GH |
685 | return opts; |
686 | } | |
687 | if (strstart(filename, "pipe:", &p)) { | |
f43e47db MA |
688 | qemu_opt_set(opts, "backend", "pipe", &error_abort); |
689 | qemu_opt_set(opts, "path", p, &error_abort); | |
7d31544f GH |
690 | return opts; |
691 | } | |
aeb2c47a | 692 | if (strstart(filename, "tcp:", &p) || |
ae92cbd5 JL |
693 | strstart(filename, "telnet:", &p) || |
694 | strstart(filename, "tn3270:", &p)) { | |
aeb2c47a GH |
695 | if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { |
696 | host[0] = 0; | |
697 | if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) | |
698 | goto fail; | |
699 | } | |
f43e47db MA |
700 | qemu_opt_set(opts, "backend", "socket", &error_abort); |
701 | qemu_opt_set(opts, "host", host, &error_abort); | |
702 | qemu_opt_set(opts, "port", port, &error_abort); | |
aeb2c47a | 703 | if (p[pos] == ',') { |
dc523cd3 MA |
704 | qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err); |
705 | if (local_err) { | |
706 | error_report_err(local_err); | |
aeb2c47a | 707 | goto fail; |
dc523cd3 | 708 | } |
aeb2c47a | 709 | } |
ae92cbd5 | 710 | if (strstart(filename, "telnet:", &p)) { |
f43e47db | 711 | qemu_opt_set(opts, "telnet", "on", &error_abort); |
ae92cbd5 JL |
712 | } else if (strstart(filename, "tn3270:", &p)) { |
713 | qemu_opt_set(opts, "tn3270", "on", &error_abort); | |
714 | } | |
aeb2c47a GH |
715 | return opts; |
716 | } | |
7e1b35b4 | 717 | if (strstart(filename, "udp:", &p)) { |
f43e47db | 718 | qemu_opt_set(opts, "backend", "udp", &error_abort); |
7e1b35b4 GH |
719 | if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) { |
720 | host[0] = 0; | |
39324ca4 | 721 | if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) { |
7e1b35b4 GH |
722 | goto fail; |
723 | } | |
724 | } | |
f43e47db MA |
725 | qemu_opt_set(opts, "host", host, &error_abort); |
726 | qemu_opt_set(opts, "port", port, &error_abort); | |
7e1b35b4 GH |
727 | if (p[pos] == '@') { |
728 | p += pos + 1; | |
729 | if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { | |
730 | host[0] = 0; | |
731 | if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) { | |
7e1b35b4 GH |
732 | goto fail; |
733 | } | |
734 | } | |
f43e47db MA |
735 | qemu_opt_set(opts, "localaddr", host, &error_abort); |
736 | qemu_opt_set(opts, "localport", port, &error_abort); | |
7e1b35b4 GH |
737 | } |
738 | return opts; | |
739 | } | |
aeb2c47a | 740 | if (strstart(filename, "unix:", &p)) { |
f43e47db | 741 | qemu_opt_set(opts, "backend", "socket", &error_abort); |
dc523cd3 MA |
742 | qemu_opts_do_parse(opts, p, "path", &local_err); |
743 | if (local_err) { | |
744 | error_report_err(local_err); | |
aeb2c47a | 745 | goto fail; |
dc523cd3 | 746 | } |
aeb2c47a GH |
747 | return opts; |
748 | } | |
48b76496 GH |
749 | if (strstart(filename, "/dev/parport", NULL) || |
750 | strstart(filename, "/dev/ppi", NULL)) { | |
f43e47db MA |
751 | qemu_opt_set(opts, "backend", "parport", &error_abort); |
752 | qemu_opt_set(opts, "path", filename, &error_abort); | |
48b76496 GH |
753 | return opts; |
754 | } | |
755 | if (strstart(filename, "/dev/", NULL)) { | |
f43e47db MA |
756 | qemu_opt_set(opts, "backend", "tty", &error_abort); |
757 | qemu_opt_set(opts, "path", filename, &error_abort); | |
48b76496 GH |
758 | return opts; |
759 | } | |
191bc01b | 760 | |
aeb2c47a | 761 | fail: |
191bc01b GH |
762 | qemu_opts_del(opts); |
763 | return NULL; | |
764 | } | |
765 | ||
21a933ea | 766 | void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend) |
d0d7708b DB |
767 | { |
768 | const char *logfile = qemu_opt_get(opts, "logfile"); | |
769 | ||
770 | backend->has_logfile = logfile != NULL; | |
e1f98fe4 | 771 | backend->logfile = g_strdup(logfile); |
d0d7708b DB |
772 | |
773 | backend->has_logappend = true; | |
774 | backend->logappend = qemu_opt_get_bool(opts, "logappend", false); | |
775 | } | |
776 | ||
88cace9f MAL |
777 | static const ChardevClass *char_get_class(const char *driver, Error **errp) |
778 | { | |
779 | ObjectClass *oc; | |
780 | const ChardevClass *cc; | |
781 | char *typename = g_strdup_printf("chardev-%s", driver); | |
782 | ||
783 | oc = object_class_by_name(typename); | |
784 | g_free(typename); | |
785 | ||
786 | if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) { | |
787 | error_setg(errp, "'%s' is not a valid char driver name", driver); | |
788 | return NULL; | |
789 | } | |
d654f34e | 790 | |
88cace9f MAL |
791 | if (object_class_is_abstract(oc)) { |
792 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver", | |
793 | "abstract device type"); | |
794 | return NULL; | |
795 | } | |
796 | ||
797 | cc = CHARDEV_CLASS(oc); | |
798 | if (cc->internal) { | |
799 | error_setg(errp, "'%s' is not a valid char driver name", driver); | |
800 | return NULL; | |
801 | } | |
802 | ||
803 | return cc; | |
804 | } | |
805 | ||
806 | static const struct ChardevAlias { | |
807 | const char *typename; | |
808 | const char *alias; | |
809 | } chardev_alias_table[] = { | |
810 | #ifdef HAVE_CHARDEV_PARPORT | |
811 | { "parallel", "parport" }, | |
812 | #endif | |
813 | #ifdef HAVE_CHARDEV_SERIAL | |
814 | { "serial", "tty" }, | |
815 | #endif | |
816 | }; | |
817 | ||
818 | typedef struct ChadevClassFE { | |
819 | void (*fn)(const char *name, void *opaque); | |
820 | void *opaque; | |
821 | } ChadevClassFE; | |
822 | ||
823 | static void | |
824 | chardev_class_foreach(ObjectClass *klass, void *opaque) | |
2c5f4882 | 825 | { |
88cace9f MAL |
826 | ChadevClassFE *fe = opaque; |
827 | ||
828 | assert(g_str_has_prefix(object_class_get_name(klass), "chardev-")); | |
829 | if (CHARDEV_CLASS(klass)->internal) { | |
830 | return; | |
831 | } | |
832 | ||
833 | fe->fn(object_class_get_name(klass) + 8, fe->opaque); | |
834 | } | |
835 | ||
836 | static void | |
837 | chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque) | |
838 | { | |
839 | ChadevClassFE fe = { .fn = fn, .opaque = opaque }; | |
840 | int i; | |
841 | ||
842 | object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe); | |
843 | ||
844 | for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) { | |
845 | fn(chardev_alias_table[i].alias, opaque); | |
846 | } | |
847 | } | |
848 | ||
849 | static void | |
850 | help_string_append(const char *name, void *opaque) | |
851 | { | |
852 | GString *str = opaque; | |
853 | ||
854 | g_string_append_printf(str, "\n%s", name); | |
2c5f4882 GH |
855 | } |
856 | ||
0ec7b3e7 MAL |
857 | Chardev *qemu_chr_new_from_opts(QemuOpts *opts, |
858 | Error **errp) | |
191bc01b | 859 | { |
0aff637e | 860 | Error *local_err = NULL; |
88cace9f | 861 | const ChardevClass *cc; |
0ec7b3e7 | 862 | Chardev *chr; |
a1698bf1 | 863 | int i; |
0b663b7d | 864 | ChardevBackend *backend = NULL; |
0b812f31 | 865 | const char *name = qemu_opt_get(opts, "backend"); |
a61ae7f8 PM |
866 | const char *id = qemu_opts_id(opts); |
867 | char *bid = NULL; | |
191bc01b | 868 | |
0b812f31 | 869 | if (name == NULL) { |
312fd5f2 | 870 | error_setg(errp, "chardev: \"%s\" missing backend", |
bd2d80b2 | 871 | qemu_opts_id(opts)); |
0b663b7d | 872 | return NULL; |
1bbd185f | 873 | } |
517b3d40 | 874 | |
0b812f31 | 875 | if (is_help_option(name)) { |
776a32a0 | 876 | GString *str = g_string_new(""); |
88cace9f MAL |
877 | |
878 | chardev_name_foreach(help_string_append, str); | |
776a32a0 MAL |
879 | |
880 | error_report("Available chardev backend types: %s", str->str); | |
881 | g_string_free(str, true); | |
0b812f31 | 882 | exit(0); |
517b3d40 LM |
883 | } |
884 | ||
885 | if (id == NULL) { | |
886 | error_setg(errp, "chardev: no id specified"); | |
0b663b7d | 887 | return NULL; |
517b3d40 LM |
888 | } |
889 | ||
88cace9f MAL |
890 | for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) { |
891 | if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) { | |
892 | name = chardev_alias_table[i].typename; | |
191bc01b | 893 | break; |
d654f34e | 894 | } |
191bc01b | 895 | } |
88cace9f MAL |
896 | |
897 | cc = char_get_class(name, errp); | |
898 | if (cc == NULL) { | |
0b663b7d | 899 | return NULL; |
191bc01b GH |
900 | } |
901 | ||
a61ae7f8 | 902 | backend = g_new0(ChardevBackend, 1); |
0b663b7d | 903 | backend->type = CHARDEV_BACKEND_KIND_NULL; |
edb2fb3c | 904 | |
a61ae7f8 PM |
905 | if (qemu_opt_get_bool(opts, "mux", 0)) { |
906 | bid = g_strdup_printf("%s-base", id); | |
907 | } | |
2c5f4882 | 908 | |
a61ae7f8 | 909 | chr = NULL; |
88cace9f MAL |
910 | if (cc->parse) { |
911 | cc->parse(opts, backend, &local_err); | |
a61ae7f8 PM |
912 | if (local_err) { |
913 | error_propagate(errp, local_err); | |
0b663b7d | 914 | goto out; |
2c5f4882 | 915 | } |
d0d7708b | 916 | } else { |
88cace9f MAL |
917 | ChardevCommon *ccom = g_new0(ChardevCommon, 1); |
918 | qemu_chr_parse_common(opts, ccom); | |
919 | backend->u.null.data = ccom; /* Any ChardevCommon member would work */ | |
2c5f4882 | 920 | } |
d0d7708b | 921 | |
c5749f7c | 922 | chr = qemu_chardev_new(bid ? bid : id, |
0b663b7d MAL |
923 | object_class_get_name(OBJECT_CLASS(cc)), |
924 | backend, errp); | |
c5749f7c | 925 | |
0b663b7d MAL |
926 | if (chr == NULL) { |
927 | goto out; | |
191bc01b GH |
928 | } |
929 | ||
a61ae7f8 | 930 | if (bid) { |
0b663b7d | 931 | Chardev *mux; |
a61ae7f8 | 932 | qapi_free_ChardevBackend(backend); |
a61ae7f8 | 933 | backend = g_new0(ChardevBackend, 1); |
130257dc | 934 | backend->type = CHARDEV_BACKEND_KIND_MUX; |
0b663b7d | 935 | backend->u.mux.data = g_new0(ChardevMux, 1); |
32bafa8f | 936 | backend->u.mux.data->chardev = g_strdup(bid); |
c5749f7c | 937 | mux = qemu_chardev_new(id, TYPE_CHARDEV_MUX, backend, errp); |
0b663b7d | 938 | if (mux == NULL) { |
2f5d45a1 | 939 | object_unparent(OBJECT(chr)); |
a61ae7f8 | 940 | chr = NULL; |
0b663b7d | 941 | goto out; |
a61ae7f8 | 942 | } |
0b663b7d | 943 | chr = mux; |
bd5c51ee | 944 | } |
7591c5c1 | 945 | |
0b663b7d | 946 | out: |
a61ae7f8 | 947 | qapi_free_ChardevBackend(backend); |
a61ae7f8 | 948 | g_free(bid); |
191bc01b GH |
949 | return chr; |
950 | } | |
951 | ||
0ec7b3e7 | 952 | Chardev *qemu_chr_new_noreplay(const char *label, const char *filename) |
6f97dba0 AL |
953 | { |
954 | const char *p; | |
0ec7b3e7 | 955 | Chardev *chr; |
191bc01b | 956 | QemuOpts *opts; |
bd2d80b2 | 957 | Error *err = NULL; |
191bc01b | 958 | |
c845f401 GH |
959 | if (strstart(filename, "chardev:", &p)) { |
960 | return qemu_chr_find(p); | |
961 | } | |
962 | ||
191bc01b | 963 | opts = qemu_chr_parse_compat(label, filename); |
7e1b35b4 GH |
964 | if (!opts) |
965 | return NULL; | |
6f97dba0 | 966 | |
b4948be9 | 967 | chr = qemu_chr_new_from_opts(opts, &err); |
84d18f06 | 968 | if (err) { |
565f65d2 | 969 | error_report_err(err); |
bd2d80b2 | 970 | } |
7e1b35b4 GH |
971 | if (chr && qemu_opt_get_bool(opts, "mux", 0)) { |
972 | monitor_init(chr, MONITOR_USE_READLINE); | |
6f97dba0 | 973 | } |
0a73336d | 974 | qemu_opts_del(opts); |
6f97dba0 AL |
975 | return chr; |
976 | } | |
977 | ||
0ec7b3e7 | 978 | Chardev *qemu_chr_new(const char *label, const char *filename) |
33577b47 | 979 | { |
0ec7b3e7 | 980 | Chardev *chr; |
b4948be9 | 981 | chr = qemu_chr_new_noreplay(label, filename); |
33577b47 | 982 | if (chr) { |
5ebd6703 MAL |
983 | if (replay_mode != REPLAY_MODE_NONE) { |
984 | qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY); | |
985 | } | |
777357d7 | 986 | if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) { |
776a32a0 MAL |
987 | error_report("Replay: ioctl is not supported " |
988 | "for serial devices yet"); | |
33577b47 PD |
989 | } |
990 | replay_register_char_driver(chr); | |
991 | } | |
992 | return chr; | |
993 | } | |
994 | ||
5345fdb4 | 995 | void qemu_chr_fe_set_echo(CharBackend *be, bool echo) |
c48855e1 | 996 | { |
0ec7b3e7 | 997 | Chardev *chr = be->chr; |
5345fdb4 | 998 | |
777357d7 MAL |
999 | if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) { |
1000 | CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo); | |
c48855e1 PB |
1001 | } |
1002 | } | |
1003 | ||
5345fdb4 | 1004 | void qemu_chr_fe_set_open(CharBackend *be, int fe_open) |
7c32c4fe | 1005 | { |
0ec7b3e7 | 1006 | Chardev *chr = be->chr; |
5345fdb4 | 1007 | |
fa394ed6 MAL |
1008 | if (!chr) { |
1009 | return; | |
1010 | } | |
1011 | ||
830896af | 1012 | if (be->fe_open == fe_open) { |
c0c4bd2c HG |
1013 | return; |
1014 | } | |
830896af | 1015 | be->fe_open = fe_open; |
777357d7 MAL |
1016 | if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) { |
1017 | CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open); | |
7c32c4fe HG |
1018 | } |
1019 | } | |
1020 | ||
5345fdb4 | 1021 | guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond, |
6f1de6b7 | 1022 | GIOFunc func, void *user_data) |
23673ca7 | 1023 | { |
0ec7b3e7 | 1024 | Chardev *s = be->chr; |
23673ca7 AL |
1025 | GSource *src; |
1026 | guint tag; | |
1027 | ||
777357d7 | 1028 | if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) { |
6f1de6b7 | 1029 | return 0; |
23673ca7 AL |
1030 | } |
1031 | ||
777357d7 | 1032 | src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond); |
62c339c5 | 1033 | if (!src) { |
6f1de6b7 | 1034 | return 0; |
62c339c5 PB |
1035 | } |
1036 | ||
23673ca7 AL |
1037 | g_source_set_callback(src, (GSourceFunc)func, user_data, NULL); |
1038 | tag = g_source_attach(src, NULL); | |
1039 | g_source_unref(src); | |
1040 | ||
1041 | return tag; | |
1042 | } | |
1043 | ||
5345fdb4 | 1044 | void qemu_chr_fe_disconnect(CharBackend *be) |
7d9d17f7 | 1045 | { |
0ec7b3e7 | 1046 | Chardev *chr = be->chr; |
5345fdb4 | 1047 | |
777357d7 MAL |
1048 | if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) { |
1049 | CHARDEV_GET_CLASS(chr)->chr_disconnect(chr); | |
7d9d17f7 TM |
1050 | } |
1051 | } | |
1052 | ||
6061162e | 1053 | static int qmp_query_chardev_foreach(Object *obj, void *data) |
1ad78ea5 | 1054 | { |
6061162e MAL |
1055 | Chardev *chr = CHARDEV(obj); |
1056 | ChardevInfoList **list = data; | |
1057 | ChardevInfoList *info = g_malloc0(sizeof(*info)); | |
1058 | ||
1059 | info->value = g_malloc0(sizeof(*info->value)); | |
1060 | info->value->label = g_strdup(chr->label); | |
1061 | info->value->filename = g_strdup(chr->filename); | |
1062 | info->value->frontend_open = chr->be && chr->be->fe_open; | |
1063 | ||
1064 | info->next = *list; | |
1065 | *list = info; | |
1066 | ||
1067 | return 0; | |
1ad78ea5 MAL |
1068 | } |
1069 | ||
c5a415a0 | 1070 | ChardevInfoList *qmp_query_chardev(Error **errp) |
6f97dba0 | 1071 | { |
c5a415a0 | 1072 | ChardevInfoList *chr_list = NULL; |
6f97dba0 | 1073 | |
6061162e MAL |
1074 | object_child_foreach(get_chardevs_root(), |
1075 | qmp_query_chardev_foreach, &chr_list); | |
588b3832 | 1076 | |
c5a415a0 | 1077 | return chr_list; |
6f97dba0 | 1078 | } |
c845f401 | 1079 | |
88cace9f MAL |
1080 | static void |
1081 | qmp_prepend_backend(const char *name, void *opaque) | |
0b812f31 | 1082 | { |
88cace9f | 1083 | ChardevBackendInfoList **list = opaque; |
0b812f31 | 1084 | ChardevBackendInfoList *info = g_malloc0(sizeof(*info)); |
88cace9f | 1085 | |
0b812f31 MAL |
1086 | info->value = g_malloc0(sizeof(*info->value)); |
1087 | info->value->name = g_strdup(name); | |
88cace9f MAL |
1088 | info->next = *list; |
1089 | *list = info; | |
0b812f31 MAL |
1090 | } |
1091 | ||
77d1c3c6 MK |
1092 | ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp) |
1093 | { | |
1094 | ChardevBackendInfoList *backend_list = NULL; | |
a1698bf1 | 1095 | |
88cace9f | 1096 | chardev_name_foreach(qmp_prepend_backend, &backend_list); |
77d1c3c6 MK |
1097 | |
1098 | return backend_list; | |
1099 | } | |
1100 | ||
0ec7b3e7 | 1101 | Chardev *qemu_chr_find(const char *name) |
c845f401 | 1102 | { |
6061162e | 1103 | Object *obj = object_resolve_path_component(get_chardevs_root(), name); |
c845f401 | 1104 | |
6061162e | 1105 | return obj ? CHARDEV(obj) : NULL; |
c845f401 | 1106 | } |
0beb4942 | 1107 | |
4d454574 PB |
1108 | QemuOptsList qemu_chardev_opts = { |
1109 | .name = "chardev", | |
1110 | .implied_opt_name = "backend", | |
1111 | .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), | |
1112 | .desc = { | |
1113 | { | |
1114 | .name = "backend", | |
1115 | .type = QEMU_OPT_STRING, | |
1116 | },{ | |
1117 | .name = "path", | |
1118 | .type = QEMU_OPT_STRING, | |
1119 | },{ | |
1120 | .name = "host", | |
1121 | .type = QEMU_OPT_STRING, | |
1122 | },{ | |
1123 | .name = "port", | |
1124 | .type = QEMU_OPT_STRING, | |
1125 | },{ | |
1126 | .name = "localaddr", | |
1127 | .type = QEMU_OPT_STRING, | |
1128 | },{ | |
1129 | .name = "localport", | |
1130 | .type = QEMU_OPT_STRING, | |
1131 | },{ | |
1132 | .name = "to", | |
1133 | .type = QEMU_OPT_NUMBER, | |
1134 | },{ | |
1135 | .name = "ipv4", | |
1136 | .type = QEMU_OPT_BOOL, | |
1137 | },{ | |
1138 | .name = "ipv6", | |
1139 | .type = QEMU_OPT_BOOL, | |
1140 | },{ | |
1141 | .name = "wait", | |
1142 | .type = QEMU_OPT_BOOL, | |
1143 | },{ | |
1144 | .name = "server", | |
1145 | .type = QEMU_OPT_BOOL, | |
1146 | },{ | |
1147 | .name = "delay", | |
1148 | .type = QEMU_OPT_BOOL, | |
5dd1f02b CM |
1149 | },{ |
1150 | .name = "reconnect", | |
1151 | .type = QEMU_OPT_NUMBER, | |
4d454574 PB |
1152 | },{ |
1153 | .name = "telnet", | |
1154 | .type = QEMU_OPT_BOOL, | |
ae92cbd5 JL |
1155 | },{ |
1156 | .name = "tn3270", | |
1157 | .type = QEMU_OPT_BOOL, | |
a8fb5427 DB |
1158 | },{ |
1159 | .name = "tls-creds", | |
1160 | .type = QEMU_OPT_STRING, | |
4d454574 PB |
1161 | },{ |
1162 | .name = "width", | |
1163 | .type = QEMU_OPT_NUMBER, | |
1164 | },{ | |
1165 | .name = "height", | |
1166 | .type = QEMU_OPT_NUMBER, | |
1167 | },{ | |
1168 | .name = "cols", | |
1169 | .type = QEMU_OPT_NUMBER, | |
1170 | },{ | |
1171 | .name = "rows", | |
1172 | .type = QEMU_OPT_NUMBER, | |
1173 | },{ | |
1174 | .name = "mux", | |
1175 | .type = QEMU_OPT_BOOL, | |
1176 | },{ | |
1177 | .name = "signal", | |
1178 | .type = QEMU_OPT_BOOL, | |
1179 | },{ | |
1180 | .name = "name", | |
1181 | .type = QEMU_OPT_STRING, | |
1182 | },{ | |
1183 | .name = "debug", | |
1184 | .type = QEMU_OPT_NUMBER, | |
51767e7c | 1185 | },{ |
3949e594 | 1186 | .name = "size", |
de1cc36e | 1187 | .type = QEMU_OPT_SIZE, |
bb6fb7c0 GH |
1188 | },{ |
1189 | .name = "chardev", | |
1190 | .type = QEMU_OPT_STRING, | |
31e38a22 OK |
1191 | },{ |
1192 | .name = "append", | |
1193 | .type = QEMU_OPT_BOOL, | |
d0d7708b DB |
1194 | },{ |
1195 | .name = "logfile", | |
1196 | .type = QEMU_OPT_STRING, | |
1197 | },{ | |
1198 | .name = "logappend", | |
1199 | .type = QEMU_OPT_BOOL, | |
4d454574 PB |
1200 | }, |
1201 | { /* end of list */ } | |
1202 | }, | |
1203 | }; | |
f1a1a356 | 1204 | |
0ec7b3e7 | 1205 | bool qemu_chr_has_feature(Chardev *chr, |
279b066e | 1206 | ChardevFeature feature) |
0a73336d DB |
1207 | { |
1208 | return test_bit(feature, chr->features); | |
1209 | } | |
1210 | ||
0ec7b3e7 | 1211 | void qemu_chr_set_feature(Chardev *chr, |
279b066e | 1212 | ChardevFeature feature) |
0a73336d DB |
1213 | { |
1214 | return set_bit(feature, chr->features); | |
1215 | } | |
1216 | ||
777357d7 | 1217 | Chardev *qemu_chardev_new(const char *id, const char *typename, |
2f5d45a1 MAL |
1218 | ChardevBackend *backend, |
1219 | Error **errp) | |
f1a1a356 | 1220 | { |
2f5d45a1 | 1221 | Object *obj; |
0ec7b3e7 | 1222 | Chardev *chr = NULL; |
eaeba653 | 1223 | Error *local_err = NULL; |
82878dac | 1224 | bool be_opened = true; |
f1a1a356 | 1225 | |
777357d7 | 1226 | assert(g_str_has_prefix(typename, "chardev-")); |
f1a1a356 | 1227 | |
2f5d45a1 MAL |
1228 | obj = object_new(typename); |
1229 | chr = CHARDEV(obj); | |
777357d7 | 1230 | chr->label = g_strdup(id); |
4ca17281 | 1231 | |
777357d7 | 1232 | qemu_char_open(chr, backend, &be_opened, &local_err); |
a1698bf1 | 1233 | if (local_err) { |
2f5d45a1 | 1234 | goto end; |
eaeba653 PB |
1235 | } |
1236 | ||
eaeba653 | 1237 | if (!chr->filename) { |
777357d7 | 1238 | chr->filename = g_strdup(typename + 8); |
f1a1a356 | 1239 | } |
82878dac | 1240 | if (be_opened) { |
eaeba653 PB |
1241 | qemu_chr_be_event(chr, CHR_EVENT_OPENED); |
1242 | } | |
777357d7 | 1243 | |
2f5d45a1 MAL |
1244 | if (id) { |
1245 | object_property_add_child(get_chardevs_root(), id, obj, &local_err); | |
1246 | if (local_err) { | |
1247 | goto end; | |
1248 | } | |
1249 | object_unref(obj); | |
1250 | } | |
1251 | ||
1252 | end: | |
1253 | if (local_err) { | |
1254 | error_propagate(errp, local_err); | |
1255 | object_unref(obj); | |
1256 | return NULL; | |
1257 | } | |
1258 | ||
777357d7 MAL |
1259 | return chr; |
1260 | } | |
1261 | ||
1262 | ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, | |
1263 | Error **errp) | |
1264 | { | |
1265 | const ChardevClass *cc; | |
1266 | ChardevReturn *ret; | |
1267 | Chardev *chr; | |
1268 | ||
777357d7 MAL |
1269 | cc = char_get_class(ChardevBackendKind_lookup[backend->type], errp); |
1270 | if (!cc) { | |
1271 | return NULL; | |
1272 | } | |
1273 | ||
c5749f7c | 1274 | chr = qemu_chardev_new(id, object_class_get_name(OBJECT_CLASS(cc)), |
777357d7 MAL |
1275 | backend, errp); |
1276 | if (!chr) { | |
1277 | return NULL; | |
1278 | } | |
1279 | ||
1280 | ret = g_new0(ChardevReturn, 1); | |
1281 | if (CHARDEV_IS_PTY(chr)) { | |
1282 | ret->pty = g_strdup(chr->filename + 4); | |
1283 | ret->has_pty = true; | |
1284 | } | |
1285 | ||
eaeba653 | 1286 | return ret; |
f1a1a356 GH |
1287 | } |
1288 | ||
1289 | void qmp_chardev_remove(const char *id, Error **errp) | |
1290 | { | |
0ec7b3e7 | 1291 | Chardev *chr; |
f1a1a356 GH |
1292 | |
1293 | chr = qemu_chr_find(id); | |
8108fd3e | 1294 | if (chr == NULL) { |
f1a1a356 GH |
1295 | error_setg(errp, "Chardev '%s' not found", id); |
1296 | return; | |
1297 | } | |
a4afa548 | 1298 | if (qemu_chr_is_busy(chr)) { |
f1a1a356 GH |
1299 | error_setg(errp, "Chardev '%s' is busy", id); |
1300 | return; | |
1301 | } | |
5ebd6703 | 1302 | if (qemu_chr_replay(chr)) { |
33577b47 PD |
1303 | error_setg(errp, |
1304 | "Chardev '%s' cannot be unplugged in record/replay mode", id); | |
1305 | return; | |
1306 | } | |
2f5d45a1 | 1307 | object_unparent(OBJECT(chr)); |
f1a1a356 | 1308 | } |
d654f34e | 1309 | |
aa5cb7f5 | 1310 | void qemu_chr_cleanup(void) |
c1111a24 | 1311 | { |
2f5d45a1 | 1312 | object_unparent(get_chardevs_root()); |
c1111a24 MAL |
1313 | } |
1314 | ||
d654f34e AL |
1315 | static void register_types(void) |
1316 | { | |
88cace9f | 1317 | type_register_static(&char_type_info); |
0b812f31 | 1318 | |
7b7ab18d MR |
1319 | /* this must be done after machine init, since we register FEs with muxes |
1320 | * as part of realize functions like serial_isa_realizefn when -nographic | |
1321 | * is specified | |
1322 | */ | |
1323 | qemu_add_machine_init_done_notifier(&muxes_realize_notify); | |
d654f34e AL |
1324 | } |
1325 | ||
1326 | type_init(register_types); |