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