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