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