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