meson: convert qapi-specific to meson
[qemu.git] / hw / semihosting / console.c
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 "cpu.h"
20 #include "hw/semihosting/semihost.h"
21 #include "hw/semihosting/console.h"
22 #include "exec/gdbstub.h"
23 #include "exec/exec-all.h"
24 #include "qemu/log.h"
25 #include "chardev/char.h"
26 #include "chardev/char-fe.h"
27 #include "sysemu/sysemu.h"
28 #include "qemu/main-loop.h"
29 #include "qapi/error.h"
30 #include "qemu/fifo8.h"
31
32 int qemu_semihosting_log_out(const char *s, int len)
33 {
34 Chardev *chardev = semihosting_get_chardev();
35 if (chardev) {
36 return qemu_chr_write_all(chardev, (uint8_t *) s, len);
37 } else {
38 return write(STDERR_FILENO, s, len);
39 }
40 }
41
42 /*
43 * A re-implementation of lock_user_string that we can use locally
44 * instead of relying on softmmu-semi. Hopefully we can deprecate that
45 * in time. Copy string until we find a 0 or address error.
46 */
47 static GString *copy_user_string(CPUArchState *env, target_ulong addr)
48 {
49 CPUState *cpu = env_cpu(env);
50 GString *s = g_string_sized_new(128);
51 uint8_t c;
52
53 do {
54 if (cpu_memory_rw_debug(cpu, addr++, &c, 1, 0) == 0) {
55 if (c) {
56 s = g_string_append_c(s, c);
57 }
58 } else {
59 qemu_log_mask(LOG_GUEST_ERROR,
60 "%s: passed inaccessible address " TARGET_FMT_lx,
61 __func__, addr);
62 break;
63 }
64 } while (c!=0);
65
66 return s;
67 }
68
69 static void semihosting_cb(CPUState *cs, target_ulong ret, target_ulong err)
70 {
71 if (ret == (target_ulong) -1) {
72 qemu_log("%s: gdb console output failed ("TARGET_FMT_ld")",
73 __func__, err);
74 }
75 }
76
77 int qemu_semihosting_console_outs(CPUArchState *env, target_ulong addr)
78 {
79 GString *s = copy_user_string(env, addr);
80 int out = s->len;
81
82 if (use_gdb_syscalls()) {
83 gdb_do_syscall(semihosting_cb, "write,2,%x,%x", addr, s->len);
84 } else {
85 out = qemu_semihosting_log_out(s->str, s->len);
86 }
87
88 g_string_free(s, true);
89 return out;
90 }
91
92 void qemu_semihosting_console_outc(CPUArchState *env, target_ulong addr)
93 {
94 CPUState *cpu = env_cpu(env);
95 uint8_t c;
96
97 if (cpu_memory_rw_debug(cpu, addr, &c, 1, 0) == 0) {
98 if (use_gdb_syscalls()) {
99 gdb_do_syscall(semihosting_cb, "write,2,%x,%x", addr, 1);
100 } else {
101 qemu_semihosting_log_out((const char *) &c, 1);
102 }
103 } else {
104 qemu_log_mask(LOG_GUEST_ERROR,
105 "%s: passed inaccessible address " TARGET_FMT_lx,
106 __func__, addr);
107 }
108 }
109
110 #define FIFO_SIZE 1024
111
112 /* Access to this structure is protected by the BQL */
113 typedef struct SemihostingConsole {
114 CharBackend backend;
115 GSList *sleeping_cpus;
116 bool got;
117 Fifo8 fifo;
118 } SemihostingConsole;
119
120 static SemihostingConsole console;
121
122 static int console_can_read(void *opaque)
123 {
124 SemihostingConsole *c = opaque;
125 int ret;
126 g_assert(qemu_mutex_iothread_locked());
127 ret = (int) fifo8_num_free(&c->fifo);
128 return ret;
129 }
130
131 static void console_wake_up(gpointer data, gpointer user_data)
132 {
133 CPUState *cs = (CPUState *) data;
134 /* cpu_handle_halt won't know we have work so just unbung here */
135 cs->halted = 0;
136 qemu_cpu_kick(cs);
137 }
138
139 static void console_read(void *opaque, const uint8_t *buf, int size)
140 {
141 SemihostingConsole *c = opaque;
142 g_assert(qemu_mutex_iothread_locked());
143 while (size-- && !fifo8_is_full(&c->fifo)) {
144 fifo8_push(&c->fifo, *buf++);
145 }
146 g_slist_foreach(c->sleeping_cpus, console_wake_up, NULL);
147 c->sleeping_cpus = NULL;
148 }
149
150 target_ulong qemu_semihosting_console_inc(CPUArchState *env)
151 {
152 uint8_t ch;
153 SemihostingConsole *c = &console;
154 g_assert(qemu_mutex_iothread_locked());
155 g_assert(current_cpu);
156 if (fifo8_is_empty(&c->fifo)) {
157 c->sleeping_cpus = g_slist_prepend(c->sleeping_cpus, current_cpu);
158 current_cpu->halted = 1;
159 current_cpu->exception_index = EXCP_HALTED;
160 cpu_loop_exit(current_cpu);
161 /* never returns */
162 }
163 ch = fifo8_pop(&c->fifo);
164 return (target_ulong) ch;
165 }
166
167 void qemu_semihosting_console_init(void)
168 {
169 Chardev *chr = semihosting_get_chardev();
170
171 if (chr) {
172 fifo8_create(&console.fifo, FIFO_SIZE);
173 qemu_chr_fe_init(&console.backend, chr, &error_abort);
174 qemu_chr_fe_set_handlers(&console.backend,
175 console_can_read,
176 console_read,
177 NULL, NULL, &console,
178 NULL, true);
179 }
180 }