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 "semihosting/semihost.h" 21 #include "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 } 181