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