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