Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20210330' into...
[qemu/ar7.git] / chardev / char-mux.c
blob72beef29d21c3bed1ffe6e48c7e75fe5db4a9da5
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  */
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"
34 /* MUX driver for serial I/O splitting */
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;
43 /* Called with chr_write_lock held.  */
44 static int mux_chr_write(Chardev *chr, const uint8_t *buf, int len)
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;
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;
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;
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
98 int term_escape_char = 0x01; /* ctrl-a is used for escape */
99 static void mux_print_help(Chardev *chr)
101     int i, j;
102     char ebuf[15] = "Escape-Char";
103     char cbuf[50] = "\n\r";
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     }
127 static void mux_chr_send_event(MuxChardev *d, int mux_nr, QEMUChrEvent event)
129     CharBackend *be = d->backends[mux_nr];
131     if (be && be->chr_event) {
132         be->chr_event(be->opaque, event);
133     }
136 static void mux_chr_be_event(Chardev *chr, QEMUChrEvent event)
138     MuxChardev *d = MUX_CHARDEV(chr);
140     if (d->focus != -1) {
141         mux_chr_send_event(d, d->focus, event);
142     }
145 static int mux_proc_byte(Chardev *chr, MuxChardev *d, int ch)
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;
190 static void mux_chr_accept_input(Chardev *chr)
192     MuxChardev *d = MUX_CHARDEV(chr);
193     int m = d->focus;
194     CharBackend *be = d->backends[m];
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     }
203 static int mux_chr_can_read(void *opaque)
205     MuxChardev *d = MUX_CHARDEV(opaque);
206     int m = d->focus;
207     CharBackend *be = d->backends[m];
209     if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE) {
210         return 1;
211     }
213     if (be && be->chr_can_read) {
214         return be->chr_can_read(be->opaque);
215     }
217     return 0;
220 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
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;
228     mux_chr_accept_input(opaque);
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         }
242 void mux_chr_send_all_event(Chardev *chr, QEMUChrEvent event)
244     MuxChardev *d = MUX_CHARDEV(chr);
245     int i;
247     if (!muxes_opened) {
248         return;
249     }
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     }
257 static void mux_chr_event(void *opaque, QEMUChrEvent event)
259     mux_chr_send_all_event(CHARDEV(opaque), event);
262 static GSource *mux_chr_add_watch(Chardev *s, GIOCondition cond)
264     MuxChardev *d = MUX_CHARDEV(s);
265     Chardev *chr = qemu_chr_fe_get_driver(&d->chr);
266     ChardevClass *cc = CHARDEV_GET_CLASS(chr);
268     if (!cc->chr_add_watch) {
269         return NULL;
270     }
272     return cc->chr_add_watch(chr, cond);
275 static void char_mux_finalize(Object *obj)
277     MuxChardev *d = MUX_CHARDEV(obj);
278     int i;
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);
289 static void mux_chr_update_read_handlers(Chardev *chr)
291     MuxChardev *d = MUX_CHARDEV(chr);
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);
303 void mux_set_focus(Chardev *chr, int focus)
305     MuxChardev *d = MUX_CHARDEV(chr);
307     assert(focus >= 0);
308     assert(focus < d->mux_cnt);
310     if (d->focus != -1) {
311         mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
312     }
314     d->focus = focus;
315     chr->be = d->backends[focus];
316     mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
319 static void qemu_chr_open_mux(Chardev *chr,
320                               ChardevBackend *backend,
321                               bool *be_opened,
322                               Error **errp)
324     ChardevMux *mux = backend->u.mux.data;
325     Chardev *drv;
326     MuxChardev *d = MUX_CHARDEV(chr);
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     }
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);
342 static void qemu_chr_parse_mux(QemuOpts *opts, ChardevBackend *backend,
343                                Error **errp)
345     const char *chardev = qemu_opt_get(opts, "chardev");
346     ChardevMux *mux;
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);
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.
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)
372     /* send OPENED to all already-attached FEs */
373     mux_chr_send_all_event(chr, CHR_EVENT_OPENED);
375     /*
376      * mark mux as OPENED so any new FEs will immediately receive
377      * OPENED event
378      */
379     chr->be_open = 1;
382 void suspend_mux_open(void)
384     muxes_opened = false;
387 static int chardev_options_parsed_cb(Object *child, void *opaque)
389     Chardev *chr = (Chardev *)child;
390     ChardevClass *class = CHARDEV_GET_CLASS(chr);
392     if (!chr->be_open && class->chr_options_parsed) {
393         class->chr_options_parsed(chr);
394     }
396     return 0;
399 void resume_mux_open(void)
401     muxes_opened = true;
402     object_child_foreach(get_chardevs_root(),
403                          chardev_options_parsed_cb, NULL);
406 static void char_mux_class_init(ObjectClass *oc, void *data)
408     ChardevClass *cc = CHARDEV_CLASS(oc);
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;
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,
428 static void register_types(void)
430     type_register_static(&char_mux_type_info);
433 type_init(register_types);