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/cpu-common.h" 22 #include "exec/gdbstub.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 #include "hw/core/cpu.h" 30 31 /* Access to this structure is protected by the BQL */ 32 typedef struct SemihostingConsole { 33 CharBackend backend; 34 Chardev *chr; 35 GSList *sleeping_cpus; 36 bool got; 37 Fifo8 fifo; 38 } SemihostingConsole; 39 40 static SemihostingConsole console; 41 42 #define FIFO_SIZE 1024 43 console_can_read(void * opaque)44 static int console_can_read(void *opaque) 45 { 46 SemihostingConsole *c = opaque; 47 g_assert(bql_locked()); 48 return (int)fifo8_num_free(&c->fifo); 49 } 50 console_wake_up(gpointer data,gpointer user_data)51 static void console_wake_up(gpointer data, gpointer user_data) 52 { 53 CPUState *cs = (CPUState *) data; 54 /* cpu_handle_halt won't know we have work so just unbung here */ 55 cs->halted = 0; 56 qemu_cpu_kick(cs); 57 } 58 console_read(void * opaque,const uint8_t * buf,int size)59 static void console_read(void *opaque, const uint8_t *buf, int size) 60 { 61 SemihostingConsole *c = opaque; 62 g_assert(bql_locked()); 63 while (size-- && !fifo8_is_full(&c->fifo)) { 64 fifo8_push(&c->fifo, *buf++); 65 } 66 g_slist_foreach(c->sleeping_cpus, console_wake_up, NULL); 67 c->sleeping_cpus = NULL; 68 } 69 qemu_semihosting_console_ready(void)70 bool qemu_semihosting_console_ready(void) 71 { 72 SemihostingConsole *c = &console; 73 74 g_assert(bql_locked()); 75 return !fifo8_is_empty(&c->fifo); 76 } 77 qemu_semihosting_console_block_until_ready(CPUState * cs)78 void qemu_semihosting_console_block_until_ready(CPUState *cs) 79 { 80 SemihostingConsole *c = &console; 81 82 g_assert(bql_locked()); 83 84 /* Block if the fifo is completely empty. */ 85 if (fifo8_is_empty(&c->fifo)) { 86 c->sleeping_cpus = g_slist_prepend(c->sleeping_cpus, cs); 87 cs->halted = 1; 88 cs->exception_index = EXCP_HALTED; 89 cpu_loop_exit(cs); 90 /* never returns */ 91 } 92 } 93 qemu_semihosting_console_read(CPUState * cs,void * buf,int len)94 int qemu_semihosting_console_read(CPUState *cs, void *buf, int len) 95 { 96 SemihostingConsole *c = &console; 97 int ret = 0; 98 99 qemu_semihosting_console_block_until_ready(cs); 100 101 /* Read until buffer full or fifo exhausted. */ 102 do { 103 *(char *)(buf + ret) = fifo8_pop(&c->fifo); 104 ret++; 105 } while (ret < len && !fifo8_is_empty(&c->fifo)); 106 107 return ret; 108 } 109 qemu_semihosting_console_write(void * buf,int len)110 int qemu_semihosting_console_write(void *buf, int len) 111 { 112 if (console.chr) { 113 int r = qemu_chr_write_all(console.chr, (uint8_t *)buf, len); 114 return r < 0 ? 0 : r; 115 } else { 116 return fwrite(buf, 1, len, stderr); 117 } 118 } 119 qemu_semihosting_console_init(Chardev * chr)120 void qemu_semihosting_console_init(Chardev *chr) 121 { 122 console.chr = chr; 123 if (chr) { 124 fifo8_create(&console.fifo, FIFO_SIZE); 125 qemu_chr_fe_init(&console.backend, chr, &error_abort); 126 qemu_chr_fe_set_handlers(&console.backend, 127 console_can_read, 128 console_read, 129 NULL, NULL, &console, 130 NULL, true); 131 } 132 133 qemu_semihosting_guestfd_init(); 134 } 135