2 * QEMU graphical console
4 * Copyright (c) 2004 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "ui/console.h"
27 #include "hw/qdev-core.h"
28 #include "qapi/error.h"
29 #include "qapi/qapi-commands-ui.h"
30 #include "qemu/module.h"
31 #include "qemu/option.h"
32 #include "qemu/timer.h"
33 #include "chardev/char-fe.h"
35 #include "exec/memory.h"
36 #include "io/channel-file.h"
37 #include "qom/object.h"
39 #define DEFAULT_BACKSCROLL 512
40 #define CONSOLE_CURSOR_PERIOD 500
42 typedef struct TextAttributes
{
52 typedef struct TextCell
{
54 TextAttributes t_attrib
;
57 #define MAX_ESC_PARAMS 3
65 typedef struct QEMUFIFO
{
68 int count
, wptr
, rptr
;
71 static int qemu_fifo_write(QEMUFIFO
*f
, const uint8_t *buf
, int len1
)
75 l
= f
->buf_size
- f
->count
;
80 l
= f
->buf_size
- f
->wptr
;
83 memcpy(f
->buf
+ f
->wptr
, buf
, l
);
85 if (f
->wptr
>= f
->buf_size
)
94 static int qemu_fifo_read(QEMUFIFO
*f
, uint8_t *buf
, int len1
)
102 l
= f
->buf_size
- f
->rptr
;
105 memcpy(buf
, f
->buf
+ f
->rptr
, l
);
107 if (f
->rptr
>= f
->buf_size
)
119 TEXT_CONSOLE_FIXED_SIZE
126 console_type_t console_type
;
128 DisplaySurface
*surface
;
130 DisplayChangeListener
*gl
;
134 /* Graphic console state. */
139 const GraphicHwOps
*hw_ops
;
142 /* Text console state */
146 int backscroll_height
;
148 int x_saved
, y_saved
;
151 TextAttributes t_attrib_default
; /* default text attributes */
152 TextAttributes t_attrib
; /* currently active text attributes */
154 int text_x
[2], text_y
[2], cursor_invalidate
;
163 int esc_params
[MAX_ESC_PARAMS
];
167 /* fifo for key pressed */
169 uint8_t out_fifo_buf
[16];
170 QEMUTimer
*kbd_timer
;
173 QTAILQ_ENTRY(QemuConsole
) next
;
176 struct DisplayState
{
177 QEMUTimer
*gui_timer
;
178 uint64_t last_update
;
179 uint64_t update_interval
;
184 QLIST_HEAD(, DisplayChangeListener
) listeners
;
187 static DisplayState
*display_state
;
188 static QemuConsole
*active_console
;
189 static QTAILQ_HEAD(, QemuConsole
) consoles
=
190 QTAILQ_HEAD_INITIALIZER(consoles
);
191 static bool cursor_visible_phase
;
192 static QEMUTimer
*cursor_timer
;
194 static void text_console_do_init(Chardev
*chr
, DisplayState
*ds
);
195 static void dpy_refresh(DisplayState
*s
);
196 static DisplayState
*get_alloc_displaystate(void);
197 static void text_console_update_cursor_timer(void);
198 static void text_console_update_cursor(void *opaque
);
200 static void gui_update(void *opaque
)
202 uint64_t interval
= GUI_REFRESH_INTERVAL_IDLE
;
203 uint64_t dcl_interval
;
204 DisplayState
*ds
= opaque
;
205 DisplayChangeListener
*dcl
;
208 ds
->refreshing
= true;
210 ds
->refreshing
= false;
212 QLIST_FOREACH(dcl
, &ds
->listeners
, next
) {
213 dcl_interval
= dcl
->update_interval
?
214 dcl
->update_interval
: GUI_REFRESH_INTERVAL_DEFAULT
;
215 if (interval
> dcl_interval
) {
216 interval
= dcl_interval
;
219 if (ds
->update_interval
!= interval
) {
220 ds
->update_interval
= interval
;
221 QTAILQ_FOREACH(con
, &consoles
, next
) {
222 if (con
->hw_ops
->update_interval
) {
223 con
->hw_ops
->update_interval(con
->hw
, interval
);
226 trace_console_refresh(interval
);
228 ds
->last_update
= qemu_clock_get_ms(QEMU_CLOCK_REALTIME
);
229 timer_mod(ds
->gui_timer
, ds
->last_update
+ interval
);
232 static void gui_setup_refresh(DisplayState
*ds
)
234 DisplayChangeListener
*dcl
;
235 bool need_timer
= false;
236 bool have_gfx
= false;
237 bool have_text
= false;
239 QLIST_FOREACH(dcl
, &ds
->listeners
, next
) {
240 if (dcl
->ops
->dpy_refresh
!= NULL
) {
243 if (dcl
->ops
->dpy_gfx_update
!= NULL
) {
246 if (dcl
->ops
->dpy_text_update
!= NULL
) {
251 if (need_timer
&& ds
->gui_timer
== NULL
) {
252 ds
->gui_timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, gui_update
, ds
);
253 timer_mod(ds
->gui_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
));
255 if (!need_timer
&& ds
->gui_timer
!= NULL
) {
256 timer_del(ds
->gui_timer
);
257 timer_free(ds
->gui_timer
);
258 ds
->gui_timer
= NULL
;
261 ds
->have_gfx
= have_gfx
;
262 ds
->have_text
= have_text
;
265 void graphic_hw_update_done(QemuConsole
*con
)
267 qemu_co_queue_restart_all(&con
->dump_queue
);
270 void graphic_hw_update(QemuConsole
*con
)
273 con
= con
? con
: active_console
;
277 if (con
->hw_ops
->gfx_update
) {
278 con
->hw_ops
->gfx_update(con
->hw
);
279 async
= con
->hw_ops
->gfx_update_async
;
282 graphic_hw_update_done(con
);
286 void graphic_hw_gl_block(QemuConsole
*con
, bool block
)
290 con
->gl_block
= block
;
291 if (con
->hw_ops
->gl_block
) {
292 con
->hw_ops
->gl_block(con
->hw
, block
);
296 int qemu_console_get_window_id(QemuConsole
*con
)
298 return con
->window_id
;
301 void qemu_console_set_window_id(QemuConsole
*con
, int window_id
)
303 con
->window_id
= window_id
;
306 void graphic_hw_invalidate(QemuConsole
*con
)
309 con
= active_console
;
311 if (con
&& con
->hw_ops
->invalidate
) {
312 con
->hw_ops
->invalidate(con
->hw
);
316 static bool ppm_save(int fd
, pixman_image_t
*image
, Error
**errp
)
318 int width
= pixman_image_get_width(image
);
319 int height
= pixman_image_get_height(image
);
320 g_autoptr(Object
) ioc
= OBJECT(qio_channel_file_new_fd(fd
));
321 g_autofree
char *header
= NULL
;
322 g_autoptr(pixman_image_t
) linebuf
= NULL
;
325 trace_ppm_save(fd
, image
);
327 header
= g_strdup_printf("P6\n%d %d\n%d\n", width
, height
, 255);
328 if (qio_channel_write_all(QIO_CHANNEL(ioc
),
329 header
, strlen(header
), errp
) < 0) {
333 linebuf
= qemu_pixman_linebuf_create(PIXMAN_BE_r8g8b8
, width
);
334 for (y
= 0; y
< height
; y
++) {
335 qemu_pixman_linebuf_fill(linebuf
, image
, width
, 0, y
);
336 if (qio_channel_write_all(QIO_CHANNEL(ioc
),
337 (char *)pixman_image_get_data(linebuf
),
338 pixman_image_get_stride(linebuf
), errp
) < 0) {
346 static void graphic_hw_update_bh(void *con
)
348 graphic_hw_update(con
);
351 /* Safety: coroutine-only, concurrent-coroutine safe, main thread only */
353 qmp_screendump(const char *filename
, bool has_device
, const char *device
,
354 bool has_head
, int64_t head
, Error
**errp
)
356 g_autoptr(pixman_image_t
) image
= NULL
;
358 DisplaySurface
*surface
;
362 con
= qemu_console_lookup_by_device_name(device
, has_head
? head
: 0,
369 error_setg(errp
, "'head' must be specified together with 'device'");
372 con
= qemu_console_lookup_by_index(0);
374 error_setg(errp
, "There is no console to take a screendump from");
379 if (qemu_co_queue_empty(&con
->dump_queue
)) {
380 /* Defer the update, it will restart the pending coroutines */
381 aio_bh_schedule_oneshot(qemu_get_aio_context(),
382 graphic_hw_update_bh
, con
);
384 qemu_co_queue_wait(&con
->dump_queue
, NULL
);
387 * All pending coroutines are woken up, while the BQL is held. No
388 * further graphic update are possible until it is released. Take
389 * an image ref before that.
391 surface
= qemu_console_surface(con
);
393 error_setg(errp
, "no surface");
396 image
= pixman_image_ref(surface
->image
);
398 fd
= qemu_open_old(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, 0666);
400 error_setg(errp
, "failed to open file '%s': %s", filename
,
406 * The image content could potentially be updated as the coroutine
407 * yields and releases the BQL. It could produce corrupted dump, but
408 * it should be otherwise safe.
410 if (!ppm_save(fd
, image
, errp
)) {
411 qemu_unlink(filename
);
415 void graphic_hw_text_update(QemuConsole
*con
, console_ch_t
*chardata
)
418 con
= active_console
;
420 if (con
&& con
->hw_ops
->text_update
) {
421 con
->hw_ops
->text_update(con
->hw
, chardata
);
425 static void vga_fill_rect(QemuConsole
*con
,
426 int posx
, int posy
, int width
, int height
,
427 pixman_color_t color
)
429 DisplaySurface
*surface
= qemu_console_surface(con
);
430 pixman_rectangle16_t rect
= {
431 .x
= posx
, .y
= posy
, .width
= width
, .height
= height
434 pixman_image_fill_rectangles(PIXMAN_OP_SRC
, surface
->image
,
438 /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */
439 static void vga_bitblt(QemuConsole
*con
,
440 int xs
, int ys
, int xd
, int yd
, int w
, int h
)
442 DisplaySurface
*surface
= qemu_console_surface(con
);
444 pixman_image_composite(PIXMAN_OP_SRC
,
445 surface
->image
, NULL
, surface
->image
,
446 xs
, ys
, 0, 0, xd
, yd
, w
, h
);
449 /***********************************************************/
450 /* basic char display */
452 #define FONT_HEIGHT 16
457 #define QEMU_RGB(r, g, b) \
458 { .red = r << 8, .green = g << 8, .blue = b << 8, .alpha = 0xffff }
460 static const pixman_color_t color_table_rgb
[2][8] = {
462 [QEMU_COLOR_BLACK
] = QEMU_RGB(0x00, 0x00, 0x00), /* black */
463 [QEMU_COLOR_BLUE
] = QEMU_RGB(0x00, 0x00, 0xaa), /* blue */
464 [QEMU_COLOR_GREEN
] = QEMU_RGB(0x00, 0xaa, 0x00), /* green */
465 [QEMU_COLOR_CYAN
] = QEMU_RGB(0x00, 0xaa, 0xaa), /* cyan */
466 [QEMU_COLOR_RED
] = QEMU_RGB(0xaa, 0x00, 0x00), /* red */
467 [QEMU_COLOR_MAGENTA
] = QEMU_RGB(0xaa, 0x00, 0xaa), /* magenta */
468 [QEMU_COLOR_YELLOW
] = QEMU_RGB(0xaa, 0xaa, 0x00), /* yellow */
469 [QEMU_COLOR_WHITE
] = QEMU_RGB(0xaa, 0xaa, 0xaa), /* white */
472 [QEMU_COLOR_BLACK
] = QEMU_RGB(0x00, 0x00, 0x00), /* black */
473 [QEMU_COLOR_BLUE
] = QEMU_RGB(0x00, 0x00, 0xff), /* blue */
474 [QEMU_COLOR_GREEN
] = QEMU_RGB(0x00, 0xff, 0x00), /* green */
475 [QEMU_COLOR_CYAN
] = QEMU_RGB(0x00, 0xff, 0xff), /* cyan */
476 [QEMU_COLOR_RED
] = QEMU_RGB(0xff, 0x00, 0x00), /* red */
477 [QEMU_COLOR_MAGENTA
] = QEMU_RGB(0xff, 0x00, 0xff), /* magenta */
478 [QEMU_COLOR_YELLOW
] = QEMU_RGB(0xff, 0xff, 0x00), /* yellow */
479 [QEMU_COLOR_WHITE
] = QEMU_RGB(0xff, 0xff, 0xff), /* white */
483 static void vga_putcharxy(QemuConsole
*s
, int x
, int y
, int ch
,
484 TextAttributes
*t_attrib
)
486 static pixman_image_t
*glyphs
[256];
487 DisplaySurface
*surface
= qemu_console_surface(s
);
488 pixman_color_t fgcol
, bgcol
;
490 if (t_attrib
->invers
) {
491 bgcol
= color_table_rgb
[t_attrib
->bold
][t_attrib
->fgcol
];
492 fgcol
= color_table_rgb
[t_attrib
->bold
][t_attrib
->bgcol
];
494 fgcol
= color_table_rgb
[t_attrib
->bold
][t_attrib
->fgcol
];
495 bgcol
= color_table_rgb
[t_attrib
->bold
][t_attrib
->bgcol
];
499 glyphs
[ch
] = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT
, vgafont16
, ch
);
501 qemu_pixman_glyph_render(glyphs
[ch
], surface
->image
,
502 &fgcol
, &bgcol
, x
, y
, FONT_WIDTH
, FONT_HEIGHT
);
505 static void text_console_resize(QemuConsole
*s
)
507 TextCell
*cells
, *c
, *c1
;
508 int w1
, x
, y
, last_width
;
510 last_width
= s
->width
;
511 s
->width
= surface_width(s
->surface
) / FONT_WIDTH
;
512 s
->height
= surface_height(s
->surface
) / FONT_HEIGHT
;
518 cells
= g_new(TextCell
, s
->width
* s
->total_height
+ 1);
519 for(y
= 0; y
< s
->total_height
; y
++) {
520 c
= &cells
[y
* s
->width
];
522 c1
= &s
->cells
[y
* last_width
];
523 for(x
= 0; x
< w1
; x
++) {
527 for(x
= w1
; x
< s
->width
; x
++) {
529 c
->t_attrib
= s
->t_attrib_default
;
537 static inline void text_update_xy(QemuConsole
*s
, int x
, int y
)
539 s
->text_x
[0] = MIN(s
->text_x
[0], x
);
540 s
->text_x
[1] = MAX(s
->text_x
[1], x
);
541 s
->text_y
[0] = MIN(s
->text_y
[0], y
);
542 s
->text_y
[1] = MAX(s
->text_y
[1], y
);
545 static void invalidate_xy(QemuConsole
*s
, int x
, int y
)
547 if (!qemu_console_is_visible(s
)) {
550 if (s
->update_x0
> x
* FONT_WIDTH
)
551 s
->update_x0
= x
* FONT_WIDTH
;
552 if (s
->update_y0
> y
* FONT_HEIGHT
)
553 s
->update_y0
= y
* FONT_HEIGHT
;
554 if (s
->update_x1
< (x
+ 1) * FONT_WIDTH
)
555 s
->update_x1
= (x
+ 1) * FONT_WIDTH
;
556 if (s
->update_y1
< (y
+ 1) * FONT_HEIGHT
)
557 s
->update_y1
= (y
+ 1) * FONT_HEIGHT
;
560 static void update_xy(QemuConsole
*s
, int x
, int y
)
565 if (s
->ds
->have_text
) {
566 text_update_xy(s
, x
, y
);
569 y1
= (s
->y_base
+ y
) % s
->total_height
;
570 y2
= y1
- s
->y_displayed
;
572 y2
+= s
->total_height
;
574 if (y2
< s
->height
) {
578 c
= &s
->cells
[y1
* s
->width
+ x
];
579 vga_putcharxy(s
, x
, y2
, c
->ch
,
581 invalidate_xy(s
, x
, y2
);
585 static void console_show_cursor(QemuConsole
*s
, int show
)
591 if (s
->ds
->have_text
) {
592 s
->cursor_invalidate
= 1;
598 y1
= (s
->y_base
+ s
->y
) % s
->total_height
;
599 y
= y1
- s
->y_displayed
;
601 y
+= s
->total_height
;
604 c
= &s
->cells
[y1
* s
->width
+ x
];
605 if (show
&& cursor_visible_phase
) {
606 TextAttributes t_attrib
= s
->t_attrib_default
;
607 t_attrib
.invers
= !(t_attrib
.invers
); /* invert fg and bg */
608 vga_putcharxy(s
, x
, y
, c
->ch
, &t_attrib
);
610 vga_putcharxy(s
, x
, y
, c
->ch
, &(c
->t_attrib
));
612 invalidate_xy(s
, x
, y
);
616 static void console_refresh(QemuConsole
*s
)
618 DisplaySurface
*surface
= qemu_console_surface(s
);
622 if (s
->ds
->have_text
) {
625 s
->text_x
[1] = s
->width
- 1;
626 s
->text_y
[1] = s
->height
- 1;
627 s
->cursor_invalidate
= 1;
630 vga_fill_rect(s
, 0, 0, surface_width(surface
), surface_height(surface
),
631 color_table_rgb
[0][QEMU_COLOR_BLACK
]);
633 for (y
= 0; y
< s
->height
; y
++) {
634 c
= s
->cells
+ y1
* s
->width
;
635 for (x
= 0; x
< s
->width
; x
++) {
636 vga_putcharxy(s
, x
, y
, c
->ch
,
640 if (++y1
== s
->total_height
) {
644 console_show_cursor(s
, 1);
645 dpy_gfx_update(s
, 0, 0,
646 surface_width(surface
), surface_height(surface
));
649 static void console_scroll(QemuConsole
*s
, int ydelta
)
654 for(i
= 0; i
< ydelta
; i
++) {
655 if (s
->y_displayed
== s
->y_base
)
657 if (++s
->y_displayed
== s
->total_height
)
662 i
= s
->backscroll_height
;
663 if (i
> s
->total_height
- s
->height
)
664 i
= s
->total_height
- s
->height
;
667 y1
+= s
->total_height
;
668 for(i
= 0; i
< ydelta
; i
++) {
669 if (s
->y_displayed
== y1
)
671 if (--s
->y_displayed
< 0)
672 s
->y_displayed
= s
->total_height
- 1;
678 static void console_put_lf(QemuConsole
*s
)
684 if (s
->y
>= s
->height
) {
685 s
->y
= s
->height
- 1;
687 if (s
->y_displayed
== s
->y_base
) {
688 if (++s
->y_displayed
== s
->total_height
)
691 if (++s
->y_base
== s
->total_height
)
693 if (s
->backscroll_height
< s
->total_height
)
694 s
->backscroll_height
++;
695 y1
= (s
->y_base
+ s
->height
- 1) % s
->total_height
;
696 c
= &s
->cells
[y1
* s
->width
];
697 for(x
= 0; x
< s
->width
; x
++) {
699 c
->t_attrib
= s
->t_attrib_default
;
702 if (s
->y_displayed
== s
->y_base
) {
703 if (s
->ds
->have_text
) {
706 s
->text_x
[1] = s
->width
- 1;
707 s
->text_y
[1] = s
->height
- 1;
710 vga_bitblt(s
, 0, FONT_HEIGHT
, 0, 0,
711 s
->width
* FONT_WIDTH
,
712 (s
->height
- 1) * FONT_HEIGHT
);
713 vga_fill_rect(s
, 0, (s
->height
- 1) * FONT_HEIGHT
,
714 s
->width
* FONT_WIDTH
, FONT_HEIGHT
,
715 color_table_rgb
[0][s
->t_attrib_default
.bgcol
]);
718 s
->update_x1
= s
->width
* FONT_WIDTH
;
719 s
->update_y1
= s
->height
* FONT_HEIGHT
;
724 /* Set console attributes depending on the current escape codes.
725 * NOTE: I know this code is not very efficient (checking every color for it
726 * self) but it is more readable and better maintainable.
728 static void console_handle_escape(QemuConsole
*s
)
732 for (i
=0; i
<s
->nb_esc_params
; i
++) {
733 switch (s
->esc_params
[i
]) {
734 case 0: /* reset all console attributes to default */
735 s
->t_attrib
= s
->t_attrib_default
;
738 s
->t_attrib
.bold
= 1;
741 s
->t_attrib
.uline
= 1;
744 s
->t_attrib
.blink
= 1;
747 s
->t_attrib
.invers
= 1;
750 s
->t_attrib
.unvisible
= 1;
753 s
->t_attrib
.bold
= 0;
756 s
->t_attrib
.uline
= 0;
759 s
->t_attrib
.blink
= 0;
762 s
->t_attrib
.invers
= 0;
765 s
->t_attrib
.unvisible
= 0;
767 /* set foreground color */
769 s
->t_attrib
.fgcol
= QEMU_COLOR_BLACK
;
772 s
->t_attrib
.fgcol
= QEMU_COLOR_RED
;
775 s
->t_attrib
.fgcol
= QEMU_COLOR_GREEN
;
778 s
->t_attrib
.fgcol
= QEMU_COLOR_YELLOW
;
781 s
->t_attrib
.fgcol
= QEMU_COLOR_BLUE
;
784 s
->t_attrib
.fgcol
= QEMU_COLOR_MAGENTA
;
787 s
->t_attrib
.fgcol
= QEMU_COLOR_CYAN
;
790 s
->t_attrib
.fgcol
= QEMU_COLOR_WHITE
;
792 /* set background color */
794 s
->t_attrib
.bgcol
= QEMU_COLOR_BLACK
;
797 s
->t_attrib
.bgcol
= QEMU_COLOR_RED
;
800 s
->t_attrib
.bgcol
= QEMU_COLOR_GREEN
;
803 s
->t_attrib
.bgcol
= QEMU_COLOR_YELLOW
;
806 s
->t_attrib
.bgcol
= QEMU_COLOR_BLUE
;
809 s
->t_attrib
.bgcol
= QEMU_COLOR_MAGENTA
;
812 s
->t_attrib
.bgcol
= QEMU_COLOR_CYAN
;
815 s
->t_attrib
.bgcol
= QEMU_COLOR_WHITE
;
821 static void console_clear_xy(QemuConsole
*s
, int x
, int y
)
823 int y1
= (s
->y_base
+ y
) % s
->total_height
;
827 TextCell
*c
= &s
->cells
[y1
* s
->width
+ x
];
829 c
->t_attrib
= s
->t_attrib_default
;
833 static void console_put_one(QemuConsole
*s
, int ch
)
837 if (s
->x
>= s
->width
) {
842 y1
= (s
->y_base
+ s
->y
) % s
->total_height
;
843 c
= &s
->cells
[y1
* s
->width
+ s
->x
];
845 c
->t_attrib
= s
->t_attrib
;
846 update_xy(s
, s
->x
, s
->y
);
850 static void console_respond_str(QemuConsole
*s
, const char *buf
)
853 console_put_one(s
, *buf
);
858 /* set cursor, checking bounds */
859 static void set_cursor(QemuConsole
*s
, int x
, int y
)
867 if (y
>= s
->height
) {
878 static void console_putchar(QemuConsole
*s
, int ch
)
887 case '\r': /* carriage return */
890 case '\n': /* newline */
893 case '\b': /* backspace */
897 case '\t': /* tabspace */
898 if (s
->x
+ (8 - (s
->x
% 8)) > s
->width
) {
902 s
->x
= s
->x
+ (8 - (s
->x
% 8));
905 case '\a': /* alert aka. bell */
906 /* TODO: has to be implemented */
909 /* SI (shift in), character set 0 (ignored) */
912 /* SO (shift out), character set 1 (ignored) */
914 case 27: /* esc (introducing an escape sequence) */
915 s
->state
= TTY_STATE_ESC
;
918 console_put_one(s
, ch
);
922 case TTY_STATE_ESC
: /* check if it is a terminal escape sequence */
924 for(i
=0;i
<MAX_ESC_PARAMS
;i
++)
925 s
->esc_params
[i
] = 0;
926 s
->nb_esc_params
= 0;
927 s
->state
= TTY_STATE_CSI
;
929 s
->state
= TTY_STATE_NORM
;
932 case TTY_STATE_CSI
: /* handle escape sequence parameters */
933 if (ch
>= '0' && ch
<= '9') {
934 if (s
->nb_esc_params
< MAX_ESC_PARAMS
) {
935 int *param
= &s
->esc_params
[s
->nb_esc_params
];
936 int digit
= (ch
- '0');
938 *param
= (*param
<= (INT_MAX
- digit
) / 10) ?
939 *param
* 10 + digit
: INT_MAX
;
942 if (s
->nb_esc_params
< MAX_ESC_PARAMS
)
944 if (ch
== ';' || ch
== '?') {
947 trace_console_putchar_csi(s
->esc_params
[0], s
->esc_params
[1],
948 ch
, s
->nb_esc_params
);
949 s
->state
= TTY_STATE_NORM
;
953 if (s
->esc_params
[0] == 0) {
954 s
->esc_params
[0] = 1;
956 set_cursor(s
, s
->x
, s
->y
- s
->esc_params
[0]);
959 /* move cursor down */
960 if (s
->esc_params
[0] == 0) {
961 s
->esc_params
[0] = 1;
963 set_cursor(s
, s
->x
, s
->y
+ s
->esc_params
[0]);
966 /* move cursor right */
967 if (s
->esc_params
[0] == 0) {
968 s
->esc_params
[0] = 1;
970 set_cursor(s
, s
->x
+ s
->esc_params
[0], s
->y
);
973 /* move cursor left */
974 if (s
->esc_params
[0] == 0) {
975 s
->esc_params
[0] = 1;
977 set_cursor(s
, s
->x
- s
->esc_params
[0], s
->y
);
980 /* move cursor to column */
981 set_cursor(s
, s
->esc_params
[0] - 1, s
->y
);
985 /* move cursor to row, column */
986 set_cursor(s
, s
->esc_params
[1] - 1, s
->esc_params
[0] - 1);
989 switch (s
->esc_params
[0]) {
991 /* clear to end of screen */
992 for (y
= s
->y
; y
< s
->height
; y
++) {
993 for (x
= 0; x
< s
->width
; x
++) {
994 if (y
== s
->y
&& x
< s
->x
) {
997 console_clear_xy(s
, x
, y
);
1002 /* clear from beginning of screen */
1003 for (y
= 0; y
<= s
->y
; y
++) {
1004 for (x
= 0; x
< s
->width
; x
++) {
1005 if (y
== s
->y
&& x
> s
->x
) {
1008 console_clear_xy(s
, x
, y
);
1013 /* clear entire screen */
1014 for (y
= 0; y
<= s
->height
; y
++) {
1015 for (x
= 0; x
< s
->width
; x
++) {
1016 console_clear_xy(s
, x
, y
);
1023 switch (s
->esc_params
[0]) {
1026 for(x
= s
->x
; x
< s
->width
; x
++) {
1027 console_clear_xy(s
, x
, s
->y
);
1031 /* clear from beginning of line */
1032 for (x
= 0; x
<= s
->x
&& x
< s
->width
; x
++) {
1033 console_clear_xy(s
, x
, s
->y
);
1037 /* clear entire line */
1038 for(x
= 0; x
< s
->width
; x
++) {
1039 console_clear_xy(s
, x
, s
->y
);
1045 console_handle_escape(s
);
1048 switch (s
->esc_params
[0]) {
1050 /* report console status (always succeed)*/
1051 console_respond_str(s
, "\033[0n");
1054 /* report cursor position */
1055 sprintf(response
, "\033[%d;%dR",
1056 (s
->y_base
+ s
->y
) % s
->total_height
+ 1,
1058 console_respond_str(s
, response
);
1063 /* save cursor position */
1068 /* restore cursor position */
1073 trace_console_putchar_unhandled(ch
);
1081 void console_select(unsigned int index
)
1083 DisplayChangeListener
*dcl
;
1086 trace_console_select(index
);
1087 s
= qemu_console_lookup_by_index(index
);
1089 DisplayState
*ds
= s
->ds
;
1093 QLIST_FOREACH(dcl
, &ds
->listeners
, next
) {
1094 if (dcl
->con
!= NULL
) {
1097 if (dcl
->ops
->dpy_gfx_switch
) {
1098 dcl
->ops
->dpy_gfx_switch(dcl
, s
->surface
);
1102 dpy_gfx_update(s
, 0, 0, surface_width(s
->surface
),
1103 surface_height(s
->surface
));
1106 if (ds
->have_text
) {
1107 dpy_text_resize(s
, s
->width
, s
->height
);
1109 text_console_update_cursor(NULL
);
1115 QemuConsole
*console
;
1117 typedef struct VCChardev VCChardev
;
1119 #define TYPE_CHARDEV_VC "chardev-vc"
1120 DECLARE_INSTANCE_CHECKER(VCChardev
, VC_CHARDEV
,
1123 static int vc_chr_write(Chardev
*chr
, const uint8_t *buf
, int len
)
1125 VCChardev
*drv
= VC_CHARDEV(chr
);
1126 QemuConsole
*s
= drv
->console
;
1133 s
->update_x0
= s
->width
* FONT_WIDTH
;
1134 s
->update_y0
= s
->height
* FONT_HEIGHT
;
1137 console_show_cursor(s
, 0);
1138 for(i
= 0; i
< len
; i
++) {
1139 console_putchar(s
, buf
[i
]);
1141 console_show_cursor(s
, 1);
1142 if (s
->ds
->have_gfx
&& s
->update_x0
< s
->update_x1
) {
1143 dpy_gfx_update(s
, s
->update_x0
, s
->update_y0
,
1144 s
->update_x1
- s
->update_x0
,
1145 s
->update_y1
- s
->update_y0
);
1150 static void kbd_send_chars(void *opaque
)
1152 QemuConsole
*s
= opaque
;
1156 len
= qemu_chr_be_can_write(s
->chr
);
1157 if (len
> s
->out_fifo
.count
)
1158 len
= s
->out_fifo
.count
;
1160 if (len
> sizeof(buf
))
1162 qemu_fifo_read(&s
->out_fifo
, buf
, len
);
1163 qemu_chr_be_write(s
->chr
, buf
, len
);
1165 /* characters are pending: we send them a bit later (XXX:
1166 horrible, should change char device API) */
1167 if (s
->out_fifo
.count
> 0) {
1168 timer_mod(s
->kbd_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + 1);
1172 /* called when an ascii key is pressed */
1173 void kbd_put_keysym_console(QemuConsole
*s
, int keysym
)
1175 uint8_t buf
[16], *q
;
1179 if (!s
|| (s
->console_type
== GRAPHIC_CONSOLE
))
1183 case QEMU_KEY_CTRL_UP
:
1184 console_scroll(s
, -1);
1186 case QEMU_KEY_CTRL_DOWN
:
1187 console_scroll(s
, 1);
1189 case QEMU_KEY_CTRL_PAGEUP
:
1190 console_scroll(s
, -10);
1192 case QEMU_KEY_CTRL_PAGEDOWN
:
1193 console_scroll(s
, 10);
1196 /* convert the QEMU keysym to VT100 key string */
1198 if (keysym
>= 0xe100 && keysym
<= 0xe11f) {
1201 c
= keysym
- 0xe100;
1203 *q
++ = '0' + (c
/ 10);
1204 *q
++ = '0' + (c
% 10);
1206 } else if (keysym
>= 0xe120 && keysym
<= 0xe17f) {
1209 *q
++ = keysym
& 0xff;
1210 } else if (s
->echo
&& (keysym
== '\r' || keysym
== '\n')) {
1211 vc_chr_write(s
->chr
, (const uint8_t *) "\r", 1);
1217 vc_chr_write(s
->chr
, buf
, q
- buf
);
1220 if (be
&& be
->chr_read
) {
1221 qemu_fifo_write(&s
->out_fifo
, buf
, q
- buf
);
1228 static const int qcode_to_keysym
[Q_KEY_CODE__MAX
] = {
1229 [Q_KEY_CODE_UP
] = QEMU_KEY_UP
,
1230 [Q_KEY_CODE_DOWN
] = QEMU_KEY_DOWN
,
1231 [Q_KEY_CODE_RIGHT
] = QEMU_KEY_RIGHT
,
1232 [Q_KEY_CODE_LEFT
] = QEMU_KEY_LEFT
,
1233 [Q_KEY_CODE_HOME
] = QEMU_KEY_HOME
,
1234 [Q_KEY_CODE_END
] = QEMU_KEY_END
,
1235 [Q_KEY_CODE_PGUP
] = QEMU_KEY_PAGEUP
,
1236 [Q_KEY_CODE_PGDN
] = QEMU_KEY_PAGEDOWN
,
1237 [Q_KEY_CODE_DELETE
] = QEMU_KEY_DELETE
,
1238 [Q_KEY_CODE_BACKSPACE
] = QEMU_KEY_BACKSPACE
,
1241 static const int ctrl_qcode_to_keysym
[Q_KEY_CODE__MAX
] = {
1242 [Q_KEY_CODE_UP
] = QEMU_KEY_CTRL_UP
,
1243 [Q_KEY_CODE_DOWN
] = QEMU_KEY_CTRL_DOWN
,
1244 [Q_KEY_CODE_RIGHT
] = QEMU_KEY_CTRL_RIGHT
,
1245 [Q_KEY_CODE_LEFT
] = QEMU_KEY_CTRL_LEFT
,
1246 [Q_KEY_CODE_HOME
] = QEMU_KEY_CTRL_HOME
,
1247 [Q_KEY_CODE_END
] = QEMU_KEY_CTRL_END
,
1248 [Q_KEY_CODE_PGUP
] = QEMU_KEY_CTRL_PAGEUP
,
1249 [Q_KEY_CODE_PGDN
] = QEMU_KEY_CTRL_PAGEDOWN
,
1252 bool kbd_put_qcode_console(QemuConsole
*s
, int qcode
, bool ctrl
)
1256 keysym
= ctrl
? ctrl_qcode_to_keysym
[qcode
] : qcode_to_keysym
[qcode
];
1260 kbd_put_keysym_console(s
, keysym
);
1264 void kbd_put_string_console(QemuConsole
*s
, const char *str
, int len
)
1268 for (i
= 0; i
< len
&& str
[i
]; i
++) {
1269 kbd_put_keysym_console(s
, str
[i
]);
1273 void kbd_put_keysym(int keysym
)
1275 kbd_put_keysym_console(active_console
, keysym
);
1278 static void text_console_invalidate(void *opaque
)
1280 QemuConsole
*s
= (QemuConsole
*) opaque
;
1282 if (s
->ds
->have_text
&& s
->console_type
== TEXT_CONSOLE
) {
1283 text_console_resize(s
);
1288 static void text_console_update(void *opaque
, console_ch_t
*chardata
)
1290 QemuConsole
*s
= (QemuConsole
*) opaque
;
1293 if (s
->text_x
[0] <= s
->text_x
[1]) {
1294 src
= (s
->y_base
+ s
->text_y
[0]) * s
->width
;
1295 chardata
+= s
->text_y
[0] * s
->width
;
1296 for (i
= s
->text_y
[0]; i
<= s
->text_y
[1]; i
++)
1297 for (j
= 0; j
< s
->width
; j
++, src
++) {
1298 console_write_ch(chardata
++,
1299 ATTR2CHTYPE(s
->cells
[src
].ch
,
1300 s
->cells
[src
].t_attrib
.fgcol
,
1301 s
->cells
[src
].t_attrib
.bgcol
,
1302 s
->cells
[src
].t_attrib
.bold
));
1304 dpy_text_update(s
, s
->text_x
[0], s
->text_y
[0],
1305 s
->text_x
[1] - s
->text_x
[0], i
- s
->text_y
[0]);
1306 s
->text_x
[0] = s
->width
;
1307 s
->text_y
[0] = s
->height
;
1311 if (s
->cursor_invalidate
) {
1312 dpy_text_cursor(s
, s
->x
, s
->y
);
1313 s
->cursor_invalidate
= 0;
1317 static QemuConsole
*new_console(DisplayState
*ds
, console_type_t console_type
,
1324 obj
= object_new(TYPE_QEMU_CONSOLE
);
1325 s
= QEMU_CONSOLE(obj
);
1326 qemu_co_queue_init(&s
->dump_queue
);
1328 object_property_add_link(obj
, "device", TYPE_DEVICE
,
1329 (Object
**)&s
->device
,
1330 object_property_allow_set_link
,
1331 OBJ_PROP_LINK_STRONG
);
1332 object_property_add_uint32_ptr(obj
, "head", &s
->head
,
1333 OBJ_PROP_FLAG_READ
);
1335 if (!active_console
|| ((active_console
->console_type
!= GRAPHIC_CONSOLE
) &&
1336 (console_type
== GRAPHIC_CONSOLE
))) {
1340 s
->console_type
= console_type
;
1343 if (QTAILQ_EMPTY(&consoles
)) {
1345 QTAILQ_INSERT_TAIL(&consoles
, s
, next
);
1346 } else if (console_type
!= GRAPHIC_CONSOLE
|| qdev_hotplug
) {
1347 QemuConsole
*last
= QTAILQ_LAST(&consoles
);
1348 s
->index
= last
->index
+ 1;
1349 QTAILQ_INSERT_TAIL(&consoles
, s
, next
);
1352 * HACK: Put graphical consoles before text consoles.
1354 * Only do that for coldplugged devices. After initial device
1355 * initialization we will not renumber the consoles any more.
1357 QemuConsole
*c
= QTAILQ_FIRST(&consoles
);
1359 while (QTAILQ_NEXT(c
, next
) != NULL
&&
1360 c
->console_type
== GRAPHIC_CONSOLE
) {
1361 c
= QTAILQ_NEXT(c
, next
);
1363 if (c
->console_type
== GRAPHIC_CONSOLE
) {
1364 /* have no text consoles */
1365 s
->index
= c
->index
+ 1;
1366 QTAILQ_INSERT_AFTER(&consoles
, c
, s
, next
);
1368 s
->index
= c
->index
;
1369 QTAILQ_INSERT_BEFORE(c
, s
, next
);
1370 /* renumber text consoles */
1371 for (i
= s
->index
+ 1; c
!= NULL
; c
= QTAILQ_NEXT(c
, next
), i
++) {
1379 static void qemu_alloc_display(DisplaySurface
*surface
, int width
, int height
)
1381 qemu_pixman_image_unref(surface
->image
);
1382 surface
->image
= NULL
;
1384 surface
->format
= PIXMAN_x8r8g8b8
;
1385 surface
->image
= pixman_image_create_bits(surface
->format
,
1388 assert(surface
->image
!= NULL
);
1390 surface
->flags
= QEMU_ALLOCATED_FLAG
;
1393 DisplaySurface
*qemu_create_displaysurface(int width
, int height
)
1395 DisplaySurface
*surface
= g_new0(DisplaySurface
, 1);
1397 trace_displaysurface_create(surface
, width
, height
);
1398 qemu_alloc_display(surface
, width
, height
);
1402 DisplaySurface
*qemu_create_displaysurface_from(int width
, int height
,
1403 pixman_format_code_t format
,
1404 int linesize
, uint8_t *data
)
1406 DisplaySurface
*surface
= g_new0(DisplaySurface
, 1);
1408 trace_displaysurface_create_from(surface
, width
, height
, format
);
1409 surface
->format
= format
;
1410 surface
->image
= pixman_image_create_bits(surface
->format
,
1412 (void *)data
, linesize
);
1413 assert(surface
->image
!= NULL
);
1418 DisplaySurface
*qemu_create_displaysurface_pixman(pixman_image_t
*image
)
1420 DisplaySurface
*surface
= g_new0(DisplaySurface
, 1);
1422 trace_displaysurface_create_pixman(surface
);
1423 surface
->format
= pixman_image_get_format(image
);
1424 surface
->image
= pixman_image_ref(image
);
1429 DisplaySurface
*qemu_create_message_surface(int w
, int h
,
1432 DisplaySurface
*surface
= qemu_create_displaysurface(w
, h
);
1433 pixman_color_t bg
= color_table_rgb
[0][QEMU_COLOR_BLACK
];
1434 pixman_color_t fg
= color_table_rgb
[0][QEMU_COLOR_WHITE
];
1435 pixman_image_t
*glyph
;
1439 x
= (w
/ FONT_WIDTH
- len
) / 2;
1440 y
= (h
/ FONT_HEIGHT
- 1) / 2;
1441 for (i
= 0; i
< len
; i
++) {
1442 glyph
= qemu_pixman_glyph_from_vgafont(FONT_HEIGHT
, vgafont16
, msg
[i
]);
1443 qemu_pixman_glyph_render(glyph
, surface
->image
, &fg
, &bg
,
1444 x
+i
, y
, FONT_WIDTH
, FONT_HEIGHT
);
1445 qemu_pixman_image_unref(glyph
);
1450 void qemu_free_displaysurface(DisplaySurface
*surface
)
1452 if (surface
== NULL
) {
1455 trace_displaysurface_free(surface
);
1456 qemu_pixman_image_unref(surface
->image
);
1460 bool console_has_gl(QemuConsole
*con
)
1462 return con
->gl
!= NULL
;
1465 bool console_has_gl_dmabuf(QemuConsole
*con
)
1467 return con
->gl
!= NULL
&& con
->gl
->ops
->dpy_gl_scanout_dmabuf
!= NULL
;
1470 void register_displaychangelistener(DisplayChangeListener
*dcl
)
1472 static const char nodev
[] =
1473 "This VM has no graphic display device.";
1474 static DisplaySurface
*dummy
;
1479 if (dcl
->ops
->dpy_gl_ctx_create
) {
1480 /* display has opengl support */
1483 fprintf(stderr
, "can't register two opengl displays (%s, %s)\n",
1484 dcl
->ops
->dpy_name
, dcl
->con
->gl
->ops
->dpy_name
);
1490 trace_displaychangelistener_register(dcl
, dcl
->ops
->dpy_name
);
1491 dcl
->ds
= get_alloc_displaystate();
1492 QLIST_INSERT_HEAD(&dcl
->ds
->listeners
, dcl
, next
);
1493 gui_setup_refresh(dcl
->ds
);
1498 con
= active_console
;
1500 if (dcl
->ops
->dpy_gfx_switch
) {
1502 dcl
->ops
->dpy_gfx_switch(dcl
, con
->surface
);
1505 dummy
= qemu_create_message_surface(640, 480, nodev
);
1507 dcl
->ops
->dpy_gfx_switch(dcl
, dummy
);
1510 text_console_update_cursor(NULL
);
1513 void update_displaychangelistener(DisplayChangeListener
*dcl
,
1516 DisplayState
*ds
= dcl
->ds
;
1518 dcl
->update_interval
= interval
;
1519 if (!ds
->refreshing
&& ds
->update_interval
> interval
) {
1520 timer_mod(ds
->gui_timer
, ds
->last_update
+ interval
);
1524 void unregister_displaychangelistener(DisplayChangeListener
*dcl
)
1526 DisplayState
*ds
= dcl
->ds
;
1527 trace_displaychangelistener_unregister(dcl
, dcl
->ops
->dpy_name
);
1531 QLIST_REMOVE(dcl
, next
);
1533 gui_setup_refresh(ds
);
1536 static void dpy_set_ui_info_timer(void *opaque
)
1538 QemuConsole
*con
= opaque
;
1540 con
->hw_ops
->ui_info(con
->hw
, con
->head
, &con
->ui_info
);
1543 bool dpy_ui_info_supported(QemuConsole
*con
)
1545 return con
->hw_ops
->ui_info
!= NULL
;
1548 const QemuUIInfo
*dpy_get_ui_info(const QemuConsole
*con
)
1550 assert(con
!= NULL
);
1552 return &con
->ui_info
;
1555 int dpy_set_ui_info(QemuConsole
*con
, QemuUIInfo
*info
)
1557 assert(con
!= NULL
);
1559 if (!dpy_ui_info_supported(con
)) {
1562 if (memcmp(&con
->ui_info
, info
, sizeof(con
->ui_info
)) == 0) {
1563 /* nothing changed -- ignore */
1568 * Typically we get a flood of these as the user resizes the window.
1569 * Wait until the dust has settled (one second without updates), then
1570 * go notify the guest.
1572 con
->ui_info
= *info
;
1573 timer_mod(con
->ui_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + 1000);
1577 void dpy_gfx_update(QemuConsole
*con
, int x
, int y
, int w
, int h
)
1579 DisplayState
*s
= con
->ds
;
1580 DisplayChangeListener
*dcl
;
1585 width
= surface_width(con
->surface
);
1586 height
= surface_height(con
->surface
);
1592 w
= MIN(w
, width
- x
);
1593 h
= MIN(h
, height
- y
);
1595 if (!qemu_console_is_visible(con
)) {
1598 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1599 if (con
!= (dcl
->con
? dcl
->con
: active_console
)) {
1602 if (dcl
->ops
->dpy_gfx_update
) {
1603 dcl
->ops
->dpy_gfx_update(dcl
, x
, y
, w
, h
);
1608 void dpy_gfx_update_full(QemuConsole
*con
)
1610 if (!con
->surface
) {
1613 dpy_gfx_update(con
, 0, 0,
1614 surface_width(con
->surface
),
1615 surface_height(con
->surface
));
1618 void dpy_gfx_replace_surface(QemuConsole
*con
,
1619 DisplaySurface
*surface
)
1621 DisplayState
*s
= con
->ds
;
1622 DisplaySurface
*old_surface
= con
->surface
;
1623 DisplayChangeListener
*dcl
;
1625 assert(old_surface
!= surface
|| surface
== NULL
);
1627 con
->surface
= surface
;
1628 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1629 if (con
!= (dcl
->con
? dcl
->con
: active_console
)) {
1632 if (dcl
->ops
->dpy_gfx_switch
) {
1633 dcl
->ops
->dpy_gfx_switch(dcl
, surface
);
1636 qemu_free_displaysurface(old_surface
);
1639 bool dpy_gfx_check_format(QemuConsole
*con
,
1640 pixman_format_code_t format
)
1642 DisplayChangeListener
*dcl
;
1643 DisplayState
*s
= con
->ds
;
1645 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1646 if (dcl
->con
&& dcl
->con
!= con
) {
1647 /* dcl bound to another console -> skip */
1650 if (dcl
->ops
->dpy_gfx_check_format
) {
1651 if (!dcl
->ops
->dpy_gfx_check_format(dcl
, format
)) {
1655 /* default is to whitelist native 32 bpp only */
1656 if (format
!= qemu_default_pixman_format(32, true)) {
1664 static void dpy_refresh(DisplayState
*s
)
1666 DisplayChangeListener
*dcl
;
1668 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1669 if (dcl
->ops
->dpy_refresh
) {
1670 dcl
->ops
->dpy_refresh(dcl
);
1675 void dpy_text_cursor(QemuConsole
*con
, int x
, int y
)
1677 DisplayState
*s
= con
->ds
;
1678 DisplayChangeListener
*dcl
;
1680 if (!qemu_console_is_visible(con
)) {
1683 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1684 if (con
!= (dcl
->con
? dcl
->con
: active_console
)) {
1687 if (dcl
->ops
->dpy_text_cursor
) {
1688 dcl
->ops
->dpy_text_cursor(dcl
, x
, y
);
1693 void dpy_text_update(QemuConsole
*con
, int x
, int y
, int w
, int h
)
1695 DisplayState
*s
= con
->ds
;
1696 DisplayChangeListener
*dcl
;
1698 if (!qemu_console_is_visible(con
)) {
1701 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1702 if (con
!= (dcl
->con
? dcl
->con
: active_console
)) {
1705 if (dcl
->ops
->dpy_text_update
) {
1706 dcl
->ops
->dpy_text_update(dcl
, x
, y
, w
, h
);
1711 void dpy_text_resize(QemuConsole
*con
, int w
, int h
)
1713 DisplayState
*s
= con
->ds
;
1714 DisplayChangeListener
*dcl
;
1716 if (!qemu_console_is_visible(con
)) {
1719 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1720 if (con
!= (dcl
->con
? dcl
->con
: active_console
)) {
1723 if (dcl
->ops
->dpy_text_resize
) {
1724 dcl
->ops
->dpy_text_resize(dcl
, w
, h
);
1729 void dpy_mouse_set(QemuConsole
*con
, int x
, int y
, int on
)
1731 DisplayState
*s
= con
->ds
;
1732 DisplayChangeListener
*dcl
;
1734 if (!qemu_console_is_visible(con
)) {
1737 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1738 if (con
!= (dcl
->con
? dcl
->con
: active_console
)) {
1741 if (dcl
->ops
->dpy_mouse_set
) {
1742 dcl
->ops
->dpy_mouse_set(dcl
, x
, y
, on
);
1747 void dpy_cursor_define(QemuConsole
*con
, QEMUCursor
*cursor
)
1749 DisplayState
*s
= con
->ds
;
1750 DisplayChangeListener
*dcl
;
1752 if (!qemu_console_is_visible(con
)) {
1755 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1756 if (con
!= (dcl
->con
? dcl
->con
: active_console
)) {
1759 if (dcl
->ops
->dpy_cursor_define
) {
1760 dcl
->ops
->dpy_cursor_define(dcl
, cursor
);
1765 bool dpy_cursor_define_supported(QemuConsole
*con
)
1767 DisplayState
*s
= con
->ds
;
1768 DisplayChangeListener
*dcl
;
1770 QLIST_FOREACH(dcl
, &s
->listeners
, next
) {
1771 if (dcl
->ops
->dpy_cursor_define
) {
1778 QEMUGLContext
dpy_gl_ctx_create(QemuConsole
*con
,
1779 struct QEMUGLParams
*qparams
)
1782 return con
->gl
->ops
->dpy_gl_ctx_create(con
->gl
, qparams
);
1785 void dpy_gl_ctx_destroy(QemuConsole
*con
, QEMUGLContext ctx
)
1788 con
->gl
->ops
->dpy_gl_ctx_destroy(con
->gl
, ctx
);
1791 int dpy_gl_ctx_make_current(QemuConsole
*con
, QEMUGLContext ctx
)
1794 return con
->gl
->ops
->dpy_gl_ctx_make_current(con
->gl
, ctx
);
1797 QEMUGLContext
dpy_gl_ctx_get_current(QemuConsole
*con
)
1800 return con
->gl
->ops
->dpy_gl_ctx_get_current(con
->gl
);
1803 void dpy_gl_scanout_disable(QemuConsole
*con
)
1806 if (con
->gl
->ops
->dpy_gl_scanout_disable
) {
1807 con
->gl
->ops
->dpy_gl_scanout_disable(con
->gl
);
1809 con
->gl
->ops
->dpy_gl_scanout_texture(con
->gl
, 0, false, 0, 0,
1814 void dpy_gl_scanout_texture(QemuConsole
*con
,
1815 uint32_t backing_id
,
1816 bool backing_y_0_top
,
1817 uint32_t backing_width
,
1818 uint32_t backing_height
,
1819 uint32_t x
, uint32_t y
,
1820 uint32_t width
, uint32_t height
)
1823 con
->gl
->ops
->dpy_gl_scanout_texture(con
->gl
, backing_id
,
1825 backing_width
, backing_height
,
1826 x
, y
, width
, height
);
1829 void dpy_gl_scanout_dmabuf(QemuConsole
*con
,
1833 con
->gl
->ops
->dpy_gl_scanout_dmabuf(con
->gl
, dmabuf
);
1836 void dpy_gl_cursor_dmabuf(QemuConsole
*con
, QemuDmaBuf
*dmabuf
,
1837 bool have_hot
, uint32_t hot_x
, uint32_t hot_y
)
1841 if (con
->gl
->ops
->dpy_gl_cursor_dmabuf
) {
1842 con
->gl
->ops
->dpy_gl_cursor_dmabuf(con
->gl
, dmabuf
,
1843 have_hot
, hot_x
, hot_y
);
1847 void dpy_gl_cursor_position(QemuConsole
*con
,
1848 uint32_t pos_x
, uint32_t pos_y
)
1852 if (con
->gl
->ops
->dpy_gl_cursor_position
) {
1853 con
->gl
->ops
->dpy_gl_cursor_position(con
->gl
, pos_x
, pos_y
);
1857 void dpy_gl_release_dmabuf(QemuConsole
*con
,
1862 if (con
->gl
->ops
->dpy_gl_release_dmabuf
) {
1863 con
->gl
->ops
->dpy_gl_release_dmabuf(con
->gl
, dmabuf
);
1867 void dpy_gl_update(QemuConsole
*con
,
1868 uint32_t x
, uint32_t y
, uint32_t w
, uint32_t h
)
1871 con
->gl
->ops
->dpy_gl_update(con
->gl
, x
, y
, w
, h
);
1874 /***********************************************************/
1875 /* register display */
1877 /* console.c internal use only */
1878 static DisplayState
*get_alloc_displaystate(void)
1880 if (!display_state
) {
1881 display_state
= g_new0(DisplayState
, 1);
1882 cursor_timer
= timer_new_ms(QEMU_CLOCK_REALTIME
,
1883 text_console_update_cursor
, NULL
);
1885 return display_state
;
1889 * Called by main(), after creating QemuConsoles
1890 * and before initializing ui (sdl/vnc/...).
1892 DisplayState
*init_displaystate(void)
1897 get_alloc_displaystate();
1898 QTAILQ_FOREACH(con
, &consoles
, next
) {
1899 if (con
->console_type
!= GRAPHIC_CONSOLE
&&
1901 text_console_do_init(con
->chr
, display_state
);
1904 /* Hook up into the qom tree here (not in new_console()), once
1905 * all QemuConsoles are created and the order / numbering
1906 * doesn't change any more */
1907 name
= g_strdup_printf("console[%d]", con
->index
);
1908 object_property_add_child(container_get(object_get_root(), "/backend"),
1913 return display_state
;
1916 void graphic_console_set_hwops(QemuConsole
*con
,
1917 const GraphicHwOps
*hw_ops
,
1920 con
->hw_ops
= hw_ops
;
1924 QemuConsole
*graphic_console_init(DeviceState
*dev
, uint32_t head
,
1925 const GraphicHwOps
*hw_ops
,
1928 static const char noinit
[] =
1929 "Guest has not initialized the display (yet).";
1934 DisplaySurface
*surface
;
1936 ds
= get_alloc_displaystate();
1937 s
= qemu_console_lookup_unused();
1939 trace_console_gfx_reuse(s
->index
);
1941 width
= surface_width(s
->surface
);
1942 height
= surface_height(s
->surface
);
1945 trace_console_gfx_new();
1946 s
= new_console(ds
, GRAPHIC_CONSOLE
, head
);
1947 s
->ui_timer
= timer_new_ms(QEMU_CLOCK_REALTIME
,
1948 dpy_set_ui_info_timer
, s
);
1950 graphic_console_set_hwops(s
, hw_ops
, opaque
);
1952 object_property_set_link(OBJECT(s
), "device", OBJECT(dev
),
1956 surface
= qemu_create_message_surface(width
, height
, noinit
);
1957 dpy_gfx_replace_surface(s
, surface
);
1961 static const GraphicHwOps unused_ops
= {
1965 void graphic_console_close(QemuConsole
*con
)
1967 static const char unplugged
[] =
1968 "Guest display has been unplugged";
1969 DisplaySurface
*surface
;
1974 width
= surface_width(con
->surface
);
1975 height
= surface_height(con
->surface
);
1978 trace_console_gfx_close(con
->index
);
1979 object_property_set_link(OBJECT(con
), "device", NULL
, &error_abort
);
1980 graphic_console_set_hwops(con
, &unused_ops
, NULL
);
1983 dpy_gl_scanout_disable(con
);
1985 surface
= qemu_create_message_surface(width
, height
, unplugged
);
1986 dpy_gfx_replace_surface(con
, surface
);
1989 QemuConsole
*qemu_console_lookup_by_index(unsigned int index
)
1993 QTAILQ_FOREACH(con
, &consoles
, next
) {
1994 if (con
->index
== index
) {
2001 QemuConsole
*qemu_console_lookup_by_device(DeviceState
*dev
, uint32_t head
)
2007 QTAILQ_FOREACH(con
, &consoles
, next
) {
2008 obj
= object_property_get_link(OBJECT(con
),
2009 "device", &error_abort
);
2010 if (DEVICE(obj
) != dev
) {
2013 h
= object_property_get_uint(OBJECT(con
),
2014 "head", &error_abort
);
2023 QemuConsole
*qemu_console_lookup_by_device_name(const char *device_id
,
2024 uint32_t head
, Error
**errp
)
2029 dev
= qdev_find_recursive(sysbus_get_default(), device_id
);
2031 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
2032 "Device '%s' not found", device_id
);
2036 con
= qemu_console_lookup_by_device(dev
, head
);
2038 error_setg(errp
, "Device %s (head %d) is not bound to a QemuConsole",
2046 QemuConsole
*qemu_console_lookup_unused(void)
2051 QTAILQ_FOREACH(con
, &consoles
, next
) {
2052 if (con
->hw_ops
!= &unused_ops
) {
2055 obj
= object_property_get_link(OBJECT(con
),
2056 "device", &error_abort
);
2065 bool qemu_console_is_visible(QemuConsole
*con
)
2067 return (con
== active_console
) || (con
->dcls
> 0);
2070 bool qemu_console_is_graphic(QemuConsole
*con
)
2073 con
= active_console
;
2075 return con
&& (con
->console_type
== GRAPHIC_CONSOLE
);
2078 bool qemu_console_is_fixedsize(QemuConsole
*con
)
2081 con
= active_console
;
2083 return con
&& (con
->console_type
!= TEXT_CONSOLE
);
2086 bool qemu_console_is_gl_blocked(QemuConsole
*con
)
2088 assert(con
!= NULL
);
2089 return con
->gl_block
;
2092 char *qemu_console_get_label(QemuConsole
*con
)
2094 if (con
->console_type
== GRAPHIC_CONSOLE
) {
2096 return g_strdup(object_get_typename(con
->device
));
2098 return g_strdup("VGA");
2100 if (con
->chr
&& con
->chr
->label
) {
2101 return g_strdup(con
->chr
->label
);
2103 return g_strdup_printf("vc%d", con
->index
);
2107 int qemu_console_get_index(QemuConsole
*con
)
2110 con
= active_console
;
2112 return con
? con
->index
: -1;
2115 uint32_t qemu_console_get_head(QemuConsole
*con
)
2118 con
= active_console
;
2120 return con
? con
->head
: -1;
2123 QemuUIInfo
*qemu_console_get_ui_info(QemuConsole
*con
)
2125 assert(con
!= NULL
);
2126 return &con
->ui_info
;
2129 int qemu_console_get_width(QemuConsole
*con
, int fallback
)
2132 con
= active_console
;
2134 return con
? surface_width(con
->surface
) : fallback
;
2137 int qemu_console_get_height(QemuConsole
*con
, int fallback
)
2140 con
= active_console
;
2142 return con
? surface_height(con
->surface
) : fallback
;
2145 static void vc_chr_set_echo(Chardev
*chr
, bool echo
)
2147 VCChardev
*drv
= VC_CHARDEV(chr
);
2148 QemuConsole
*s
= drv
->console
;
2153 static void text_console_update_cursor_timer(void)
2155 timer_mod(cursor_timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
)
2156 + CONSOLE_CURSOR_PERIOD
/ 2);
2159 static void text_console_update_cursor(void *opaque
)
2164 cursor_visible_phase
= !cursor_visible_phase
;
2166 QTAILQ_FOREACH(s
, &consoles
, next
) {
2167 if (qemu_console_is_graphic(s
) ||
2168 !qemu_console_is_visible(s
)) {
2172 graphic_hw_invalidate(s
);
2176 text_console_update_cursor_timer();
2180 static const GraphicHwOps text_console_ops
= {
2181 .invalidate
= text_console_invalidate
,
2182 .text_update
= text_console_update
,
2185 static void text_console_do_init(Chardev
*chr
, DisplayState
*ds
)
2187 VCChardev
*drv
= VC_CHARDEV(chr
);
2188 QemuConsole
*s
= drv
->console
;
2189 int g_width
= 80 * FONT_WIDTH
;
2190 int g_height
= 24 * FONT_HEIGHT
;
2192 s
->out_fifo
.buf
= s
->out_fifo_buf
;
2193 s
->out_fifo
.buf_size
= sizeof(s
->out_fifo_buf
);
2194 s
->kbd_timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, kbd_send_chars
, s
);
2199 s
->total_height
= DEFAULT_BACKSCROLL
;
2203 if (active_console
&& active_console
->surface
) {
2204 g_width
= surface_width(active_console
->surface
);
2205 g_height
= surface_height(active_console
->surface
);
2207 s
->surface
= qemu_create_displaysurface(g_width
, g_height
);
2210 s
->hw_ops
= &text_console_ops
;
2213 /* Set text attribute defaults */
2214 s
->t_attrib_default
.bold
= 0;
2215 s
->t_attrib_default
.uline
= 0;
2216 s
->t_attrib_default
.blink
= 0;
2217 s
->t_attrib_default
.invers
= 0;
2218 s
->t_attrib_default
.unvisible
= 0;
2219 s
->t_attrib_default
.fgcol
= QEMU_COLOR_WHITE
;
2220 s
->t_attrib_default
.bgcol
= QEMU_COLOR_BLACK
;
2221 /* set current text attributes to default */
2222 s
->t_attrib
= s
->t_attrib_default
;
2223 text_console_resize(s
);
2228 s
->t_attrib
.bgcol
= QEMU_COLOR_BLUE
;
2229 msg
= g_strdup_printf("%s console\r\n", chr
->label
);
2230 vc_chr_write(chr
, (uint8_t *)msg
, strlen(msg
));
2232 s
->t_attrib
= s
->t_attrib_default
;
2235 qemu_chr_be_event(chr
, CHR_EVENT_OPENED
);
2238 static void vc_chr_open(Chardev
*chr
,
2239 ChardevBackend
*backend
,
2243 ChardevVC
*vc
= backend
->u
.vc
.data
;
2244 VCChardev
*drv
= VC_CHARDEV(chr
);
2247 unsigned height
= 0;
2249 if (vc
->has_width
) {
2251 } else if (vc
->has_cols
) {
2252 width
= vc
->cols
* FONT_WIDTH
;
2255 if (vc
->has_height
) {
2256 height
= vc
->height
;
2257 } else if (vc
->has_rows
) {
2258 height
= vc
->rows
* FONT_HEIGHT
;
2261 trace_console_txt_new(width
, height
);
2262 if (width
== 0 || height
== 0) {
2263 s
= new_console(NULL
, TEXT_CONSOLE
, 0);
2265 s
= new_console(NULL
, TEXT_CONSOLE_FIXED_SIZE
, 0);
2266 s
->surface
= qemu_create_displaysurface(width
, height
);
2270 error_setg(errp
, "cannot create text console");
2277 if (display_state
) {
2278 text_console_do_init(chr
, display_state
);
2281 /* console/chardev init sometimes completes elsewhere in a 2nd
2282 * stage, so defer OPENED events until they are fully initialized
2287 void qemu_console_resize(QemuConsole
*s
, int width
, int height
)
2289 DisplaySurface
*surface
;
2291 assert(s
->console_type
== GRAPHIC_CONSOLE
);
2293 if (s
->surface
&& (s
->surface
->flags
& QEMU_ALLOCATED_FLAG
) &&
2294 pixman_image_get_width(s
->surface
->image
) == width
&&
2295 pixman_image_get_height(s
->surface
->image
) == height
) {
2299 surface
= qemu_create_displaysurface(width
, height
);
2300 dpy_gfx_replace_surface(s
, surface
);
2303 DisplaySurface
*qemu_console_surface(QemuConsole
*console
)
2305 return console
->surface
;
2308 PixelFormat
qemu_default_pixelformat(int bpp
)
2310 pixman_format_code_t fmt
= qemu_default_pixman_format(bpp
, true);
2311 PixelFormat pf
= qemu_pixelformat_from_pixman(fmt
);
2315 static QemuDisplay
*dpys
[DISPLAY_TYPE__MAX
];
2317 void qemu_display_register(QemuDisplay
*ui
)
2319 assert(ui
->type
< DISPLAY_TYPE__MAX
);
2320 dpys
[ui
->type
] = ui
;
2323 bool qemu_display_find_default(DisplayOptions
*opts
)
2325 static DisplayType prio
[] = {
2332 for (i
= 0; i
< ARRAY_SIZE(prio
); i
++) {
2333 if (dpys
[prio
[i
]] == NULL
) {
2334 ui_module_load_one(DisplayType_str(prio
[i
]));
2336 if (dpys
[prio
[i
]] == NULL
) {
2339 opts
->type
= prio
[i
];
2345 void qemu_display_early_init(DisplayOptions
*opts
)
2347 assert(opts
->type
< DISPLAY_TYPE__MAX
);
2348 if (opts
->type
== DISPLAY_TYPE_NONE
) {
2351 if (dpys
[opts
->type
] == NULL
) {
2352 ui_module_load_one(DisplayType_str(opts
->type
));
2354 if (dpys
[opts
->type
] == NULL
) {
2355 error_report("Display '%s' is not available.",
2356 DisplayType_str(opts
->type
));
2359 if (dpys
[opts
->type
]->early_init
) {
2360 dpys
[opts
->type
]->early_init(opts
);
2364 void qemu_display_init(DisplayState
*ds
, DisplayOptions
*opts
)
2366 assert(opts
->type
< DISPLAY_TYPE__MAX
);
2367 if (opts
->type
== DISPLAY_TYPE_NONE
) {
2370 assert(dpys
[opts
->type
] != NULL
);
2371 dpys
[opts
->type
]->init(ds
, opts
);
2374 void qemu_display_help(void)
2378 printf("Available display backend types:\n");
2380 for (idx
= DISPLAY_TYPE_NONE
; idx
< DISPLAY_TYPE__MAX
; idx
++) {
2382 ui_module_load_one(DisplayType_str(idx
));
2385 printf("%s\n", DisplayType_str(dpys
[idx
]->type
));
2390 void qemu_chr_parse_vc(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
)
2395 backend
->type
= CHARDEV_BACKEND_KIND_VC
;
2396 vc
= backend
->u
.vc
.data
= g_new0(ChardevVC
, 1);
2397 qemu_chr_parse_common(opts
, qapi_ChardevVC_base(vc
));
2399 val
= qemu_opt_get_number(opts
, "width", 0);
2401 vc
->has_width
= true;
2405 val
= qemu_opt_get_number(opts
, "height", 0);
2407 vc
->has_height
= true;
2411 val
= qemu_opt_get_number(opts
, "cols", 0);
2413 vc
->has_cols
= true;
2417 val
= qemu_opt_get_number(opts
, "rows", 0);
2419 vc
->has_rows
= true;
2424 static const TypeInfo qemu_console_info
= {
2425 .name
= TYPE_QEMU_CONSOLE
,
2426 .parent
= TYPE_OBJECT
,
2427 .instance_size
= sizeof(QemuConsole
),
2428 .class_size
= sizeof(QemuConsoleClass
),
2431 static void char_vc_class_init(ObjectClass
*oc
, void *data
)
2433 ChardevClass
*cc
= CHARDEV_CLASS(oc
);
2435 cc
->parse
= qemu_chr_parse_vc
;
2436 cc
->open
= vc_chr_open
;
2437 cc
->chr_write
= vc_chr_write
;
2438 cc
->chr_set_echo
= vc_chr_set_echo
;
2441 static const TypeInfo char_vc_type_info
= {
2442 .name
= TYPE_CHARDEV_VC
,
2443 .parent
= TYPE_CHARDEV
,
2444 .instance_size
= sizeof(VCChardev
),
2445 .class_init
= char_vc_class_init
,
2448 void qemu_console_early_init(void)
2450 /* set the default vc driver */
2451 if (!object_class_by_name(TYPE_CHARDEV_VC
)) {
2452 type_register(&char_vc_type_info
);
2456 static void register_types(void)
2458 type_register_static(&qemu_console_info
);
2461 type_init(register_types
);