1 /* 2 * QEMU graphical console 3 * 4 * Copyright (c) 2004 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 "ui/console.h" 27 #include "hw/qdev-core.h" 28 #include "qapi/error.h" 29 #include "qapi/qapi-commands-ui.h" 30 #include "qemu/coroutine.h" 31 #include "qemu/error-report.h" 32 #include "qemu/fifo8.h" 33 #include "qemu/main-loop.h" 34 #include "qemu/module.h" 35 #include "qemu/option.h" 36 #include "qemu/timer.h" 37 #include "chardev/char.h" 38 #include "trace.h" 39 #include "exec/memory.h" 40 #include "io/channel-file.h" 41 #include "qom/object.h" 42 #ifdef CONFIG_PNG 43 #include <png.h> 44 #endif 45 46 #define DEFAULT_BACKSCROLL 512 47 #define CONSOLE_CURSOR_PERIOD 500 48 49 typedef struct TextAttributes { 50 uint8_t fgcol:4; 51 uint8_t bgcol:4; 52 uint8_t bold:1; 53 uint8_t uline:1; 54 uint8_t blink:1; 55 uint8_t invers:1; 56 uint8_t unvisible:1; 57 } TextAttributes; 58 59 typedef struct TextCell { 60 uint8_t ch; 61 TextAttributes t_attrib; 62 } TextCell; 63 64 #define MAX_ESC_PARAMS 3 65 66 enum TTYState { 67 TTY_STATE_NORM, 68 TTY_STATE_ESC, 69 TTY_STATE_CSI, 70 }; 71 72 typedef enum { 73 GRAPHIC_CONSOLE, 74 TEXT_CONSOLE, 75 TEXT_CONSOLE_FIXED_SIZE 76 } console_type_t; 77 78 struct QemuConsole { 79 Object parent; 80 81 int index; 82 console_type_t console_type; 83 DisplayState *ds; 84 DisplaySurface *surface; 85 DisplayScanout scanout; 86 int dcls; 87 DisplayGLCtx *gl; 88 int gl_block; 89 QEMUTimer *gl_unblock_timer; 90 int window_id; 91 92 /* Graphic console state. */ 93 Object *device; 94 uint32_t head; 95 QemuUIInfo ui_info; 96 QEMUTimer *ui_timer; 97 QEMUCursor *cursor; 98 int cursor_x, cursor_y, cursor_on; 99 const GraphicHwOps *hw_ops; 100 void *hw; 101 102 /* Text console state */ 103 int width; 104 int height; 105 int total_height; 106 int backscroll_height; 107 int x, y; 108 int x_saved, y_saved; 109 int y_displayed; 110 int y_base; 111 TextAttributes t_attrib_default; /* default text attributes */ 112 TextAttributes t_attrib; /* currently active text attributes */ 113 TextCell *cells; 114 int text_x[2], text_y[2], cursor_invalidate; 115 int echo; 116 117 int update_x0; 118 int update_y0; 119 int update_x1; 120 int update_y1; 121 122 enum TTYState state; 123 int esc_params[MAX_ESC_PARAMS]; 124 int nb_esc_params; 125 126 Chardev *chr; 127 /* fifo for key pressed */ 128 Fifo8 out_fifo; 129 CoQueue dump_queue; 130 131 QTAILQ_ENTRY(QemuConsole) next; 132 }; 133 134 struct DisplayState { 135 QEMUTimer *gui_timer; 136 uint64_t last_update; 137 uint64_t update_interval; 138 bool refreshing; 139 bool have_gfx; 140 bool have_text; 141 142 QLIST_HEAD(, DisplayChangeListener) listeners; 143 }; 144 145 static DisplayState *display_state; 146 static QemuConsole *active_console; 147 static QTAILQ_HEAD(, QemuConsole) consoles = 148 QTAILQ_HEAD_INITIALIZER(consoles); 149 static bool cursor_visible_phase; 150 static QEMUTimer *cursor_timer; 151 152 static void text_console_do_init(Chardev *chr, DisplayState *ds); 153 static void dpy_refresh(DisplayState *s); 154 static DisplayState *get_alloc_displaystate(void); 155 static void text_console_update_cursor_timer(void); 156 static void text_console_update_cursor(void *opaque); 157 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl); 158 static bool console_compatible_with(QemuConsole *con, 159 DisplayChangeListener *dcl, Error **errp); 160 161 static void gui_update(void *opaque) 162 { 163 uint64_t interval = GUI_REFRESH_INTERVAL_IDLE; 164 uint64_t dcl_interval; 165 DisplayState *ds = opaque; 166 DisplayChangeListener *dcl; 167 168 ds->refreshing = true; 169 dpy_refresh(ds); 170 ds->refreshing = false; 171 172 QLIST_FOREACH(dcl, &ds->listeners, next) { 173 dcl_interval = dcl->update_interval ? 174 dcl->update_interval : GUI_REFRESH_INTERVAL_DEFAULT; 175 if (interval > dcl_interval) { 176 interval = dcl_interval; 177 } 178 } 179 if (ds->update_interval != interval) { 180 ds->update_interval = interval; 181 trace_console_refresh(interval); 182 } 183 ds->last_update = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 184 timer_mod(ds->gui_timer, ds->last_update + interval); 185 } 186 187 static void gui_setup_refresh(DisplayState *ds) 188 { 189 DisplayChangeListener *dcl; 190 bool need_timer = false; 191 bool have_gfx = false; 192 bool have_text = false; 193 194 QLIST_FOREACH(dcl, &ds->listeners, next) { 195 if (dcl->ops->dpy_refresh != NULL) { 196 need_timer = true; 197 } 198 if (dcl->ops->dpy_gfx_update != NULL) { 199 have_gfx = true; 200 } 201 if (dcl->ops->dpy_text_update != NULL) { 202 have_text = true; 203 } 204 } 205 206 if (need_timer && ds->gui_timer == NULL) { 207 ds->gui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, gui_update, ds); 208 timer_mod(ds->gui_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); 209 } 210 if (!need_timer && ds->gui_timer != NULL) { 211 timer_free(ds->gui_timer); 212 ds->gui_timer = NULL; 213 } 214 215 ds->have_gfx = have_gfx; 216 ds->have_text = have_text; 217 } 218 219 void graphic_hw_update_done(QemuConsole *con) 220 { 221 if (con) { 222 qemu_co_enter_all(&con->dump_queue, NULL); 223 } 224 } 225 226 void graphic_hw_update(QemuConsole *con) 227 { 228 bool async = false; 229 con = con ? con : active_console; 230 if (!con) { 231 return; 232 } 233 if (con->hw_ops->gfx_update) { 234 con->hw_ops->gfx_update(con->hw); 235 async = con->hw_ops->gfx_update_async; 236 } 237 if (!async) { 238 graphic_hw_update_done(con); 239 } 240 } 241 242 static void graphic_hw_gl_unblock_timer(void *opaque) 243 { 244 warn_report("console: no gl-unblock within one second"); 245 } 246 247 void graphic_hw_gl_block(QemuConsole *con, bool block) 248 { 249 uint64_t timeout; 250 assert(con != NULL); 251 252 if (block) { 253 con->gl_block++; 254 } else { 255 con->gl_block--; 256 } 257 assert(con->gl_block >= 0); 258 if (!con->hw_ops->gl_block) { 259 return; 260 } 261 if ((block && con->gl_block != 1) || (!block && con->gl_block != 0)) { 262 return; 263 } 264 con->hw_ops->gl_block(con->hw, block); 265 266 if (block) { 267 timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 268 timeout += 1000; /* one sec */ 269 timer_mod(con->gl_unblock_timer, timeout); 270 } else { 271 timer_del(con->gl_unblock_timer); 272 } 273 } 274 275 int qemu_console_get_window_id(QemuConsole *con) 276 { 277 return con->window_id; 278 } 279 280 void qemu_console_set_window_id(QemuConsole *con, int window_id) 281 { 282 con->window_id = window_id; 283 } 284 285 void graphic_hw_invalidate(QemuConsole *con) 286 { 287 if (!con) { 288 con = active_console; 289 } 290 if (con && con->hw_ops->invalidate) { 291 con->hw_ops->invalidate(con->hw); 292 } 293 } 294 295 #ifdef CONFIG_PNG 296 /** 297 * png_save: Take a screenshot as PNG 298 * 299 * Saves screendump as a PNG file 300 * 301 * Returns true for success or false for error. 302 * 303 * @fd: File descriptor for PNG file. 304 * @image: Image data in pixman format. 305 * @errp: Pointer to an error. 306 */ 307 static bool png_save(int fd, pixman_image_t *image, Error **errp) 308 { 309 int width = pixman_image_get_width(image); 310 int height = pixman_image_get_height(image); 311 png_struct *png_ptr; 312 png_info *info_ptr; 313 g_autoptr(pixman_image_t) linebuf = 314 qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8, width); 315 uint8_t *buf = (uint8_t *)pixman_image_get_data(linebuf); 316 FILE *f = fdopen(fd, "wb"); 317 int y; 318 if (!f) { 319 error_setg_errno(errp, errno, 320 "Failed to create file from file descriptor"); 321 return false; 322 } 323 324 png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, 325 NULL, NULL); 326 if (!png_ptr) { 327 error_setg(errp, "PNG creation failed. Unable to write struct"); 328 fclose(f); 329 return false; 330 } 331 332 info_ptr = png_create_info_struct(png_ptr); 333 334 if (!info_ptr) { 335 error_setg(errp, "PNG creation failed. Unable to write info"); 336 fclose(f); 337 png_destroy_write_struct(&png_ptr, &info_ptr); 338 return false; 339 } 340 341 png_init_io(png_ptr, f); 342 343 png_set_IHDR(png_ptr, info_ptr, width, height, 8, 344 PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, 345 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); 346 347 png_write_info(png_ptr, info_ptr); 348 349 for (y = 0; y < height; ++y) { 350 qemu_pixman_linebuf_fill(linebuf, image, width, 0, y); 351 png_write_row(png_ptr, buf); 352 } 353 354 png_write_end(png_ptr, NULL); 355 356 png_destroy_write_struct(&png_ptr, &info_ptr); 357 358 if (fclose(f) != 0) { 359 error_setg_errno(errp, errno, 360 "PNG creation failed. Unable to close file"); 361 return false; 362 } 363 364 return true; 365 } 366 367 #else /* no png support */ 368 369 static bool png_save(int fd, pixman_image_t *image, Error **errp) 370 { 371 error_setg(errp, "Enable PNG support with libpng for screendump"); 372 return false; 373 } 374 375 #endif /* CONFIG_PNG */ 376 377 static bool ppm_save(int fd, pixman_image_t *image, Error **errp) 378 { 379 int width = pixman_image_get_width(image); 380 int height = pixman_image_get_height(image); 381 g_autoptr(Object) ioc = OBJECT(qio_channel_file_new_fd(fd)); 382 g_autofree char *header = NULL; 383 g_autoptr(pixman_image_t) linebuf = NULL; 384 int y; 385 386 trace_ppm_save(fd, image); 387 388 header = g_strdup_printf("P6\n%d %d\n%d\n", width, height, 255); 389 if (qio_channel_write_all(QIO_CHANNEL(ioc), 390 header, strlen(header), errp) < 0) { 391 return false; 392 } 393 394 linebuf = qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8, width); 395 for (y = 0; y < height; y++) { 396 qemu_pixman_linebuf_fill(linebuf, image, width, 0, y); 397 if (qio_channel_write_all(QIO_CHANNEL(ioc), 398 (char *)pixman_image_get_data(linebuf), 399 pixman_image_get_stride(linebuf), errp) < 0) { 400 return false; 401 } 402 } 403 404 return true; 405 } 406 407 static void graphic_hw_update_bh(void *con) 408 { 409 graphic_hw_update(con); 410 } 411 412 /* Safety: coroutine-only, concurrent-coroutine safe, main thread only */ 413 void coroutine_fn 414 qmp_screendump(const char *filename, const char *device, 415 bool has_head, int64_t head, 416 bool has_format, ImageFormat format, Error **errp) 417 { 418 g_autoptr(pixman_image_t) image = NULL; 419 QemuConsole *con; 420 DisplaySurface *surface; 421 int fd; 422 423 if (device) { 424 con = qemu_console_lookup_by_device_name(device, has_head ? head : 0, 425 errp); 426 if (!con) { 427 return; 428 } 429 } else { 430 if (has_head) { 431 error_setg(errp, "'head' must be specified together with 'device'"); 432 return; 433 } 434 con = qemu_console_lookup_by_index(0); 435 if (!con) { 436 error_setg(errp, "There is no console to take a screendump from"); 437 return; 438 } 439 } 440 441 if (qemu_co_queue_empty(&con->dump_queue)) { 442 /* Defer the update, it will restart the pending coroutines */ 443 aio_bh_schedule_oneshot(qemu_get_aio_context(), 444 graphic_hw_update_bh, con); 445 } 446 qemu_co_queue_wait(&con->dump_queue, NULL); 447 448 /* 449 * All pending coroutines are woken up, while the BQL is held. No 450 * further graphic update are possible until it is released. Take 451 * an image ref before that. 452 */ 453 surface = qemu_console_surface(con); 454 if (!surface) { 455 error_setg(errp, "no surface"); 456 return; 457 } 458 image = pixman_image_ref(surface->image); 459 460 fd = qemu_open_old(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666); 461 if (fd == -1) { 462 error_setg(errp, "failed to open file '%s': %s", filename, 463 strerror(errno)); 464 return; 465 } 466 467 /* 468 * The image content could potentially be updated as the coroutine 469 * yields and releases the BQL. It could produce corrupted dump, but 470 * it should be otherwise safe. 471 */ 472 if (has_format && format == IMAGE_FORMAT_PNG) { 473 /* PNG format specified for screendump */ 474 if (!png_save(fd, image, errp)) { 475 qemu_unlink(filename); 476 } 477 } else { 478 /* PPM format specified/default for screendump */ 479 if (!ppm_save(fd, image, errp)) { 480 qemu_unlink(filename); 481 } 482 } 483 } 484 485 void graphic_hw_text_update(QemuConsole *con, console_ch_t *chardata) 486 { 487 if (!con) { 488 con = active_console; 489 } 490 if (con && con->hw_ops->text_update) { 491 con->hw_ops->text_update(con->hw, chardata); 492 } 493 } 494 495 static void vga_fill_rect(QemuConsole *con, 496 int posx, int posy, int width, int height, 497 pixman_color_t color) 498 { 499 DisplaySurface *surface = qemu_console_surface(con); 500 pixman_rectangle16_t rect = { 501 .x = posx, .y = posy, .width = width, .height = height 502 }; 503 504 pixman_image_fill_rectangles(PIXMAN_OP_SRC, surface->image, 505 &color, 1, &rect); 506 } 507 508 /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */ 509 static void vga_bitblt(QemuConsole *con, 510 int xs, int ys, int xd, int yd, int w, int h) 511 { 512 DisplaySurface *surface = qemu_console_surface(con); 513 514 pixman_image_composite(PIXMAN_OP_SRC, 515 surface->image, NULL, surface->image, 516 xs, ys, 0, 0, xd, yd, w, h); 517 } 518 519 /***********************************************************/ 520 /* basic char display */ 521 522 #define FONT_HEIGHT 16 523 #define FONT_WIDTH 8 524 525 #include "vgafont.h" 526 527 #define QEMU_RGB(r, g, b) \ 528 { .red = r << 8, .green = g << 8, .blue = b << 8, .alpha = 0xffff } 529 530 static const pixman_color_t color_table_rgb[2][8] = { 531 { /* dark */ 532 [QEMU_COLOR_BLACK] = QEMU_RGB(0x00, 0x00, 0x00), /* black */ 533 [QEMU_COLOR_BLUE] = QEMU_RGB(0x00, 0x00, 0xaa), /* blue */ 534 [QEMU_COLOR_GREEN] = QEMU_RGB(0x00, 0xaa, 0x00), /* green */ 535 [QEMU_COLOR_CYAN] = QEMU_RGB(0x00, 0xaa, 0xaa), /* cyan */ 536 [QEMU_COLOR_RED] = QEMU_RGB(0xaa, 0x00, 0x00), /* red */ 537 [QEMU_COLOR_MAGENTA] = QEMU_RGB(0xaa, 0x00, 0xaa), /* magenta */ 538 [QEMU_COLOR_YELLOW] = QEMU_RGB(0xaa, 0xaa, 0x00), /* yellow */ 539 [QEMU_COLOR_WHITE] = QEMU_RGB(0xaa, 0xaa, 0xaa), /* white */ 540 }, 541 { /* bright */ 542 [QEMU_COLOR_BLACK] = QEMU_RGB(0x00, 0x00, 0x00), /* black */ 543 [QEMU_COLOR_BLUE] = QEMU_RGB(0x00, 0x00, 0xff), /* blue */ 544 [QEMU_COLOR_GREEN] = QEMU_RGB(0x00, 0xff, 0x00), /* green */ 545 [QEMU_COLOR_CYAN] = QEMU_RGB(0x00, 0xff, 0xff), /* cyan */ 546 [QEMU_COLOR_RED] = QEMU_RGB(0xff, 0x00, 0x00), /* red */ 547 [QEMU_COLOR_MAGENTA] = QEMU_RGB(0xff, 0x00, 0xff), /* magenta */ 548 [QEMU_COLOR_YELLOW] = QEMU_RGB(0xff, 0xff, 0x00), /* yellow */ 549 [QEMU_COLOR_WHITE] = QEMU_RGB(0xff, 0xff, 0xff), /* white */ 550 } 551 }; 552 553 static void vga_putcharxy(QemuConsole *s, int x, int y, int ch, 554 TextAttributes *t_attrib) 555 { 556 static pixman_image_t *glyphs[256]; 557 DisplaySurface *surface = qemu_console_surface(s); 558 pixman_color_t fgcol, bgcol; 559 560 if (t_attrib->invers) { 561 bgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol]; 562 fgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol]; 563 } else { 564 fgcol = color_table_rgb[t_attrib->bold][t_attrib->fgcol]; 565 bgcol = color_table_rgb[t_attrib->bold][t_attrib->bgcol]; 566 } 567 568 if (!glyphs[ch]) { 569 glyphs[ch] = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, ch); 570 } 571 qemu_pixman_glyph_render(glyphs[ch], surface->image, 572 &fgcol, &bgcol, x, y, FONT_WIDTH, FONT_HEIGHT); 573 } 574 575 static void text_console_resize(QemuConsole *s) 576 { 577 TextCell *cells, *c, *c1; 578 int w1, x, y, last_width; 579 580 assert(s->scanout.kind == SCANOUT_SURFACE); 581 582 last_width = s->width; 583 s->width = surface_width(s->surface) / FONT_WIDTH; 584 s->height = surface_height(s->surface) / FONT_HEIGHT; 585 586 w1 = last_width; 587 if (s->width < w1) 588 w1 = s->width; 589 590 cells = g_new(TextCell, s->width * s->total_height + 1); 591 for(y = 0; y < s->total_height; y++) { 592 c = &cells[y * s->width]; 593 if (w1 > 0) { 594 c1 = &s->cells[y * last_width]; 595 for(x = 0; x < w1; x++) { 596 *c++ = *c1++; 597 } 598 } 599 for(x = w1; x < s->width; x++) { 600 c->ch = ' '; 601 c->t_attrib = s->t_attrib_default; 602 c++; 603 } 604 } 605 g_free(s->cells); 606 s->cells = cells; 607 } 608 609 static inline void text_update_xy(QemuConsole *s, int x, int y) 610 { 611 s->text_x[0] = MIN(s->text_x[0], x); 612 s->text_x[1] = MAX(s->text_x[1], x); 613 s->text_y[0] = MIN(s->text_y[0], y); 614 s->text_y[1] = MAX(s->text_y[1], y); 615 } 616 617 static void invalidate_xy(QemuConsole *s, int x, int y) 618 { 619 if (!qemu_console_is_visible(s)) { 620 return; 621 } 622 if (s->update_x0 > x * FONT_WIDTH) 623 s->update_x0 = x * FONT_WIDTH; 624 if (s->update_y0 > y * FONT_HEIGHT) 625 s->update_y0 = y * FONT_HEIGHT; 626 if (s->update_x1 < (x + 1) * FONT_WIDTH) 627 s->update_x1 = (x + 1) * FONT_WIDTH; 628 if (s->update_y1 < (y + 1) * FONT_HEIGHT) 629 s->update_y1 = (y + 1) * FONT_HEIGHT; 630 } 631 632 static void update_xy(QemuConsole *s, int x, int y) 633 { 634 TextCell *c; 635 int y1, y2; 636 637 if (s->ds->have_text) { 638 text_update_xy(s, x, y); 639 } 640 641 y1 = (s->y_base + y) % s->total_height; 642 y2 = y1 - s->y_displayed; 643 if (y2 < 0) { 644 y2 += s->total_height; 645 } 646 if (y2 < s->height) { 647 if (x >= s->width) { 648 x = s->width - 1; 649 } 650 c = &s->cells[y1 * s->width + x]; 651 vga_putcharxy(s, x, y2, c->ch, 652 &(c->t_attrib)); 653 invalidate_xy(s, x, y2); 654 } 655 } 656 657 static void console_show_cursor(QemuConsole *s, int show) 658 { 659 TextCell *c; 660 int y, y1; 661 int x = s->x; 662 663 if (s->ds->have_text) { 664 s->cursor_invalidate = 1; 665 } 666 667 if (x >= s->width) { 668 x = s->width - 1; 669 } 670 y1 = (s->y_base + s->y) % s->total_height; 671 y = y1 - s->y_displayed; 672 if (y < 0) { 673 y += s->total_height; 674 } 675 if (y < s->height) { 676 c = &s->cells[y1 * s->width + x]; 677 if (show && cursor_visible_phase) { 678 TextAttributes t_attrib = s->t_attrib_default; 679 t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */ 680 vga_putcharxy(s, x, y, c->ch, &t_attrib); 681 } else { 682 vga_putcharxy(s, x, y, c->ch, &(c->t_attrib)); 683 } 684 invalidate_xy(s, x, y); 685 } 686 } 687 688 static void console_refresh(QemuConsole *s) 689 { 690 DisplaySurface *surface = qemu_console_surface(s); 691 TextCell *c; 692 int x, y, y1; 693 694 if (s->ds->have_text) { 695 s->text_x[0] = 0; 696 s->text_y[0] = 0; 697 s->text_x[1] = s->width - 1; 698 s->text_y[1] = s->height - 1; 699 s->cursor_invalidate = 1; 700 } 701 702 vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface), 703 color_table_rgb[0][QEMU_COLOR_BLACK]); 704 y1 = s->y_displayed; 705 for (y = 0; y < s->height; y++) { 706 c = s->cells + y1 * s->width; 707 for (x = 0; x < s->width; x++) { 708 vga_putcharxy(s, x, y, c->ch, 709 &(c->t_attrib)); 710 c++; 711 } 712 if (++y1 == s->total_height) { 713 y1 = 0; 714 } 715 } 716 console_show_cursor(s, 1); 717 dpy_gfx_update(s, 0, 0, 718 surface_width(surface), surface_height(surface)); 719 } 720 721 static void console_scroll(QemuConsole *s, int ydelta) 722 { 723 int i, y1; 724 725 if (ydelta > 0) { 726 for(i = 0; i < ydelta; i++) { 727 if (s->y_displayed == s->y_base) 728 break; 729 if (++s->y_displayed == s->total_height) 730 s->y_displayed = 0; 731 } 732 } else { 733 ydelta = -ydelta; 734 i = s->backscroll_height; 735 if (i > s->total_height - s->height) 736 i = s->total_height - s->height; 737 y1 = s->y_base - i; 738 if (y1 < 0) 739 y1 += s->total_height; 740 for(i = 0; i < ydelta; i++) { 741 if (s->y_displayed == y1) 742 break; 743 if (--s->y_displayed < 0) 744 s->y_displayed = s->total_height - 1; 745 } 746 } 747 console_refresh(s); 748 } 749 750 static void console_put_lf(QemuConsole *s) 751 { 752 TextCell *c; 753 int x, y1; 754 755 s->y++; 756 if (s->y >= s->height) { 757 s->y = s->height - 1; 758 759 if (s->y_displayed == s->y_base) { 760 if (++s->y_displayed == s->total_height) 761 s->y_displayed = 0; 762 } 763 if (++s->y_base == s->total_height) 764 s->y_base = 0; 765 if (s->backscroll_height < s->total_height) 766 s->backscroll_height++; 767 y1 = (s->y_base + s->height - 1) % s->total_height; 768 c = &s->cells[y1 * s->width]; 769 for(x = 0; x < s->width; x++) { 770 c->ch = ' '; 771 c->t_attrib = s->t_attrib_default; 772 c++; 773 } 774 if (s->y_displayed == s->y_base) { 775 if (s->ds->have_text) { 776 s->text_x[0] = 0; 777 s->text_y[0] = 0; 778 s->text_x[1] = s->width - 1; 779 s->text_y[1] = s->height - 1; 780 } 781 782 vga_bitblt(s, 0, FONT_HEIGHT, 0, 0, 783 s->width * FONT_WIDTH, 784 (s->height - 1) * FONT_HEIGHT); 785 vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT, 786 s->width * FONT_WIDTH, FONT_HEIGHT, 787 color_table_rgb[0][s->t_attrib_default.bgcol]); 788 s->update_x0 = 0; 789 s->update_y0 = 0; 790 s->update_x1 = s->width * FONT_WIDTH; 791 s->update_y1 = s->height * FONT_HEIGHT; 792 } 793 } 794 } 795 796 /* Set console attributes depending on the current escape codes. 797 * NOTE: I know this code is not very efficient (checking every color for it 798 * self) but it is more readable and better maintainable. 799 */ 800 static void console_handle_escape(QemuConsole *s) 801 { 802 int i; 803 804 for (i=0; i<s->nb_esc_params; i++) { 805 switch (s->esc_params[i]) { 806 case 0: /* reset all console attributes to default */ 807 s->t_attrib = s->t_attrib_default; 808 break; 809 case 1: 810 s->t_attrib.bold = 1; 811 break; 812 case 4: 813 s->t_attrib.uline = 1; 814 break; 815 case 5: 816 s->t_attrib.blink = 1; 817 break; 818 case 7: 819 s->t_attrib.invers = 1; 820 break; 821 case 8: 822 s->t_attrib.unvisible = 1; 823 break; 824 case 22: 825 s->t_attrib.bold = 0; 826 break; 827 case 24: 828 s->t_attrib.uline = 0; 829 break; 830 case 25: 831 s->t_attrib.blink = 0; 832 break; 833 case 27: 834 s->t_attrib.invers = 0; 835 break; 836 case 28: 837 s->t_attrib.unvisible = 0; 838 break; 839 /* set foreground color */ 840 case 30: 841 s->t_attrib.fgcol = QEMU_COLOR_BLACK; 842 break; 843 case 31: 844 s->t_attrib.fgcol = QEMU_COLOR_RED; 845 break; 846 case 32: 847 s->t_attrib.fgcol = QEMU_COLOR_GREEN; 848 break; 849 case 33: 850 s->t_attrib.fgcol = QEMU_COLOR_YELLOW; 851 break; 852 case 34: 853 s->t_attrib.fgcol = QEMU_COLOR_BLUE; 854 break; 855 case 35: 856 s->t_attrib.fgcol = QEMU_COLOR_MAGENTA; 857 break; 858 case 36: 859 s->t_attrib.fgcol = QEMU_COLOR_CYAN; 860 break; 861 case 37: 862 s->t_attrib.fgcol = QEMU_COLOR_WHITE; 863 break; 864 /* set background color */ 865 case 40: 866 s->t_attrib.bgcol = QEMU_COLOR_BLACK; 867 break; 868 case 41: 869 s->t_attrib.bgcol = QEMU_COLOR_RED; 870 break; 871 case 42: 872 s->t_attrib.bgcol = QEMU_COLOR_GREEN; 873 break; 874 case 43: 875 s->t_attrib.bgcol = QEMU_COLOR_YELLOW; 876 break; 877 case 44: 878 s->t_attrib.bgcol = QEMU_COLOR_BLUE; 879 break; 880 case 45: 881 s->t_attrib.bgcol = QEMU_COLOR_MAGENTA; 882 break; 883 case 46: 884 s->t_attrib.bgcol = QEMU_COLOR_CYAN; 885 break; 886 case 47: 887 s->t_attrib.bgcol = QEMU_COLOR_WHITE; 888 break; 889 } 890 } 891 } 892 893 static void console_clear_xy(QemuConsole *s, int x, int y) 894 { 895 int y1 = (s->y_base + y) % s->total_height; 896 if (x >= s->width) { 897 x = s->width - 1; 898 } 899 TextCell *c = &s->cells[y1 * s->width + x]; 900 c->ch = ' '; 901 c->t_attrib = s->t_attrib_default; 902 update_xy(s, x, y); 903 } 904 905 static void console_put_one(QemuConsole *s, int ch) 906 { 907 TextCell *c; 908 int y1; 909 if (s->x >= s->width) { 910 /* line wrap */ 911 s->x = 0; 912 console_put_lf(s); 913 } 914 y1 = (s->y_base + s->y) % s->total_height; 915 c = &s->cells[y1 * s->width + s->x]; 916 c->ch = ch; 917 c->t_attrib = s->t_attrib; 918 update_xy(s, s->x, s->y); 919 s->x++; 920 } 921 922 static void console_respond_str(QemuConsole *s, const char *buf) 923 { 924 while (*buf) { 925 console_put_one(s, *buf); 926 buf++; 927 } 928 } 929 930 /* set cursor, checking bounds */ 931 static void set_cursor(QemuConsole *s, int x, int y) 932 { 933 if (x < 0) { 934 x = 0; 935 } 936 if (y < 0) { 937 y = 0; 938 } 939 if (y >= s->height) { 940 y = s->height - 1; 941 } 942 if (x >= s->width) { 943 x = s->width - 1; 944 } 945 946 s->x = x; 947 s->y = y; 948 } 949 950 static void console_putchar(QemuConsole *s, int ch) 951 { 952 int i; 953 int x, y; 954 char response[40]; 955 956 switch(s->state) { 957 case TTY_STATE_NORM: 958 switch(ch) { 959 case '\r': /* carriage return */ 960 s->x = 0; 961 break; 962 case '\n': /* newline */ 963 console_put_lf(s); 964 break; 965 case '\b': /* backspace */ 966 if (s->x > 0) 967 s->x--; 968 break; 969 case '\t': /* tabspace */ 970 if (s->x + (8 - (s->x % 8)) > s->width) { 971 s->x = 0; 972 console_put_lf(s); 973 } else { 974 s->x = s->x + (8 - (s->x % 8)); 975 } 976 break; 977 case '\a': /* alert aka. bell */ 978 /* TODO: has to be implemented */ 979 break; 980 case 14: 981 /* SI (shift in), character set 0 (ignored) */ 982 break; 983 case 15: 984 /* SO (shift out), character set 1 (ignored) */ 985 break; 986 case 27: /* esc (introducing an escape sequence) */ 987 s->state = TTY_STATE_ESC; 988 break; 989 default: 990 console_put_one(s, ch); 991 break; 992 } 993 break; 994 case TTY_STATE_ESC: /* check if it is a terminal escape sequence */ 995 if (ch == '[') { 996 for(i=0;i<MAX_ESC_PARAMS;i++) 997 s->esc_params[i] = 0; 998 s->nb_esc_params = 0; 999 s->state = TTY_STATE_CSI; 1000 } else { 1001 s->state = TTY_STATE_NORM; 1002 } 1003 break; 1004 case TTY_STATE_CSI: /* handle escape sequence parameters */ 1005 if (ch >= '0' && ch <= '9') { 1006 if (s->nb_esc_params < MAX_ESC_PARAMS) { 1007 int *param = &s->esc_params[s->nb_esc_params]; 1008 int digit = (ch - '0'); 1009 1010 *param = (*param <= (INT_MAX - digit) / 10) ? 1011 *param * 10 + digit : INT_MAX; 1012 } 1013 } else { 1014 if (s->nb_esc_params < MAX_ESC_PARAMS) 1015 s->nb_esc_params++; 1016 if (ch == ';' || ch == '?') { 1017 break; 1018 } 1019 trace_console_putchar_csi(s->esc_params[0], s->esc_params[1], 1020 ch, s->nb_esc_params); 1021 s->state = TTY_STATE_NORM; 1022 switch(ch) { 1023 case 'A': 1024 /* move cursor up */ 1025 if (s->esc_params[0] == 0) { 1026 s->esc_params[0] = 1; 1027 } 1028 set_cursor(s, s->x, s->y - s->esc_params[0]); 1029 break; 1030 case 'B': 1031 /* move cursor down */ 1032 if (s->esc_params[0] == 0) { 1033 s->esc_params[0] = 1; 1034 } 1035 set_cursor(s, s->x, s->y + s->esc_params[0]); 1036 break; 1037 case 'C': 1038 /* move cursor right */ 1039 if (s->esc_params[0] == 0) { 1040 s->esc_params[0] = 1; 1041 } 1042 set_cursor(s, s->x + s->esc_params[0], s->y); 1043 break; 1044 case 'D': 1045 /* move cursor left */ 1046 if (s->esc_params[0] == 0) { 1047 s->esc_params[0] = 1; 1048 } 1049 set_cursor(s, s->x - s->esc_params[0], s->y); 1050 break; 1051 case 'G': 1052 /* move cursor to column */ 1053 set_cursor(s, s->esc_params[0] - 1, s->y); 1054 break; 1055 case 'f': 1056 case 'H': 1057 /* move cursor to row, column */ 1058 set_cursor(s, s->esc_params[1] - 1, s->esc_params[0] - 1); 1059 break; 1060 case 'J': 1061 switch (s->esc_params[0]) { 1062 case 0: 1063 /* clear to end of screen */ 1064 for (y = s->y; y < s->height; y++) { 1065 for (x = 0; x < s->width; x++) { 1066 if (y == s->y && x < s->x) { 1067 continue; 1068 } 1069 console_clear_xy(s, x, y); 1070 } 1071 } 1072 break; 1073 case 1: 1074 /* clear from beginning of screen */ 1075 for (y = 0; y <= s->y; y++) { 1076 for (x = 0; x < s->width; x++) { 1077 if (y == s->y && x > s->x) { 1078 break; 1079 } 1080 console_clear_xy(s, x, y); 1081 } 1082 } 1083 break; 1084 case 2: 1085 /* clear entire screen */ 1086 for (y = 0; y <= s->height; y++) { 1087 for (x = 0; x < s->width; x++) { 1088 console_clear_xy(s, x, y); 1089 } 1090 } 1091 break; 1092 } 1093 break; 1094 case 'K': 1095 switch (s->esc_params[0]) { 1096 case 0: 1097 /* clear to eol */ 1098 for(x = s->x; x < s->width; x++) { 1099 console_clear_xy(s, x, s->y); 1100 } 1101 break; 1102 case 1: 1103 /* clear from beginning of line */ 1104 for (x = 0; x <= s->x && x < s->width; x++) { 1105 console_clear_xy(s, x, s->y); 1106 } 1107 break; 1108 case 2: 1109 /* clear entire line */ 1110 for(x = 0; x < s->width; x++) { 1111 console_clear_xy(s, x, s->y); 1112 } 1113 break; 1114 } 1115 break; 1116 case 'm': 1117 console_handle_escape(s); 1118 break; 1119 case 'n': 1120 switch (s->esc_params[0]) { 1121 case 5: 1122 /* report console status (always succeed)*/ 1123 console_respond_str(s, "\033[0n"); 1124 break; 1125 case 6: 1126 /* report cursor position */ 1127 sprintf(response, "\033[%d;%dR", 1128 (s->y_base + s->y) % s->total_height + 1, 1129 s->x + 1); 1130 console_respond_str(s, response); 1131 break; 1132 } 1133 break; 1134 case 's': 1135 /* save cursor position */ 1136 s->x_saved = s->x; 1137 s->y_saved = s->y; 1138 break; 1139 case 'u': 1140 /* restore cursor position */ 1141 s->x = s->x_saved; 1142 s->y = s->y_saved; 1143 break; 1144 default: 1145 trace_console_putchar_unhandled(ch); 1146 break; 1147 } 1148 break; 1149 } 1150 } 1151 } 1152 1153 static void displaychangelistener_gfx_switch(DisplayChangeListener *dcl, 1154 struct DisplaySurface *new_surface, 1155 bool update) 1156 { 1157 if (dcl->ops->dpy_gfx_switch) { 1158 dcl->ops->dpy_gfx_switch(dcl, new_surface); 1159 } 1160 1161 if (update && dcl->ops->dpy_gfx_update) { 1162 dcl->ops->dpy_gfx_update(dcl, 0, 0, 1163 surface_width(new_surface), 1164 surface_height(new_surface)); 1165 } 1166 } 1167 1168 static void dpy_gfx_create_texture(QemuConsole *con, DisplaySurface *surface) 1169 { 1170 if (con->gl && con->gl->ops->dpy_gl_ctx_create_texture) { 1171 con->gl->ops->dpy_gl_ctx_create_texture(con->gl, surface); 1172 } 1173 } 1174 1175 static void dpy_gfx_destroy_texture(QemuConsole *con, DisplaySurface *surface) 1176 { 1177 if (con->gl && con->gl->ops->dpy_gl_ctx_destroy_texture) { 1178 con->gl->ops->dpy_gl_ctx_destroy_texture(con->gl, surface); 1179 } 1180 } 1181 1182 static void dpy_gfx_update_texture(QemuConsole *con, DisplaySurface *surface, 1183 int x, int y, int w, int h) 1184 { 1185 if (con->gl && con->gl->ops->dpy_gl_ctx_update_texture) { 1186 con->gl->ops->dpy_gl_ctx_update_texture(con->gl, surface, x, y, w, h); 1187 } 1188 } 1189 1190 static void displaychangelistener_display_console(DisplayChangeListener *dcl, 1191 QemuConsole *con, 1192 Error **errp) 1193 { 1194 static const char nodev[] = 1195 "This VM has no graphic display device."; 1196 static DisplaySurface *dummy; 1197 1198 if (!con || !console_compatible_with(con, dcl, errp)) { 1199 if (!dummy) { 1200 dummy = qemu_create_placeholder_surface(640, 480, nodev); 1201 } 1202 if (con) { 1203 dpy_gfx_create_texture(con, dummy); 1204 } 1205 displaychangelistener_gfx_switch(dcl, dummy, TRUE); 1206 return; 1207 } 1208 1209 dpy_gfx_create_texture(con, con->surface); 1210 displaychangelistener_gfx_switch(dcl, con->surface, 1211 con->scanout.kind == SCANOUT_SURFACE); 1212 1213 if (con->scanout.kind == SCANOUT_DMABUF && 1214 displaychangelistener_has_dmabuf(dcl)) { 1215 dcl->ops->dpy_gl_scanout_dmabuf(dcl, con->scanout.dmabuf); 1216 } else if (con->scanout.kind == SCANOUT_TEXTURE && 1217 dcl->ops->dpy_gl_scanout_texture) { 1218 dcl->ops->dpy_gl_scanout_texture(dcl, 1219 con->scanout.texture.backing_id, 1220 con->scanout.texture.backing_y_0_top, 1221 con->scanout.texture.backing_width, 1222 con->scanout.texture.backing_height, 1223 con->scanout.texture.x, 1224 con->scanout.texture.y, 1225 con->scanout.texture.width, 1226 con->scanout.texture.height, 1227 con->scanout.texture.d3d_tex2d); 1228 } 1229 } 1230 1231 void console_select(unsigned int index) 1232 { 1233 DisplayChangeListener *dcl; 1234 QemuConsole *s; 1235 1236 trace_console_select(index); 1237 s = qemu_console_lookup_by_index(index); 1238 if (s) { 1239 DisplayState *ds = s->ds; 1240 1241 active_console = s; 1242 if (ds->have_gfx) { 1243 QLIST_FOREACH(dcl, &ds->listeners, next) { 1244 if (dcl->con != NULL) { 1245 continue; 1246 } 1247 displaychangelistener_display_console(dcl, s, NULL); 1248 } 1249 } 1250 if (ds->have_text) { 1251 dpy_text_resize(s, s->width, s->height); 1252 } 1253 text_console_update_cursor(NULL); 1254 } 1255 } 1256 1257 struct VCChardev { 1258 Chardev parent; 1259 QemuConsole *console; 1260 }; 1261 typedef struct VCChardev VCChardev; 1262 1263 #define TYPE_CHARDEV_VC "chardev-vc" 1264 DECLARE_INSTANCE_CHECKER(VCChardev, VC_CHARDEV, 1265 TYPE_CHARDEV_VC) 1266 1267 static int vc_chr_write(Chardev *chr, const uint8_t *buf, int len) 1268 { 1269 VCChardev *drv = VC_CHARDEV(chr); 1270 QemuConsole *s = drv->console; 1271 int i; 1272 1273 if (!s->ds) { 1274 return 0; 1275 } 1276 1277 s->update_x0 = s->width * FONT_WIDTH; 1278 s->update_y0 = s->height * FONT_HEIGHT; 1279 s->update_x1 = 0; 1280 s->update_y1 = 0; 1281 console_show_cursor(s, 0); 1282 for(i = 0; i < len; i++) { 1283 console_putchar(s, buf[i]); 1284 } 1285 console_show_cursor(s, 1); 1286 if (s->ds->have_gfx && s->update_x0 < s->update_x1) { 1287 dpy_gfx_update(s, s->update_x0, s->update_y0, 1288 s->update_x1 - s->update_x0, 1289 s->update_y1 - s->update_y0); 1290 } 1291 return len; 1292 } 1293 1294 static void kbd_send_chars(QemuConsole *s) 1295 { 1296 uint32_t len, avail; 1297 1298 len = qemu_chr_be_can_write(s->chr); 1299 avail = fifo8_num_used(&s->out_fifo); 1300 while (len > 0 && avail > 0) { 1301 const uint8_t *buf; 1302 uint32_t size; 1303 1304 buf = fifo8_pop_buf(&s->out_fifo, MIN(len, avail), &size); 1305 qemu_chr_be_write(s->chr, buf, size); 1306 len = qemu_chr_be_can_write(s->chr); 1307 avail -= size; 1308 } 1309 } 1310 1311 /* called when an ascii key is pressed */ 1312 void kbd_put_keysym_console(QemuConsole *s, int keysym) 1313 { 1314 uint8_t buf[16], *q; 1315 int c; 1316 uint32_t num_free; 1317 1318 if (!s || (s->console_type == GRAPHIC_CONSOLE)) 1319 return; 1320 1321 switch(keysym) { 1322 case QEMU_KEY_CTRL_UP: 1323 console_scroll(s, -1); 1324 break; 1325 case QEMU_KEY_CTRL_DOWN: 1326 console_scroll(s, 1); 1327 break; 1328 case QEMU_KEY_CTRL_PAGEUP: 1329 console_scroll(s, -10); 1330 break; 1331 case QEMU_KEY_CTRL_PAGEDOWN: 1332 console_scroll(s, 10); 1333 break; 1334 default: 1335 /* convert the QEMU keysym to VT100 key string */ 1336 q = buf; 1337 if (keysym >= 0xe100 && keysym <= 0xe11f) { 1338 *q++ = '\033'; 1339 *q++ = '['; 1340 c = keysym - 0xe100; 1341 if (c >= 10) 1342 *q++ = '0' + (c / 10); 1343 *q++ = '0' + (c % 10); 1344 *q++ = '~'; 1345 } else if (keysym >= 0xe120 && keysym <= 0xe17f) { 1346 *q++ = '\033'; 1347 *q++ = '['; 1348 *q++ = keysym & 0xff; 1349 } else if (s->echo && (keysym == '\r' || keysym == '\n')) { 1350 vc_chr_write(s->chr, (const uint8_t *) "\r", 1); 1351 *q++ = '\n'; 1352 } else { 1353 *q++ = keysym; 1354 } 1355 if (s->echo) { 1356 vc_chr_write(s->chr, buf, q - buf); 1357 } 1358 num_free = fifo8_num_free(&s->out_fifo); 1359 fifo8_push_all(&s->out_fifo, buf, MIN(num_free, q - buf)); 1360 kbd_send_chars(s); 1361 break; 1362 } 1363 } 1364 1365 static const int qcode_to_keysym[Q_KEY_CODE__MAX] = { 1366 [Q_KEY_CODE_UP] = QEMU_KEY_UP, 1367 [Q_KEY_CODE_DOWN] = QEMU_KEY_DOWN, 1368 [Q_KEY_CODE_RIGHT] = QEMU_KEY_RIGHT, 1369 [Q_KEY_CODE_LEFT] = QEMU_KEY_LEFT, 1370 [Q_KEY_CODE_HOME] = QEMU_KEY_HOME, 1371 [Q_KEY_CODE_END] = QEMU_KEY_END, 1372 [Q_KEY_CODE_PGUP] = QEMU_KEY_PAGEUP, 1373 [Q_KEY_CODE_PGDN] = QEMU_KEY_PAGEDOWN, 1374 [Q_KEY_CODE_DELETE] = QEMU_KEY_DELETE, 1375 [Q_KEY_CODE_TAB] = QEMU_KEY_TAB, 1376 [Q_KEY_CODE_BACKSPACE] = QEMU_KEY_BACKSPACE, 1377 }; 1378 1379 static const int ctrl_qcode_to_keysym[Q_KEY_CODE__MAX] = { 1380 [Q_KEY_CODE_UP] = QEMU_KEY_CTRL_UP, 1381 [Q_KEY_CODE_DOWN] = QEMU_KEY_CTRL_DOWN, 1382 [Q_KEY_CODE_RIGHT] = QEMU_KEY_CTRL_RIGHT, 1383 [Q_KEY_CODE_LEFT] = QEMU_KEY_CTRL_LEFT, 1384 [Q_KEY_CODE_HOME] = QEMU_KEY_CTRL_HOME, 1385 [Q_KEY_CODE_END] = QEMU_KEY_CTRL_END, 1386 [Q_KEY_CODE_PGUP] = QEMU_KEY_CTRL_PAGEUP, 1387 [Q_KEY_CODE_PGDN] = QEMU_KEY_CTRL_PAGEDOWN, 1388 }; 1389 1390 bool kbd_put_qcode_console(QemuConsole *s, int qcode, bool ctrl) 1391 { 1392 int keysym; 1393 1394 keysym = ctrl ? ctrl_qcode_to_keysym[qcode] : qcode_to_keysym[qcode]; 1395 if (keysym == 0) { 1396 return false; 1397 } 1398 kbd_put_keysym_console(s, keysym); 1399 return true; 1400 } 1401 1402 void kbd_put_string_console(QemuConsole *s, const char *str, int len) 1403 { 1404 int i; 1405 1406 for (i = 0; i < len && str[i]; i++) { 1407 kbd_put_keysym_console(s, str[i]); 1408 } 1409 } 1410 1411 void kbd_put_keysym(int keysym) 1412 { 1413 kbd_put_keysym_console(active_console, keysym); 1414 } 1415 1416 static void text_console_invalidate(void *opaque) 1417 { 1418 QemuConsole *s = (QemuConsole *) opaque; 1419 1420 if (s->ds->have_text && s->console_type == TEXT_CONSOLE) { 1421 text_console_resize(s); 1422 } 1423 console_refresh(s); 1424 } 1425 1426 static void text_console_update(void *opaque, console_ch_t *chardata) 1427 { 1428 QemuConsole *s = (QemuConsole *) opaque; 1429 int i, j, src; 1430 1431 if (s->text_x[0] <= s->text_x[1]) { 1432 src = (s->y_base + s->text_y[0]) * s->width; 1433 chardata += s->text_y[0] * s->width; 1434 for (i = s->text_y[0]; i <= s->text_y[1]; i ++) 1435 for (j = 0; j < s->width; j++, src++) { 1436 console_write_ch(chardata ++, 1437 ATTR2CHTYPE(s->cells[src].ch, 1438 s->cells[src].t_attrib.fgcol, 1439 s->cells[src].t_attrib.bgcol, 1440 s->cells[src].t_attrib.bold)); 1441 } 1442 dpy_text_update(s, s->text_x[0], s->text_y[0], 1443 s->text_x[1] - s->text_x[0], i - s->text_y[0]); 1444 s->text_x[0] = s->width; 1445 s->text_y[0] = s->height; 1446 s->text_x[1] = 0; 1447 s->text_y[1] = 0; 1448 } 1449 if (s->cursor_invalidate) { 1450 dpy_text_cursor(s, s->x, s->y); 1451 s->cursor_invalidate = 0; 1452 } 1453 } 1454 1455 static QemuConsole *new_console(DisplayState *ds, console_type_t console_type, 1456 uint32_t head) 1457 { 1458 Object *obj; 1459 QemuConsole *s; 1460 int i; 1461 1462 obj = object_new(TYPE_QEMU_CONSOLE); 1463 s = QEMU_CONSOLE(obj); 1464 qemu_co_queue_init(&s->dump_queue); 1465 s->head = head; 1466 object_property_add_link(obj, "device", TYPE_DEVICE, 1467 (Object **)&s->device, 1468 object_property_allow_set_link, 1469 OBJ_PROP_LINK_STRONG); 1470 object_property_add_uint32_ptr(obj, "head", &s->head, 1471 OBJ_PROP_FLAG_READ); 1472 1473 if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) && 1474 (console_type == GRAPHIC_CONSOLE))) { 1475 active_console = s; 1476 } 1477 s->ds = ds; 1478 s->console_type = console_type; 1479 s->window_id = -1; 1480 1481 if (QTAILQ_EMPTY(&consoles)) { 1482 s->index = 0; 1483 QTAILQ_INSERT_TAIL(&consoles, s, next); 1484 } else if (console_type != GRAPHIC_CONSOLE || phase_check(PHASE_MACHINE_READY)) { 1485 QemuConsole *last = QTAILQ_LAST(&consoles); 1486 s->index = last->index + 1; 1487 QTAILQ_INSERT_TAIL(&consoles, s, next); 1488 } else { 1489 /* 1490 * HACK: Put graphical consoles before text consoles. 1491 * 1492 * Only do that for coldplugged devices. After initial device 1493 * initialization we will not renumber the consoles any more. 1494 */ 1495 QemuConsole *c = QTAILQ_FIRST(&consoles); 1496 1497 while (QTAILQ_NEXT(c, next) != NULL && 1498 c->console_type == GRAPHIC_CONSOLE) { 1499 c = QTAILQ_NEXT(c, next); 1500 } 1501 if (c->console_type == GRAPHIC_CONSOLE) { 1502 /* have no text consoles */ 1503 s->index = c->index + 1; 1504 QTAILQ_INSERT_AFTER(&consoles, c, s, next); 1505 } else { 1506 s->index = c->index; 1507 QTAILQ_INSERT_BEFORE(c, s, next); 1508 /* renumber text consoles */ 1509 for (i = s->index + 1; c != NULL; c = QTAILQ_NEXT(c, next), i++) { 1510 c->index = i; 1511 } 1512 } 1513 } 1514 return s; 1515 } 1516 1517 #ifdef WIN32 1518 void qemu_displaysurface_win32_set_handle(DisplaySurface *surface, 1519 HANDLE h, uint32_t offset) 1520 { 1521 assert(!surface->handle); 1522 1523 surface->handle = h; 1524 surface->handle_offset = offset; 1525 } 1526 1527 static void 1528 win32_pixman_image_destroy(pixman_image_t *image, void *data) 1529 { 1530 DisplaySurface *surface = data; 1531 1532 if (!surface->handle) { 1533 return; 1534 } 1535 1536 assert(surface->handle_offset == 0); 1537 1538 qemu_win32_map_free( 1539 pixman_image_get_data(surface->image), 1540 surface->handle, 1541 &error_warn 1542 ); 1543 } 1544 #endif 1545 1546 DisplaySurface *qemu_create_displaysurface(int width, int height) 1547 { 1548 DisplaySurface *surface; 1549 void *bits = NULL; 1550 #ifdef WIN32 1551 HANDLE handle = NULL; 1552 #endif 1553 1554 trace_displaysurface_create(width, height); 1555 1556 #ifdef WIN32 1557 bits = qemu_win32_map_alloc(width * height * 4, &handle, &error_abort); 1558 #endif 1559 1560 surface = qemu_create_displaysurface_from( 1561 width, height, 1562 PIXMAN_x8r8g8b8, 1563 width * 4, bits 1564 ); 1565 surface->flags = QEMU_ALLOCATED_FLAG; 1566 1567 #ifdef WIN32 1568 qemu_displaysurface_win32_set_handle(surface, handle, 0); 1569 #endif 1570 return surface; 1571 } 1572 1573 DisplaySurface *qemu_create_displaysurface_from(int width, int height, 1574 pixman_format_code_t format, 1575 int linesize, uint8_t *data) 1576 { 1577 DisplaySurface *surface = g_new0(DisplaySurface, 1); 1578 1579 trace_displaysurface_create_from(surface, width, height, format); 1580 surface->format = format; 1581 surface->image = pixman_image_create_bits(surface->format, 1582 width, height, 1583 (void *)data, linesize); 1584 assert(surface->image != NULL); 1585 #ifdef WIN32 1586 pixman_image_set_destroy_function(surface->image, 1587 win32_pixman_image_destroy, surface); 1588 #endif 1589 1590 return surface; 1591 } 1592 1593 DisplaySurface *qemu_create_displaysurface_pixman(pixman_image_t *image) 1594 { 1595 DisplaySurface *surface = g_new0(DisplaySurface, 1); 1596 1597 trace_displaysurface_create_pixman(surface); 1598 surface->format = pixman_image_get_format(image); 1599 surface->image = pixman_image_ref(image); 1600 1601 return surface; 1602 } 1603 1604 DisplaySurface *qemu_create_placeholder_surface(int w, int h, 1605 const char *msg) 1606 { 1607 DisplaySurface *surface = qemu_create_displaysurface(w, h); 1608 pixman_color_t bg = color_table_rgb[0][QEMU_COLOR_BLACK]; 1609 pixman_color_t fg = color_table_rgb[0][QEMU_COLOR_WHITE]; 1610 pixman_image_t *glyph; 1611 int len, x, y, i; 1612 1613 len = strlen(msg); 1614 x = (w / FONT_WIDTH - len) / 2; 1615 y = (h / FONT_HEIGHT - 1) / 2; 1616 for (i = 0; i < len; i++) { 1617 glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]); 1618 qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg, 1619 x+i, y, FONT_WIDTH, FONT_HEIGHT); 1620 qemu_pixman_image_unref(glyph); 1621 } 1622 surface->flags |= QEMU_PLACEHOLDER_FLAG; 1623 return surface; 1624 } 1625 1626 void qemu_free_displaysurface(DisplaySurface *surface) 1627 { 1628 if (surface == NULL) { 1629 return; 1630 } 1631 trace_displaysurface_free(surface); 1632 qemu_pixman_image_unref(surface->image); 1633 g_free(surface); 1634 } 1635 1636 bool console_has_gl(QemuConsole *con) 1637 { 1638 return con->gl != NULL; 1639 } 1640 1641 static bool displaychangelistener_has_dmabuf(DisplayChangeListener *dcl) 1642 { 1643 if (dcl->ops->dpy_has_dmabuf) { 1644 return dcl->ops->dpy_has_dmabuf(dcl); 1645 } 1646 1647 if (dcl->ops->dpy_gl_scanout_dmabuf) { 1648 return true; 1649 } 1650 1651 return false; 1652 } 1653 1654 static bool console_compatible_with(QemuConsole *con, 1655 DisplayChangeListener *dcl, Error **errp) 1656 { 1657 int flags; 1658 1659 flags = con->hw_ops->get_flags ? con->hw_ops->get_flags(con->hw) : 0; 1660 1661 if (console_has_gl(con) && 1662 !con->gl->ops->dpy_gl_ctx_is_compatible_dcl(con->gl, dcl)) { 1663 error_setg(errp, "Display %s is incompatible with the GL context", 1664 dcl->ops->dpy_name); 1665 return false; 1666 } 1667 1668 if (flags & GRAPHIC_FLAGS_GL && 1669 !console_has_gl(con)) { 1670 error_setg(errp, "The console requires a GL context."); 1671 return false; 1672 1673 } 1674 1675 if (flags & GRAPHIC_FLAGS_DMABUF && 1676 !displaychangelistener_has_dmabuf(dcl)) { 1677 error_setg(errp, "The console requires display DMABUF support."); 1678 return false; 1679 } 1680 1681 return true; 1682 } 1683 1684 void console_handle_touch_event(QemuConsole *con, 1685 struct touch_slot touch_slots[INPUT_EVENT_SLOTS_MAX], 1686 uint64_t num_slot, 1687 int width, int height, 1688 double x, double y, 1689 InputMultiTouchType type, 1690 Error **errp) 1691 { 1692 struct touch_slot *slot; 1693 bool needs_sync = false; 1694 int update; 1695 int i; 1696 1697 if (num_slot >= INPUT_EVENT_SLOTS_MAX) { 1698 error_setg(errp, 1699 "Unexpected touch slot number: % " PRId64" >= %d", 1700 num_slot, INPUT_EVENT_SLOTS_MAX); 1701 return; 1702 } 1703 1704 slot = &touch_slots[num_slot]; 1705 slot->x = x; 1706 slot->y = y; 1707 1708 if (type == INPUT_MULTI_TOUCH_TYPE_BEGIN) { 1709 slot->tracking_id = num_slot; 1710 } 1711 1712 for (i = 0; i < INPUT_EVENT_SLOTS_MAX; ++i) { 1713 if (i == num_slot) { 1714 update = type; 1715 } else { 1716 update = INPUT_MULTI_TOUCH_TYPE_UPDATE; 1717 } 1718 1719 slot = &touch_slots[i]; 1720 1721 if (slot->tracking_id == -1) { 1722 continue; 1723 } 1724 1725 if (update == INPUT_MULTI_TOUCH_TYPE_END) { 1726 slot->tracking_id = -1; 1727 qemu_input_queue_mtt(con, update, i, slot->tracking_id); 1728 needs_sync = true; 1729 } else { 1730 qemu_input_queue_mtt(con, update, i, slot->tracking_id); 1731 qemu_input_queue_btn(con, INPUT_BUTTON_TOUCH, true); 1732 qemu_input_queue_mtt_abs(con, 1733 INPUT_AXIS_X, (int) slot->x, 1734 0, width, 1735 i, slot->tracking_id); 1736 qemu_input_queue_mtt_abs(con, 1737 INPUT_AXIS_Y, (int) slot->y, 1738 0, height, 1739 i, slot->tracking_id); 1740 needs_sync = true; 1741 } 1742 } 1743 1744 if (needs_sync) { 1745 qemu_input_event_sync(); 1746 } 1747 } 1748 1749 void qemu_console_set_display_gl_ctx(QemuConsole *con, DisplayGLCtx *gl) 1750 { 1751 /* display has opengl support */ 1752 assert(con); 1753 if (con->gl) { 1754 error_report("The console already has an OpenGL context."); 1755 exit(1); 1756 } 1757 con->gl = gl; 1758 } 1759 1760 void register_displaychangelistener(DisplayChangeListener *dcl) 1761 { 1762 QemuConsole *con; 1763 1764 assert(!dcl->ds); 1765 1766 trace_displaychangelistener_register(dcl, dcl->ops->dpy_name); 1767 dcl->ds = get_alloc_displaystate(); 1768 QLIST_INSERT_HEAD(&dcl->ds->listeners, dcl, next); 1769 gui_setup_refresh(dcl->ds); 1770 if (dcl->con) { 1771 dcl->con->dcls++; 1772 con = dcl->con; 1773 } else { 1774 con = active_console; 1775 } 1776 displaychangelistener_display_console(dcl, con, dcl->con ? &error_fatal : NULL); 1777 if (con && con->cursor && dcl->ops->dpy_cursor_define) { 1778 dcl->ops->dpy_cursor_define(dcl, con->cursor); 1779 } 1780 if (con && dcl->ops->dpy_mouse_set) { 1781 dcl->ops->dpy_mouse_set(dcl, con->cursor_x, con->cursor_y, con->cursor_on); 1782 } 1783 text_console_update_cursor(NULL); 1784 } 1785 1786 void update_displaychangelistener(DisplayChangeListener *dcl, 1787 uint64_t interval) 1788 { 1789 DisplayState *ds = dcl->ds; 1790 1791 dcl->update_interval = interval; 1792 if (!ds->refreshing && ds->update_interval > interval) { 1793 timer_mod(ds->gui_timer, ds->last_update + interval); 1794 } 1795 } 1796 1797 void unregister_displaychangelistener(DisplayChangeListener *dcl) 1798 { 1799 DisplayState *ds = dcl->ds; 1800 trace_displaychangelistener_unregister(dcl, dcl->ops->dpy_name); 1801 if (dcl->con) { 1802 dcl->con->dcls--; 1803 } 1804 QLIST_REMOVE(dcl, next); 1805 dcl->ds = NULL; 1806 gui_setup_refresh(ds); 1807 } 1808 1809 static void dpy_set_ui_info_timer(void *opaque) 1810 { 1811 QemuConsole *con = opaque; 1812 1813 con->hw_ops->ui_info(con->hw, con->head, &con->ui_info); 1814 } 1815 1816 bool dpy_ui_info_supported(QemuConsole *con) 1817 { 1818 if (con == NULL) { 1819 con = active_console; 1820 } 1821 1822 return con->hw_ops->ui_info != NULL; 1823 } 1824 1825 const QemuUIInfo *dpy_get_ui_info(const QemuConsole *con) 1826 { 1827 if (con == NULL) { 1828 con = active_console; 1829 } 1830 1831 return &con->ui_info; 1832 } 1833 1834 int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay) 1835 { 1836 if (con == NULL) { 1837 con = active_console; 1838 } 1839 1840 if (!dpy_ui_info_supported(con)) { 1841 return -1; 1842 } 1843 if (memcmp(&con->ui_info, info, sizeof(con->ui_info)) == 0) { 1844 /* nothing changed -- ignore */ 1845 return 0; 1846 } 1847 1848 /* 1849 * Typically we get a flood of these as the user resizes the window. 1850 * Wait until the dust has settled (one second without updates), then 1851 * go notify the guest. 1852 */ 1853 con->ui_info = *info; 1854 timer_mod(con->ui_timer, 1855 qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + (delay ? 1000 : 0)); 1856 return 0; 1857 } 1858 1859 void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h) 1860 { 1861 DisplayState *s = con->ds; 1862 DisplayChangeListener *dcl; 1863 int width = qemu_console_get_width(con, x + w); 1864 int height = qemu_console_get_height(con, y + h); 1865 1866 x = MAX(x, 0); 1867 y = MAX(y, 0); 1868 x = MIN(x, width); 1869 y = MIN(y, height); 1870 w = MIN(w, width - x); 1871 h = MIN(h, height - y); 1872 1873 if (!qemu_console_is_visible(con)) { 1874 return; 1875 } 1876 dpy_gfx_update_texture(con, con->surface, x, y, w, h); 1877 QLIST_FOREACH(dcl, &s->listeners, next) { 1878 if (con != (dcl->con ? dcl->con : active_console)) { 1879 continue; 1880 } 1881 if (dcl->ops->dpy_gfx_update) { 1882 dcl->ops->dpy_gfx_update(dcl, x, y, w, h); 1883 } 1884 } 1885 } 1886 1887 void dpy_gfx_update_full(QemuConsole *con) 1888 { 1889 int w = qemu_console_get_width(con, 0); 1890 int h = qemu_console_get_height(con, 0); 1891 1892 dpy_gfx_update(con, 0, 0, w, h); 1893 } 1894 1895 void dpy_gfx_replace_surface(QemuConsole *con, 1896 DisplaySurface *surface) 1897 { 1898 static const char placeholder_msg[] = "Display output is not active."; 1899 DisplayState *s = con->ds; 1900 DisplaySurface *old_surface = con->surface; 1901 DisplayChangeListener *dcl; 1902 int width; 1903 int height; 1904 1905 if (!surface) { 1906 if (old_surface) { 1907 width = surface_width(old_surface); 1908 height = surface_height(old_surface); 1909 } else { 1910 width = 640; 1911 height = 480; 1912 } 1913 1914 surface = qemu_create_placeholder_surface(width, height, placeholder_msg); 1915 } 1916 1917 assert(old_surface != surface); 1918 1919 con->scanout.kind = SCANOUT_SURFACE; 1920 con->surface = surface; 1921 dpy_gfx_create_texture(con, surface); 1922 QLIST_FOREACH(dcl, &s->listeners, next) { 1923 if (con != (dcl->con ? dcl->con : active_console)) { 1924 continue; 1925 } 1926 displaychangelistener_gfx_switch(dcl, surface, FALSE); 1927 } 1928 dpy_gfx_destroy_texture(con, old_surface); 1929 qemu_free_displaysurface(old_surface); 1930 } 1931 1932 bool dpy_gfx_check_format(QemuConsole *con, 1933 pixman_format_code_t format) 1934 { 1935 DisplayChangeListener *dcl; 1936 DisplayState *s = con->ds; 1937 1938 QLIST_FOREACH(dcl, &s->listeners, next) { 1939 if (dcl->con && dcl->con != con) { 1940 /* dcl bound to another console -> skip */ 1941 continue; 1942 } 1943 if (dcl->ops->dpy_gfx_check_format) { 1944 if (!dcl->ops->dpy_gfx_check_format(dcl, format)) { 1945 return false; 1946 } 1947 } else { 1948 /* default is to allow native 32 bpp only */ 1949 if (format != qemu_default_pixman_format(32, true)) { 1950 return false; 1951 } 1952 } 1953 } 1954 return true; 1955 } 1956 1957 static void dpy_refresh(DisplayState *s) 1958 { 1959 DisplayChangeListener *dcl; 1960 1961 QLIST_FOREACH(dcl, &s->listeners, next) { 1962 if (dcl->ops->dpy_refresh) { 1963 dcl->ops->dpy_refresh(dcl); 1964 } 1965 } 1966 } 1967 1968 void dpy_text_cursor(QemuConsole *con, int x, int y) 1969 { 1970 DisplayState *s = con->ds; 1971 DisplayChangeListener *dcl; 1972 1973 if (!qemu_console_is_visible(con)) { 1974 return; 1975 } 1976 QLIST_FOREACH(dcl, &s->listeners, next) { 1977 if (con != (dcl->con ? dcl->con : active_console)) { 1978 continue; 1979 } 1980 if (dcl->ops->dpy_text_cursor) { 1981 dcl->ops->dpy_text_cursor(dcl, x, y); 1982 } 1983 } 1984 } 1985 1986 void dpy_text_update(QemuConsole *con, int x, int y, int w, int h) 1987 { 1988 DisplayState *s = con->ds; 1989 DisplayChangeListener *dcl; 1990 1991 if (!qemu_console_is_visible(con)) { 1992 return; 1993 } 1994 QLIST_FOREACH(dcl, &s->listeners, next) { 1995 if (con != (dcl->con ? dcl->con : active_console)) { 1996 continue; 1997 } 1998 if (dcl->ops->dpy_text_update) { 1999 dcl->ops->dpy_text_update(dcl, x, y, w, h); 2000 } 2001 } 2002 } 2003 2004 void dpy_text_resize(QemuConsole *con, int w, int h) 2005 { 2006 DisplayState *s = con->ds; 2007 DisplayChangeListener *dcl; 2008 2009 if (!qemu_console_is_visible(con)) { 2010 return; 2011 } 2012 QLIST_FOREACH(dcl, &s->listeners, next) { 2013 if (con != (dcl->con ? dcl->con : active_console)) { 2014 continue; 2015 } 2016 if (dcl->ops->dpy_text_resize) { 2017 dcl->ops->dpy_text_resize(dcl, w, h); 2018 } 2019 } 2020 } 2021 2022 void dpy_mouse_set(QemuConsole *con, int x, int y, int on) 2023 { 2024 DisplayState *s = con->ds; 2025 DisplayChangeListener *dcl; 2026 2027 con->cursor_x = x; 2028 con->cursor_y = y; 2029 con->cursor_on = on; 2030 if (!qemu_console_is_visible(con)) { 2031 return; 2032 } 2033 QLIST_FOREACH(dcl, &s->listeners, next) { 2034 if (con != (dcl->con ? dcl->con : active_console)) { 2035 continue; 2036 } 2037 if (dcl->ops->dpy_mouse_set) { 2038 dcl->ops->dpy_mouse_set(dcl, x, y, on); 2039 } 2040 } 2041 } 2042 2043 void dpy_cursor_define(QemuConsole *con, QEMUCursor *cursor) 2044 { 2045 DisplayState *s = con->ds; 2046 DisplayChangeListener *dcl; 2047 2048 cursor_unref(con->cursor); 2049 con->cursor = cursor_ref(cursor); 2050 if (!qemu_console_is_visible(con)) { 2051 return; 2052 } 2053 QLIST_FOREACH(dcl, &s->listeners, next) { 2054 if (con != (dcl->con ? dcl->con : active_console)) { 2055 continue; 2056 } 2057 if (dcl->ops->dpy_cursor_define) { 2058 dcl->ops->dpy_cursor_define(dcl, cursor); 2059 } 2060 } 2061 } 2062 2063 bool dpy_cursor_define_supported(QemuConsole *con) 2064 { 2065 DisplayState *s = con->ds; 2066 DisplayChangeListener *dcl; 2067 2068 QLIST_FOREACH(dcl, &s->listeners, next) { 2069 if (dcl->ops->dpy_cursor_define) { 2070 return true; 2071 } 2072 } 2073 return false; 2074 } 2075 2076 QEMUGLContext dpy_gl_ctx_create(QemuConsole *con, 2077 struct QEMUGLParams *qparams) 2078 { 2079 assert(con->gl); 2080 return con->gl->ops->dpy_gl_ctx_create(con->gl, qparams); 2081 } 2082 2083 void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx) 2084 { 2085 assert(con->gl); 2086 con->gl->ops->dpy_gl_ctx_destroy(con->gl, ctx); 2087 } 2088 2089 int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx) 2090 { 2091 assert(con->gl); 2092 return con->gl->ops->dpy_gl_ctx_make_current(con->gl, ctx); 2093 } 2094 2095 void dpy_gl_scanout_disable(QemuConsole *con) 2096 { 2097 DisplayState *s = con->ds; 2098 DisplayChangeListener *dcl; 2099 2100 if (con->scanout.kind != SCANOUT_SURFACE) { 2101 con->scanout.kind = SCANOUT_NONE; 2102 } 2103 QLIST_FOREACH(dcl, &s->listeners, next) { 2104 if (con != (dcl->con ? dcl->con : active_console)) { 2105 continue; 2106 } 2107 if (dcl->ops->dpy_gl_scanout_disable) { 2108 dcl->ops->dpy_gl_scanout_disable(dcl); 2109 } 2110 } 2111 } 2112 2113 void dpy_gl_scanout_texture(QemuConsole *con, 2114 uint32_t backing_id, 2115 bool backing_y_0_top, 2116 uint32_t backing_width, 2117 uint32_t backing_height, 2118 uint32_t x, uint32_t y, 2119 uint32_t width, uint32_t height, 2120 void *d3d_tex2d) 2121 { 2122 DisplayState *s = con->ds; 2123 DisplayChangeListener *dcl; 2124 2125 con->scanout.kind = SCANOUT_TEXTURE; 2126 con->scanout.texture = (ScanoutTexture) { 2127 backing_id, backing_y_0_top, backing_width, backing_height, 2128 x, y, width, height, d3d_tex2d, 2129 }; 2130 QLIST_FOREACH(dcl, &s->listeners, next) { 2131 if (con != (dcl->con ? dcl->con : active_console)) { 2132 continue; 2133 } 2134 if (dcl->ops->dpy_gl_scanout_texture) { 2135 dcl->ops->dpy_gl_scanout_texture(dcl, backing_id, 2136 backing_y_0_top, 2137 backing_width, backing_height, 2138 x, y, width, height, 2139 d3d_tex2d); 2140 } 2141 } 2142 } 2143 2144 void dpy_gl_scanout_dmabuf(QemuConsole *con, 2145 QemuDmaBuf *dmabuf) 2146 { 2147 DisplayState *s = con->ds; 2148 DisplayChangeListener *dcl; 2149 2150 con->scanout.kind = SCANOUT_DMABUF; 2151 con->scanout.dmabuf = dmabuf; 2152 QLIST_FOREACH(dcl, &s->listeners, next) { 2153 if (con != (dcl->con ? dcl->con : active_console)) { 2154 continue; 2155 } 2156 if (dcl->ops->dpy_gl_scanout_dmabuf) { 2157 dcl->ops->dpy_gl_scanout_dmabuf(dcl, dmabuf); 2158 } 2159 } 2160 } 2161 2162 void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf, 2163 bool have_hot, uint32_t hot_x, uint32_t hot_y) 2164 { 2165 DisplayState *s = con->ds; 2166 DisplayChangeListener *dcl; 2167 2168 QLIST_FOREACH(dcl, &s->listeners, next) { 2169 if (con != (dcl->con ? dcl->con : active_console)) { 2170 continue; 2171 } 2172 if (dcl->ops->dpy_gl_cursor_dmabuf) { 2173 dcl->ops->dpy_gl_cursor_dmabuf(dcl, dmabuf, 2174 have_hot, hot_x, hot_y); 2175 } 2176 } 2177 } 2178 2179 void dpy_gl_cursor_position(QemuConsole *con, 2180 uint32_t pos_x, uint32_t pos_y) 2181 { 2182 DisplayState *s = con->ds; 2183 DisplayChangeListener *dcl; 2184 2185 QLIST_FOREACH(dcl, &s->listeners, next) { 2186 if (con != (dcl->con ? dcl->con : active_console)) { 2187 continue; 2188 } 2189 if (dcl->ops->dpy_gl_cursor_position) { 2190 dcl->ops->dpy_gl_cursor_position(dcl, pos_x, pos_y); 2191 } 2192 } 2193 } 2194 2195 void dpy_gl_release_dmabuf(QemuConsole *con, 2196 QemuDmaBuf *dmabuf) 2197 { 2198 DisplayState *s = con->ds; 2199 DisplayChangeListener *dcl; 2200 2201 QLIST_FOREACH(dcl, &s->listeners, next) { 2202 if (con != (dcl->con ? dcl->con : active_console)) { 2203 continue; 2204 } 2205 if (dcl->ops->dpy_gl_release_dmabuf) { 2206 dcl->ops->dpy_gl_release_dmabuf(dcl, dmabuf); 2207 } 2208 } 2209 } 2210 2211 void dpy_gl_update(QemuConsole *con, 2212 uint32_t x, uint32_t y, uint32_t w, uint32_t h) 2213 { 2214 DisplayState *s = con->ds; 2215 DisplayChangeListener *dcl; 2216 2217 assert(con->gl); 2218 2219 graphic_hw_gl_block(con, true); 2220 QLIST_FOREACH(dcl, &s->listeners, next) { 2221 if (con != (dcl->con ? dcl->con : active_console)) { 2222 continue; 2223 } 2224 if (dcl->ops->dpy_gl_update) { 2225 dcl->ops->dpy_gl_update(dcl, x, y, w, h); 2226 } 2227 } 2228 graphic_hw_gl_block(con, false); 2229 } 2230 2231 /***********************************************************/ 2232 /* register display */ 2233 2234 /* console.c internal use only */ 2235 static DisplayState *get_alloc_displaystate(void) 2236 { 2237 if (!display_state) { 2238 display_state = g_new0(DisplayState, 1); 2239 cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 2240 text_console_update_cursor, NULL); 2241 } 2242 return display_state; 2243 } 2244 2245 /* 2246 * Called by main(), after creating QemuConsoles 2247 * and before initializing ui (sdl/vnc/...). 2248 */ 2249 DisplayState *init_displaystate(void) 2250 { 2251 gchar *name; 2252 QemuConsole *con; 2253 2254 get_alloc_displaystate(); 2255 QTAILQ_FOREACH(con, &consoles, next) { 2256 if (con->console_type != GRAPHIC_CONSOLE && 2257 con->ds == NULL) { 2258 text_console_do_init(con->chr, display_state); 2259 } 2260 2261 /* Hook up into the qom tree here (not in new_console()), once 2262 * all QemuConsoles are created and the order / numbering 2263 * doesn't change any more */ 2264 name = g_strdup_printf("console[%d]", con->index); 2265 object_property_add_child(container_get(object_get_root(), "/backend"), 2266 name, OBJECT(con)); 2267 g_free(name); 2268 } 2269 2270 return display_state; 2271 } 2272 2273 void graphic_console_set_hwops(QemuConsole *con, 2274 const GraphicHwOps *hw_ops, 2275 void *opaque) 2276 { 2277 con->hw_ops = hw_ops; 2278 con->hw = opaque; 2279 } 2280 2281 QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head, 2282 const GraphicHwOps *hw_ops, 2283 void *opaque) 2284 { 2285 static const char noinit[] = 2286 "Guest has not initialized the display (yet)."; 2287 int width = 640; 2288 int height = 480; 2289 QemuConsole *s; 2290 DisplayState *ds; 2291 DisplaySurface *surface; 2292 2293 ds = get_alloc_displaystate(); 2294 s = qemu_console_lookup_unused(); 2295 if (s) { 2296 trace_console_gfx_reuse(s->index); 2297 width = qemu_console_get_width(s, 0); 2298 height = qemu_console_get_height(s, 0); 2299 } else { 2300 trace_console_gfx_new(); 2301 s = new_console(ds, GRAPHIC_CONSOLE, head); 2302 s->ui_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 2303 dpy_set_ui_info_timer, s); 2304 } 2305 graphic_console_set_hwops(s, hw_ops, opaque); 2306 if (dev) { 2307 object_property_set_link(OBJECT(s), "device", OBJECT(dev), 2308 &error_abort); 2309 } 2310 2311 surface = qemu_create_placeholder_surface(width, height, noinit); 2312 dpy_gfx_replace_surface(s, surface); 2313 s->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME, 2314 graphic_hw_gl_unblock_timer, s); 2315 return s; 2316 } 2317 2318 static const GraphicHwOps unused_ops = { 2319 /* no callbacks */ 2320 }; 2321 2322 void graphic_console_close(QemuConsole *con) 2323 { 2324 static const char unplugged[] = 2325 "Guest display has been unplugged"; 2326 DisplaySurface *surface; 2327 int width = qemu_console_get_width(con, 640); 2328 int height = qemu_console_get_height(con, 480); 2329 2330 trace_console_gfx_close(con->index); 2331 object_property_set_link(OBJECT(con), "device", NULL, &error_abort); 2332 graphic_console_set_hwops(con, &unused_ops, NULL); 2333 2334 if (con->gl) { 2335 dpy_gl_scanout_disable(con); 2336 } 2337 surface = qemu_create_placeholder_surface(width, height, unplugged); 2338 dpy_gfx_replace_surface(con, surface); 2339 } 2340 2341 QemuConsole *qemu_console_lookup_by_index(unsigned int index) 2342 { 2343 QemuConsole *con; 2344 2345 QTAILQ_FOREACH(con, &consoles, next) { 2346 if (con->index == index) { 2347 return con; 2348 } 2349 } 2350 return NULL; 2351 } 2352 2353 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head) 2354 { 2355 QemuConsole *con; 2356 Object *obj; 2357 uint32_t h; 2358 2359 QTAILQ_FOREACH(con, &consoles, next) { 2360 obj = object_property_get_link(OBJECT(con), 2361 "device", &error_abort); 2362 if (DEVICE(obj) != dev) { 2363 continue; 2364 } 2365 h = object_property_get_uint(OBJECT(con), 2366 "head", &error_abort); 2367 if (h != head) { 2368 continue; 2369 } 2370 return con; 2371 } 2372 return NULL; 2373 } 2374 2375 QemuConsole *qemu_console_lookup_by_device_name(const char *device_id, 2376 uint32_t head, Error **errp) 2377 { 2378 DeviceState *dev; 2379 QemuConsole *con; 2380 2381 dev = qdev_find_recursive(sysbus_get_default(), device_id); 2382 if (dev == NULL) { 2383 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 2384 "Device '%s' not found", device_id); 2385 return NULL; 2386 } 2387 2388 con = qemu_console_lookup_by_device(dev, head); 2389 if (con == NULL) { 2390 error_setg(errp, "Device %s (head %d) is not bound to a QemuConsole", 2391 device_id, head); 2392 return NULL; 2393 } 2394 2395 return con; 2396 } 2397 2398 QemuConsole *qemu_console_lookup_unused(void) 2399 { 2400 QemuConsole *con; 2401 Object *obj; 2402 2403 QTAILQ_FOREACH(con, &consoles, next) { 2404 if (con->hw_ops != &unused_ops) { 2405 continue; 2406 } 2407 obj = object_property_get_link(OBJECT(con), 2408 "device", &error_abort); 2409 if (obj != NULL) { 2410 continue; 2411 } 2412 return con; 2413 } 2414 return NULL; 2415 } 2416 2417 QEMUCursor *qemu_console_get_cursor(QemuConsole *con) 2418 { 2419 if (con == NULL) { 2420 con = active_console; 2421 } 2422 return con ? con->cursor : NULL; 2423 } 2424 2425 bool qemu_console_is_visible(QemuConsole *con) 2426 { 2427 return (con == active_console) || (con->dcls > 0); 2428 } 2429 2430 bool qemu_console_is_graphic(QemuConsole *con) 2431 { 2432 if (con == NULL) { 2433 con = active_console; 2434 } 2435 return con && (con->console_type == GRAPHIC_CONSOLE); 2436 } 2437 2438 bool qemu_console_is_fixedsize(QemuConsole *con) 2439 { 2440 if (con == NULL) { 2441 con = active_console; 2442 } 2443 return con && (con->console_type != TEXT_CONSOLE); 2444 } 2445 2446 bool qemu_console_is_gl_blocked(QemuConsole *con) 2447 { 2448 assert(con != NULL); 2449 return con->gl_block; 2450 } 2451 2452 bool qemu_console_is_multihead(DeviceState *dev) 2453 { 2454 QemuConsole *con; 2455 Object *obj; 2456 uint32_t f = 0xffffffff; 2457 uint32_t h; 2458 2459 QTAILQ_FOREACH(con, &consoles, next) { 2460 obj = object_property_get_link(OBJECT(con), 2461 "device", &error_abort); 2462 if (DEVICE(obj) != dev) { 2463 continue; 2464 } 2465 2466 h = object_property_get_uint(OBJECT(con), 2467 "head", &error_abort); 2468 if (f == 0xffffffff) { 2469 f = h; 2470 } else if (h != f) { 2471 return true; 2472 } 2473 } 2474 return false; 2475 } 2476 2477 char *qemu_console_get_label(QemuConsole *con) 2478 { 2479 if (con->console_type == GRAPHIC_CONSOLE) { 2480 if (con->device) { 2481 DeviceState *dev; 2482 bool multihead; 2483 2484 dev = DEVICE(con->device); 2485 multihead = qemu_console_is_multihead(dev); 2486 if (multihead) { 2487 return g_strdup_printf("%s.%d", dev->id ? 2488 dev->id : 2489 object_get_typename(con->device), 2490 con->head); 2491 } else { 2492 return g_strdup_printf("%s", dev->id ? 2493 dev->id : 2494 object_get_typename(con->device)); 2495 } 2496 } 2497 return g_strdup("VGA"); 2498 } else { 2499 if (con->chr && con->chr->label) { 2500 return g_strdup(con->chr->label); 2501 } 2502 return g_strdup_printf("vc%d", con->index); 2503 } 2504 } 2505 2506 int qemu_console_get_index(QemuConsole *con) 2507 { 2508 if (con == NULL) { 2509 con = active_console; 2510 } 2511 return con ? con->index : -1; 2512 } 2513 2514 uint32_t qemu_console_get_head(QemuConsole *con) 2515 { 2516 if (con == NULL) { 2517 con = active_console; 2518 } 2519 return con ? con->head : -1; 2520 } 2521 2522 int qemu_console_get_width(QemuConsole *con, int fallback) 2523 { 2524 if (con == NULL) { 2525 con = active_console; 2526 } 2527 if (con == NULL) { 2528 return fallback; 2529 } 2530 switch (con->scanout.kind) { 2531 case SCANOUT_DMABUF: 2532 return con->scanout.dmabuf->width; 2533 case SCANOUT_TEXTURE: 2534 return con->scanout.texture.width; 2535 case SCANOUT_SURFACE: 2536 return surface_width(con->surface); 2537 default: 2538 return fallback; 2539 } 2540 } 2541 2542 int qemu_console_get_height(QemuConsole *con, int fallback) 2543 { 2544 if (con == NULL) { 2545 con = active_console; 2546 } 2547 if (con == NULL) { 2548 return fallback; 2549 } 2550 switch (con->scanout.kind) { 2551 case SCANOUT_DMABUF: 2552 return con->scanout.dmabuf->height; 2553 case SCANOUT_TEXTURE: 2554 return con->scanout.texture.height; 2555 case SCANOUT_SURFACE: 2556 return surface_height(con->surface); 2557 default: 2558 return fallback; 2559 } 2560 } 2561 2562 static void vc_chr_accept_input(Chardev *chr) 2563 { 2564 VCChardev *drv = VC_CHARDEV(chr); 2565 QemuConsole *s = drv->console; 2566 2567 kbd_send_chars(s); 2568 } 2569 2570 static void vc_chr_set_echo(Chardev *chr, bool echo) 2571 { 2572 VCChardev *drv = VC_CHARDEV(chr); 2573 QemuConsole *s = drv->console; 2574 2575 s->echo = echo; 2576 } 2577 2578 static void text_console_update_cursor_timer(void) 2579 { 2580 timer_mod(cursor_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) 2581 + CONSOLE_CURSOR_PERIOD / 2); 2582 } 2583 2584 static void text_console_update_cursor(void *opaque) 2585 { 2586 QemuConsole *s; 2587 int count = 0; 2588 2589 cursor_visible_phase = !cursor_visible_phase; 2590 2591 QTAILQ_FOREACH(s, &consoles, next) { 2592 if (qemu_console_is_graphic(s) || 2593 !qemu_console_is_visible(s)) { 2594 continue; 2595 } 2596 count++; 2597 graphic_hw_invalidate(s); 2598 } 2599 2600 if (count) { 2601 text_console_update_cursor_timer(); 2602 } 2603 } 2604 2605 static const GraphicHwOps text_console_ops = { 2606 .invalidate = text_console_invalidate, 2607 .text_update = text_console_update, 2608 }; 2609 2610 static void text_console_do_init(Chardev *chr, DisplayState *ds) 2611 { 2612 VCChardev *drv = VC_CHARDEV(chr); 2613 QemuConsole *s = drv->console; 2614 int g_width = 80 * FONT_WIDTH; 2615 int g_height = 24 * FONT_HEIGHT; 2616 2617 fifo8_create(&s->out_fifo, 16); 2618 s->ds = ds; 2619 2620 s->y_displayed = 0; 2621 s->y_base = 0; 2622 s->total_height = DEFAULT_BACKSCROLL; 2623 s->x = 0; 2624 s->y = 0; 2625 if (s->scanout.kind != SCANOUT_SURFACE) { 2626 if (active_console && active_console->scanout.kind == SCANOUT_SURFACE) { 2627 g_width = qemu_console_get_width(active_console, g_width); 2628 g_height = qemu_console_get_height(active_console, g_height); 2629 } 2630 s->surface = qemu_create_displaysurface(g_width, g_height); 2631 s->scanout.kind = SCANOUT_SURFACE; 2632 } 2633 2634 s->hw_ops = &text_console_ops; 2635 s->hw = s; 2636 2637 /* Set text attribute defaults */ 2638 s->t_attrib_default.bold = 0; 2639 s->t_attrib_default.uline = 0; 2640 s->t_attrib_default.blink = 0; 2641 s->t_attrib_default.invers = 0; 2642 s->t_attrib_default.unvisible = 0; 2643 s->t_attrib_default.fgcol = QEMU_COLOR_WHITE; 2644 s->t_attrib_default.bgcol = QEMU_COLOR_BLACK; 2645 /* set current text attributes to default */ 2646 s->t_attrib = s->t_attrib_default; 2647 text_console_resize(s); 2648 2649 if (chr->label) { 2650 char *msg; 2651 2652 s->t_attrib.bgcol = QEMU_COLOR_BLUE; 2653 msg = g_strdup_printf("%s console\r\n", chr->label); 2654 vc_chr_write(chr, (uint8_t *)msg, strlen(msg)); 2655 g_free(msg); 2656 s->t_attrib = s->t_attrib_default; 2657 } 2658 2659 qemu_chr_be_event(chr, CHR_EVENT_OPENED); 2660 } 2661 2662 static void vc_chr_open(Chardev *chr, 2663 ChardevBackend *backend, 2664 bool *be_opened, 2665 Error **errp) 2666 { 2667 ChardevVC *vc = backend->u.vc.data; 2668 VCChardev *drv = VC_CHARDEV(chr); 2669 QemuConsole *s; 2670 unsigned width = 0; 2671 unsigned height = 0; 2672 2673 if (vc->has_width) { 2674 width = vc->width; 2675 } else if (vc->has_cols) { 2676 width = vc->cols * FONT_WIDTH; 2677 } 2678 2679 if (vc->has_height) { 2680 height = vc->height; 2681 } else if (vc->has_rows) { 2682 height = vc->rows * FONT_HEIGHT; 2683 } 2684 2685 trace_console_txt_new(width, height); 2686 if (width == 0 || height == 0) { 2687 s = new_console(NULL, TEXT_CONSOLE, 0); 2688 } else { 2689 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE, 0); 2690 s->scanout.kind = SCANOUT_SURFACE; 2691 s->surface = qemu_create_displaysurface(width, height); 2692 } 2693 2694 if (!s) { 2695 error_setg(errp, "cannot create text console"); 2696 return; 2697 } 2698 2699 s->chr = chr; 2700 drv->console = s; 2701 2702 if (display_state) { 2703 text_console_do_init(chr, display_state); 2704 } 2705 2706 /* console/chardev init sometimes completes elsewhere in a 2nd 2707 * stage, so defer OPENED events until they are fully initialized 2708 */ 2709 *be_opened = false; 2710 } 2711 2712 void qemu_console_resize(QemuConsole *s, int width, int height) 2713 { 2714 DisplaySurface *surface = qemu_console_surface(s); 2715 2716 assert(s->console_type == GRAPHIC_CONSOLE); 2717 2718 if ((s->scanout.kind != SCANOUT_SURFACE || 2719 (surface && surface->flags & QEMU_ALLOCATED_FLAG)) && 2720 qemu_console_get_width(s, -1) == width && 2721 qemu_console_get_height(s, -1) == height) { 2722 return; 2723 } 2724 2725 surface = qemu_create_displaysurface(width, height); 2726 dpy_gfx_replace_surface(s, surface); 2727 } 2728 2729 DisplaySurface *qemu_console_surface(QemuConsole *console) 2730 { 2731 switch (console->scanout.kind) { 2732 case SCANOUT_SURFACE: 2733 return console->surface; 2734 default: 2735 return NULL; 2736 } 2737 } 2738 2739 PixelFormat qemu_default_pixelformat(int bpp) 2740 { 2741 pixman_format_code_t fmt = qemu_default_pixman_format(bpp, true); 2742 PixelFormat pf = qemu_pixelformat_from_pixman(fmt); 2743 return pf; 2744 } 2745 2746 static QemuDisplay *dpys[DISPLAY_TYPE__MAX]; 2747 2748 void qemu_display_register(QemuDisplay *ui) 2749 { 2750 assert(ui->type < DISPLAY_TYPE__MAX); 2751 dpys[ui->type] = ui; 2752 } 2753 2754 bool qemu_display_find_default(DisplayOptions *opts) 2755 { 2756 static DisplayType prio[] = { 2757 #if defined(CONFIG_GTK) 2758 DISPLAY_TYPE_GTK, 2759 #endif 2760 #if defined(CONFIG_SDL) 2761 DISPLAY_TYPE_SDL, 2762 #endif 2763 #if defined(CONFIG_COCOA) 2764 DISPLAY_TYPE_COCOA 2765 #endif 2766 }; 2767 int i; 2768 2769 for (i = 0; i < (int)ARRAY_SIZE(prio); i++) { 2770 if (dpys[prio[i]] == NULL) { 2771 Error *local_err = NULL; 2772 int rv = ui_module_load(DisplayType_str(prio[i]), &local_err); 2773 if (rv < 0) { 2774 error_report_err(local_err); 2775 } 2776 } 2777 if (dpys[prio[i]] == NULL) { 2778 continue; 2779 } 2780 opts->type = prio[i]; 2781 return true; 2782 } 2783 return false; 2784 } 2785 2786 void qemu_display_early_init(DisplayOptions *opts) 2787 { 2788 assert(opts->type < DISPLAY_TYPE__MAX); 2789 if (opts->type == DISPLAY_TYPE_NONE) { 2790 return; 2791 } 2792 if (dpys[opts->type] == NULL) { 2793 Error *local_err = NULL; 2794 int rv = ui_module_load(DisplayType_str(opts->type), &local_err); 2795 if (rv < 0) { 2796 error_report_err(local_err); 2797 } 2798 } 2799 if (dpys[opts->type] == NULL) { 2800 error_report("Display '%s' is not available.", 2801 DisplayType_str(opts->type)); 2802 exit(1); 2803 } 2804 if (dpys[opts->type]->early_init) { 2805 dpys[opts->type]->early_init(opts); 2806 } 2807 } 2808 2809 void qemu_display_init(DisplayState *ds, DisplayOptions *opts) 2810 { 2811 assert(opts->type < DISPLAY_TYPE__MAX); 2812 if (opts->type == DISPLAY_TYPE_NONE) { 2813 return; 2814 } 2815 assert(dpys[opts->type] != NULL); 2816 dpys[opts->type]->init(ds, opts); 2817 } 2818 2819 void qemu_display_help(void) 2820 { 2821 int idx; 2822 2823 printf("Available display backend types:\n"); 2824 printf("none\n"); 2825 for (idx = DISPLAY_TYPE_NONE; idx < DISPLAY_TYPE__MAX; idx++) { 2826 if (!dpys[idx]) { 2827 Error *local_err = NULL; 2828 int rv = ui_module_load(DisplayType_str(idx), &local_err); 2829 if (rv < 0) { 2830 error_report_err(local_err); 2831 } 2832 } 2833 if (dpys[idx]) { 2834 printf("%s\n", DisplayType_str(dpys[idx]->type)); 2835 } 2836 } 2837 } 2838 2839 void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp) 2840 { 2841 int val; 2842 ChardevVC *vc; 2843 2844 backend->type = CHARDEV_BACKEND_KIND_VC; 2845 vc = backend->u.vc.data = g_new0(ChardevVC, 1); 2846 qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc)); 2847 2848 val = qemu_opt_get_number(opts, "width", 0); 2849 if (val != 0) { 2850 vc->has_width = true; 2851 vc->width = val; 2852 } 2853 2854 val = qemu_opt_get_number(opts, "height", 0); 2855 if (val != 0) { 2856 vc->has_height = true; 2857 vc->height = val; 2858 } 2859 2860 val = qemu_opt_get_number(opts, "cols", 0); 2861 if (val != 0) { 2862 vc->has_cols = true; 2863 vc->cols = val; 2864 } 2865 2866 val = qemu_opt_get_number(opts, "rows", 0); 2867 if (val != 0) { 2868 vc->has_rows = true; 2869 vc->rows = val; 2870 } 2871 } 2872 2873 static const TypeInfo qemu_console_info = { 2874 .name = TYPE_QEMU_CONSOLE, 2875 .parent = TYPE_OBJECT, 2876 .instance_size = sizeof(QemuConsole), 2877 .class_size = sizeof(QemuConsoleClass), 2878 }; 2879 2880 static void char_vc_class_init(ObjectClass *oc, void *data) 2881 { 2882 ChardevClass *cc = CHARDEV_CLASS(oc); 2883 2884 cc->parse = qemu_chr_parse_vc; 2885 cc->open = vc_chr_open; 2886 cc->chr_write = vc_chr_write; 2887 cc->chr_accept_input = vc_chr_accept_input; 2888 cc->chr_set_echo = vc_chr_set_echo; 2889 } 2890 2891 static const TypeInfo char_vc_type_info = { 2892 .name = TYPE_CHARDEV_VC, 2893 .parent = TYPE_CHARDEV, 2894 .instance_size = sizeof(VCChardev), 2895 .class_init = char_vc_class_init, 2896 }; 2897 2898 void qemu_console_early_init(void) 2899 { 2900 /* set the default vc driver */ 2901 if (!object_class_by_name(TYPE_CHARDEV_VC)) { 2902 type_register(&char_vc_type_info); 2903 } 2904 } 2905 2906 static void register_types(void) 2907 { 2908 type_register_static(&qemu_console_info); 2909 } 2910 2911 type_init(register_types); 2912