1 /*
2 * Semihosting Console Support
3 *
4 * Copyright (c) 2015 Imagination Technologies
5 * Copyright (c) 2019 Linaro Ltd
6 *
7 * This provides support for outputting to a semihosting console.
8 *
9 * While most semihosting implementations support reading and writing
10 * to arbitrary file descriptors we treat the console as something
11 * specifically for debugging interaction. This means messages can be
12 * re-directed to gdb (if currently being used to debug) or even
13 * re-directed elsewhere.
14 *
15 * SPDX-License-Identifier: GPL-2.0-or-later
16 */
17
18 #include "qemu/osdep.h"
19 #include "semihosting/semihost.h"
20 #include "semihosting/console.h"
21 #include "exec/gdbstub.h"
22 #include "exec/exec-all.h"
23 #include "qemu/log.h"
24 #include "chardev/char.h"
25 #include "chardev/char-fe.h"
26 #include "qemu/main-loop.h"
27 #include "qapi/error.h"
28 #include "qemu/fifo8.h"
29
30 /* Access to this structure is protected by the BQL */
31 typedef struct SemihostingConsole {
32 CharBackend backend;
33 Chardev *chr;
34 GSList *sleeping_cpus;
35 bool got;
36 Fifo8 fifo;
37 } SemihostingConsole;
38
39 static SemihostingConsole console;
40
41 #define FIFO_SIZE 1024
42
console_can_read(void * opaque)43 static int console_can_read(void *opaque)
44 {
45 SemihostingConsole *c = opaque;
46 g_assert(bql_locked());
47 return (int)fifo8_num_free(&c->fifo);
48 }
49
console_wake_up(gpointer data,gpointer user_data)50 static void console_wake_up(gpointer data, gpointer user_data)
51 {
52 CPUState *cs = (CPUState *) data;
53 /* cpu_handle_halt won't know we have work so just unbung here */
54 cs->halted = 0;
55 qemu_cpu_kick(cs);
56 }
57
console_read(void * opaque,const uint8_t * buf,int size)58 static void console_read(void *opaque, const uint8_t *buf, int size)
59 {
60 SemihostingConsole *c = opaque;
61 g_assert(bql_locked());
62 while (size-- && !fifo8_is_full(&c->fifo)) {
63 fifo8_push(&c->fifo, *buf++);
64 }
65 g_slist_foreach(c->sleeping_cpus, console_wake_up, NULL);
66 c->sleeping_cpus = NULL;
67 }
68
qemu_semihosting_console_ready(void)69 bool qemu_semihosting_console_ready(void)
70 {
71 SemihostingConsole *c = &console;
72
73 g_assert(bql_locked());
74 return !fifo8_is_empty(&c->fifo);
75 }
76
qemu_semihosting_console_block_until_ready(CPUState * cs)77 void qemu_semihosting_console_block_until_ready(CPUState *cs)
78 {
79 SemihostingConsole *c = &console;
80
81 g_assert(bql_locked());
82
83 /* Block if the fifo is completely empty. */
84 if (fifo8_is_empty(&c->fifo)) {
85 c->sleeping_cpus = g_slist_prepend(c->sleeping_cpus, cs);
86 cs->halted = 1;
87 cs->exception_index = EXCP_HALTED;
88 cpu_loop_exit(cs);
89 /* never returns */
90 }
91 }
92
qemu_semihosting_console_read(CPUState * cs,void * buf,int len)93 int qemu_semihosting_console_read(CPUState *cs, void *buf, int len)
94 {
95 SemihostingConsole *c = &console;
96 int ret = 0;
97
98 qemu_semihosting_console_block_until_ready(cs);
99
100 /* Read until buffer full or fifo exhausted. */
101 do {
102 *(char *)(buf + ret) = fifo8_pop(&c->fifo);
103 ret++;
104 } while (ret < len && !fifo8_is_empty(&c->fifo));
105
106 return ret;
107 }
108
qemu_semihosting_console_write(void * buf,int len)109 int qemu_semihosting_console_write(void *buf, int len)
110 {
111 if (console.chr) {
112 int r = qemu_chr_write_all(console.chr, (uint8_t *)buf, len);
113 return r < 0 ? 0 : r;
114 } else {
115 return fwrite(buf, 1, len, stderr);
116 }
117 }
118
qemu_semihosting_console_init(Chardev * chr)119 void qemu_semihosting_console_init(Chardev *chr)
120 {
121 console.chr = chr;
122 if (chr) {
123 fifo8_create(&console.fifo, FIFO_SIZE);
124 qemu_chr_fe_init(&console.backend, chr, &error_abort);
125 qemu_chr_fe_set_handlers(&console.backend,
126 console_can_read,
127 console_read,
128 NULL, NULL, &console,
129 NULL, true);
130 }
131
132 qemu_semihosting_guestfd_init();
133 }
134