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