]> git.proxmox.com Git - mirror_qemu.git/blob - ui/console.c
projects / mirror_qemu.git / blob
? search:


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