Merge remote-tracking branch 'remotes/stefanberger/tags/pull-tpm-2021-01-25-1' into...
[qemu.git] / chardev / char-mux.c
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 */
24
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/module.h"
28 #include "qemu/option.h"
29 #include "chardev/char.h"
30 #include "sysemu/block-backend.h"
31 #include "sysemu/sysemu.h"
32 #include "chardev-internal.h"
33
34 /* MUX driver for serial I/O splitting */
35
36 /*
37 * Set to false by suspend_mux_open. Open events are delayed until
38 * resume_mux_open. Usually suspend_mux_open is called before
39 * command line processing and resume_mux_open afterwards.
40 */
41 static bool muxes_opened = true;
42
43 /* Called with chr_write_lock held. */
44 static int mux_chr_write(Chardev *chr, const uint8_t *buf, int len)
45 {
46 MuxChardev *d = MUX_CHARDEV(chr);
47 int ret;
48 if (!d->timestamps) {
49 ret = qemu_chr_fe_write(&d->chr, buf, len);
50 } else {
51 int i;
52
53 ret = 0;
54 for (i = 0; i < len; i++) {
55 if (d->linestart) {
56 char buf1[64];
57 int64_t ti;
58 int secs;
59
60 ti = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
61 if (d->timestamps_start == -1) {
62 d->timestamps_start = ti;
63 }
64 ti -= d->timestamps_start;
65 secs = ti / 1000;
66 snprintf(buf1, sizeof(buf1),
67 "[%02d:%02d:%02d.%03d] ",
68 secs / 3600,
69 (secs / 60) % 60,
70 secs % 60,
71 (int)(ti % 1000));
72 /* XXX this blocks entire thread. Rewrite to use
73 * qemu_chr_fe_write and background I/O callbacks */
74 qemu_chr_fe_write_all(&d->chr,
75 (uint8_t *)buf1, strlen(buf1));
76 d->linestart = 0;
77 }
78 ret += qemu_chr_fe_write(&d->chr, buf + i, 1);
79 if (buf[i] == '\n') {
80 d->linestart = 1;
81 }
82 }
83 }
84 return ret;
85 }
86
87 static const char * const mux_help[] = {
88 "% h print this help\n\r",
89 "% x exit emulator\n\r",
90 "% s save disk data back to file (if -snapshot)\n\r",
91 "% t toggle console timestamps\n\r",
92 "% b send break (magic sysrq)\n\r",
93 "% c switch between console and monitor\n\r",
94 "% % sends %\n\r",
95 NULL
96 };
97
98 int term_escape_char = 0x01; /* ctrl-a is used for escape */
99 static void mux_print_help(Chardev *chr)
100 {
101 int i, j;
102 char ebuf[15] = "Escape-Char";
103 char cbuf[50] = "\n\r";
104
105 if (term_escape_char > 0 && term_escape_char < 26) {
106 snprintf(cbuf, sizeof(cbuf), "\n\r");
107 snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
108 } else {
109 snprintf(cbuf, sizeof(cbuf),
110 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
111 term_escape_char);
112 }
113 /* XXX this blocks entire thread. Rewrite to use
114 * qemu_chr_fe_write and background I/O callbacks */
115 qemu_chr_write_all(chr, (uint8_t *)cbuf, strlen(cbuf));
116 for (i = 0; mux_help[i] != NULL; i++) {
117 for (j = 0; mux_help[i][j] != '\0'; j++) {
118 if (mux_help[i][j] == '%') {
119 qemu_chr_write_all(chr, (uint8_t *)ebuf, strlen(ebuf));
120 } else {
121 qemu_chr_write_all(chr, (uint8_t *)&mux_help[i][j], 1);
122 }
123 }
124 }
125 }
126
127 static void mux_chr_send_event(MuxChardev *d, int mux_nr, QEMUChrEvent event)
128 {
129 CharBackend *be = d->backends[mux_nr];
130
131 if (be && be->chr_event) {
132 be->chr_event(be->opaque, event);
133 }
134 }
135
136 static void mux_chr_be_event(Chardev *chr, QEMUChrEvent event)
137 {
138 MuxChardev *d = MUX_CHARDEV(chr);
139
140 if (d->focus != -1) {
141 mux_chr_send_event(d, d->focus, event);
142 }
143 }
144
145 static int mux_proc_byte(Chardev *chr, MuxChardev *d, int ch)
146 {
147 if (d->term_got_escape) {
148 d->term_got_escape = 0;
149 if (ch == term_escape_char) {
150 goto send_char;
151 }
152 switch (ch) {
153 case '?':
154 case 'h':
155 mux_print_help(chr);
156 break;
157 case 'x':
158 {
159 const char *term = "QEMU: Terminated\n\r";
160 qemu_chr_write_all(chr, (uint8_t *)term, strlen(term));
161 exit(0);
162 break;
163 }
164 case 's':
165 blk_commit_all();
166 break;
167 case 'b':
168 qemu_chr_be_event(chr, CHR_EVENT_BREAK);
169 break;
170 case 'c':
171 assert(d->mux_cnt > 0); /* handler registered with first fe */
172 /* Switch to the next registered device */
173 mux_set_focus(chr, (d->focus + 1) % d->mux_cnt);
174 break;
175 case 't':
176 d->timestamps = !d->timestamps;
177 d->timestamps_start = -1;
178 d->linestart = 0;
179 break;
180 }
181 } else if (ch == term_escape_char) {
182 d->term_got_escape = 1;
183 } else {
184 send_char:
185 return 1;
186 }
187 return 0;
188 }
189
190 static void mux_chr_accept_input(Chardev *chr)
191 {
192 MuxChardev *d = MUX_CHARDEV(chr);
193 int m = d->focus;
194 CharBackend *be = d->backends[m];
195
196 while (be && d->prod[m] != d->cons[m] &&
197 be->chr_can_read && be->chr_can_read(be->opaque)) {
198 be->chr_read(be->opaque,
199 &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
200 }
201 }
202
203 static int mux_chr_can_read(void *opaque)
204 {
205 MuxChardev *d = MUX_CHARDEV(opaque);
206 int m = d->focus;
207 CharBackend *be = d->backends[m];
208
209 if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE) {
210 return 1;
211 }
212
213 if (be && be->chr_can_read) {
214 return be->chr_can_read(be->opaque);
215 }
216
217 return 0;
218 }
219
220 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
221 {
222 Chardev *chr = CHARDEV(opaque);
223 MuxChardev *d = MUX_CHARDEV(opaque);
224 int m = d->focus;
225 CharBackend *be = d->backends[m];
226 int i;
227
228 mux_chr_accept_input(opaque);
229
230 for (i = 0; i < size; i++)
231 if (mux_proc_byte(chr, d, buf[i])) {
232 if (d->prod[m] == d->cons[m] &&
233 be && be->chr_can_read &&
234 be->chr_can_read(be->opaque)) {
235 be->chr_read(be->opaque, &buf[i], 1);
236 } else {
237 d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
238 }
239 }
240 }
241
242 void mux_chr_send_all_event(Chardev *chr, QEMUChrEvent event)
243 {
244 MuxChardev *d = MUX_CHARDEV(chr);
245 int i;
246
247 if (!muxes_opened) {
248 return;
249 }
250
251 /* Send the event to all registered listeners */
252 for (i = 0; i < d->mux_cnt; i++) {
253 mux_chr_send_event(d, i, event);
254 }
255 }
256
257 static void mux_chr_event(void *opaque, QEMUChrEvent event)
258 {
259 mux_chr_send_all_event(CHARDEV(opaque), event);
260 }
261
262 static GSource *mux_chr_add_watch(Chardev *s, GIOCondition cond)
263 {
264 MuxChardev *d = MUX_CHARDEV(s);
265 Chardev *chr = qemu_chr_fe_get_driver(&d->chr);
266 ChardevClass *cc = CHARDEV_GET_CLASS(chr);
267
268 if (!cc->chr_add_watch) {
269 return NULL;
270 }
271
272 return cc->chr_add_watch(chr, cond);
273 }
274
275 static void char_mux_finalize(Object *obj)
276 {
277 MuxChardev *d = MUX_CHARDEV(obj);
278 int i;
279
280 for (i = 0; i < d->mux_cnt; i++) {
281 CharBackend *be = d->backends[i];
282 if (be) {
283 be->chr = NULL;
284 }
285 }
286 qemu_chr_fe_deinit(&d->chr, false);
287 }
288
289 static void mux_chr_update_read_handlers(Chardev *chr)
290 {
291 MuxChardev *d = MUX_CHARDEV(chr);
292
293 /* Fix up the real driver with mux routines */
294 qemu_chr_fe_set_handlers_full(&d->chr,
295 mux_chr_can_read,
296 mux_chr_read,
297 mux_chr_event,
298 NULL,
299 chr,
300 chr->gcontext, true, false);
301 }
302
303 void mux_set_focus(Chardev *chr, int focus)
304 {
305 MuxChardev *d = MUX_CHARDEV(chr);
306
307 assert(focus >= 0);
308 assert(focus < d->mux_cnt);
309
310 if (d->focus != -1) {
311 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
312 }
313
314 d->focus = focus;
315 chr->be = d->backends[focus];
316 mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
317 }
318
319 static void qemu_chr_open_mux(Chardev *chr,
320 ChardevBackend *backend,
321 bool *be_opened,
322 Error **errp)
323 {
324 ChardevMux *mux = backend->u.mux.data;
325 Chardev *drv;
326 MuxChardev *d = MUX_CHARDEV(chr);
327
328 drv = qemu_chr_find(mux->chardev);
329 if (drv == NULL) {
330 error_setg(errp, "mux: base chardev %s not found", mux->chardev);
331 return;
332 }
333
334 d->focus = -1;
335 /* only default to opened state if we've realized the initial
336 * set of muxes
337 */
338 *be_opened = muxes_opened;
339 qemu_chr_fe_init(&d->chr, drv, errp);
340 }
341
342 static void qemu_chr_parse_mux(QemuOpts *opts, ChardevBackend *backend,
343 Error **errp)
344 {
345 const char *chardev = qemu_opt_get(opts, "chardev");
346 ChardevMux *mux;
347
348 if (chardev == NULL) {
349 error_setg(errp, "chardev: mux: no chardev given");
350 return;
351 }
352 backend->type = CHARDEV_BACKEND_KIND_MUX;
353 mux = backend->u.mux.data = g_new0(ChardevMux, 1);
354 qemu_chr_parse_common(opts, qapi_ChardevMux_base(mux));
355 mux->chardev = g_strdup(chardev);
356 }
357
358 /**
359 * Called after processing of default and command-line-specified
360 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
361 * to a mux chardev. This is done here to ensure that
362 * output/prompts/banners are only displayed for the FE that has
363 * focus when initial command-line processing/machine init is
364 * completed.
365 *
366 * After this point, any new FE attached to any new or existing
367 * mux will receive CHR_EVENT_OPENED notifications for the BE
368 * immediately.
369 */
370 static void open_muxes(Chardev *chr)
371 {
372 /* send OPENED to all already-attached FEs */
373 mux_chr_send_all_event(chr, CHR_EVENT_OPENED);
374
375 /*
376 * mark mux as OPENED so any new FEs will immediately receive
377 * OPENED event
378 */
379 chr->be_open = 1;
380 }
381
382 void suspend_mux_open(void)
383 {
384 muxes_opened = false;
385 }
386
387 static int chardev_options_parsed_cb(Object *child, void *opaque)
388 {
389 Chardev *chr = (Chardev *)child;
390 ChardevClass *class = CHARDEV_GET_CLASS(chr);
391
392 if (!chr->be_open && class->chr_options_parsed) {
393 class->chr_options_parsed(chr);
394 }
395
396 return 0;
397 }
398
399 void resume_mux_open(void)
400 {
401 muxes_opened = true;
402 object_child_foreach(get_chardevs_root(),
403 chardev_options_parsed_cb, NULL);
404 }
405
406 static void char_mux_class_init(ObjectClass *oc, void *data)
407 {
408 ChardevClass *cc = CHARDEV_CLASS(oc);
409
410 cc->parse = qemu_chr_parse_mux;
411 cc->open = qemu_chr_open_mux;
412 cc->chr_write = mux_chr_write;
413 cc->chr_accept_input = mux_chr_accept_input;
414 cc->chr_add_watch = mux_chr_add_watch;
415 cc->chr_be_event = mux_chr_be_event;
416 cc->chr_options_parsed = open_muxes;
417 cc->chr_update_read_handler = mux_chr_update_read_handlers;
418 }
419
420 static const TypeInfo char_mux_type_info = {
421 .name = TYPE_CHARDEV_MUX,
422 .parent = TYPE_CHARDEV,
423 .class_init = char_mux_class_init,
424 .instance_size = sizeof(MuxChardev),
425 .instance_finalize = char_mux_finalize,
426 };
427
428 static void register_types(void)
429 {
430 type_register_static(&char_mux_type_info);
431 }
432
433 type_init(register_types);