blob: d78c6428b90b570a44f3b88bd4a235fa5486f431 [file] [log] [blame]
bellarda4f81972005-04-23 18:25:41 +00001/*
Keith Packard0bb446d2021-01-08 22:42:49 +00002 * Semihosting support for systems modeled on the Arm "Angel"
Keith Packarda10b9d92021-01-08 22:42:52 +00003 * semihosting syscalls design. This includes Arm and RISC-V processors
ths5fafdf22007-09-16 21:08:06 +00004 *
pbrook8e716212007-01-20 17:12:09 +00005 * Copyright (c) 2005, 2007 CodeSourcery.
Alex Bennée4cb28db2019-05-14 12:08:39 +01006 * Copyright (c) 2019 Linaro
pbrook8e716212007-01-20 17:12:09 +00007 * Written by Paul Brook.
bellarda4f81972005-04-23 18:25:41 +00008 *
Keith Packard0bb446d2021-01-08 22:42:49 +00009 * Copyright © 2020 by Keith Packard <keithp@keithp.com>
10 * Adapted for systems other than ARM, including RISC-V, by Keith Packard
11 *
bellarda4f81972005-04-23 18:25:41 +000012 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
Blue Swirl8167ee82009-07-16 20:47:01 +000023 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Alex Bennée4cb28db2019-05-14 12:08:39 +010024 *
25 * ARM Semihosting is documented in:
26 * Semihosting for AArch32 and AArch64 Release 2.0
Alex Bennée424d5ec2022-09-29 12:42:21 +010027 * https://github.com/ARM-software/abi-aa/blob/main/semihosting/semihosting.rst
Keith Packarda10b9d92021-01-08 22:42:52 +000028 *
29 * RISC-V Semihosting is documented in:
30 * RISC-V Semihosting
31 * https://github.com/riscv/riscv-semihosting-spec/blob/main/riscv-semihosting-spec.adoc
bellarda4f81972005-04-23 18:25:41 +000032 */
33
Peter Maydell74c21bd2015-12-07 16:23:44 +000034#include "qemu/osdep.h"
Richard Henderson5b3f39c2022-04-28 01:44:28 -070035#include "qemu/timer.h"
36#include "exec/gdbstub.h"
Alex Bennéec5660802023-03-02 18:57:57 -080037#include "gdbstub/syscalls.h"
Philippe Mathieu-Daudé6b5fe132021-03-05 13:54:49 +000038#include "semihosting/semihost.h"
39#include "semihosting/console.h"
40#include "semihosting/common-semi.h"
Richard Henderson1c6ff722022-04-27 21:38:02 -070041#include "semihosting/guestfd.h"
Richard Henderson5b3f39c2022-04-28 01:44:28 -070042#include "semihosting/syscalls.h"
Richard Henderson1c6ff722022-04-27 21:38:02 -070043
pbrook8e716212007-01-20 17:12:09 +000044#ifdef CONFIG_USER_ONLY
bellarda4f81972005-04-23 18:25:41 +000045#include "qemu.h"
46
Keith Packard3c37cfe2021-01-08 22:42:50 +000047#define COMMON_SEMI_HEAP_SIZE (128 * 1024 * 1024)
pbrook8e716212007-01-20 17:12:09 +000048#else
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020049#include "qemu/cutils.h"
Alex Bennée5fc983a2022-02-25 17:20:20 +000050#include "hw/loader.h"
Paolo Bonzini6e504a92020-10-28 06:18:20 -040051#include "hw/boards.h"
pbrook8e716212007-01-20 17:12:09 +000052#endif
bellarda4f81972005-04-23 18:25:41 +000053
Stefan Weil38817252012-04-28 05:07:47 +000054#define TARGET_SYS_OPEN 0x01
55#define TARGET_SYS_CLOSE 0x02
56#define TARGET_SYS_WRITEC 0x03
57#define TARGET_SYS_WRITE0 0x04
58#define TARGET_SYS_WRITE 0x05
59#define TARGET_SYS_READ 0x06
60#define TARGET_SYS_READC 0x07
Keith Packard767ba042021-01-08 22:42:56 +000061#define TARGET_SYS_ISERROR 0x08
Stefan Weil38817252012-04-28 05:07:47 +000062#define TARGET_SYS_ISTTY 0x09
63#define TARGET_SYS_SEEK 0x0a
64#define TARGET_SYS_FLEN 0x0c
65#define TARGET_SYS_TMPNAM 0x0d
66#define TARGET_SYS_REMOVE 0x0e
67#define TARGET_SYS_RENAME 0x0f
68#define TARGET_SYS_CLOCK 0x10
69#define TARGET_SYS_TIME 0x11
70#define TARGET_SYS_SYSTEM 0x12
71#define TARGET_SYS_ERRNO 0x13
72#define TARGET_SYS_GET_CMDLINE 0x15
73#define TARGET_SYS_HEAPINFO 0x16
74#define TARGET_SYS_EXIT 0x18
Peter Maydelle9ebfbf2015-09-07 10:39:28 +010075#define TARGET_SYS_SYNCCACHE 0x19
Peter Maydell22a43bb2019-09-16 15:15:43 +010076#define TARGET_SYS_EXIT_EXTENDED 0x20
Keith Packard4d834032021-01-08 22:42:54 +000077#define TARGET_SYS_ELAPSED 0x30
78#define TARGET_SYS_TICKFREQ 0x31
bellarda4f81972005-04-23 18:25:41 +000079
Liviu Ionescu1ecc3a22014-12-11 12:07:48 +000080/* ADP_Stopped_ApplicationExit is used for exit(0),
81 * anything else is implemented as exit(1) */
82#define ADP_Stopped_ApplicationExit (0x20026)
83
bellarda4f81972005-04-23 18:25:41 +000084#ifndef O_BINARY
85#define O_BINARY 0
86#endif
87
pbrooka2d1eba2007-01-28 03:10:55 +000088static int gdb_open_modeflags[12] = {
89 GDB_O_RDONLY,
Richard Hendersona1a2a3e2022-06-07 10:50:43 -070090 GDB_O_RDONLY,
pbrooka2d1eba2007-01-28 03:10:55 +000091 GDB_O_RDWR,
Richard Hendersona1a2a3e2022-06-07 10:50:43 -070092 GDB_O_RDWR,
pbrooka2d1eba2007-01-28 03:10:55 +000093 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC,
Richard Hendersona1a2a3e2022-06-07 10:50:43 -070094 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC,
pbrooka2d1eba2007-01-28 03:10:55 +000095 GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC,
Richard Hendersona1a2a3e2022-06-07 10:50:43 -070096 GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC,
pbrooka2d1eba2007-01-28 03:10:55 +000097 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND,
Richard Hendersona1a2a3e2022-06-07 10:50:43 -070098 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND,
pbrooka2d1eba2007-01-28 03:10:55 +000099 GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND,
Richard Hendersona1a2a3e2022-06-07 10:50:43 -0700100 GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND,
pbrooka2d1eba2007-01-28 03:10:55 +0000101};
102
Keith Packard095f8c02021-01-08 22:42:51 +0000103#ifndef CONFIG_USER_ONLY
Alex Bennée5fc983a2022-02-25 17:20:20 +0000104
105/**
106 * common_semi_find_bases: find information about ram and heap base
107 *
108 * This function attempts to provide meaningful numbers for RAM and
109 * HEAP base addresses. The rambase is simply the lowest addressable
110 * RAM position. For the heapbase we ask the loader to scan the
111 * address space and the largest available gap by querying the "ROM"
112 * regions.
113 *
114 * Returns: a structure with the numbers we need.
Keith Packard095f8c02021-01-08 22:42:51 +0000115 */
Alex Bennée5fc983a2022-02-25 17:20:20 +0000116
117typedef struct LayoutInfo {
118 target_ulong rambase;
119 size_t ramsize;
120 hwaddr heapbase;
121 hwaddr heaplimit;
122} LayoutInfo;
123
124static bool find_ram_cb(Int128 start, Int128 len, const MemoryRegion *mr,
125 hwaddr offset_in_region, void *opaque)
Keith Packard095f8c02021-01-08 22:42:51 +0000126{
Alex Bennée5fc983a2022-02-25 17:20:20 +0000127 LayoutInfo *info = (LayoutInfo *) opaque;
128 uint64_t size = int128_get64(len);
129
130 if (!mr->ram || mr->readonly) {
131 return false;
132 }
133
134 if (size > info->ramsize) {
135 info->rambase = int128_get64(start);
136 info->ramsize = size;
137 }
138
139 /* search exhaustively for largest RAM */
140 return false;
141}
142
143static LayoutInfo common_semi_find_bases(CPUState *cs)
144{
145 FlatView *fv;
146 LayoutInfo info = { 0, 0, 0, 0 };
147
148 RCU_READ_LOCK_GUARD();
149
150 fv = address_space_to_flatview(cs->as);
151 flatview_for_each_range(fv, find_ram_cb, &info);
Keith Packard095f8c02021-01-08 22:42:51 +0000152
153 /*
Alex Bennée5fc983a2022-02-25 17:20:20 +0000154 * If we have found the RAM lets iterate through the ROM blobs to
155 * work out the best place for the remainder of RAM and split it
156 * equally between stack and heap.
Keith Packard095f8c02021-01-08 22:42:51 +0000157 */
Alex Bennée5fc983a2022-02-25 17:20:20 +0000158 if (info.rambase || info.ramsize > 0) {
159 RomGap gap = rom_find_largest_gap_between(info.rambase, info.ramsize);
160 info.heapbase = gap.base;
161 info.heaplimit = gap.base + gap.size;
Keith Packard095f8c02021-01-08 22:42:51 +0000162 }
Alex Bennée5fc983a2022-02-25 17:20:20 +0000163
164 return info;
Keith Packard095f8c02021-01-08 22:42:51 +0000165}
Alex Bennée5fc983a2022-02-25 17:20:20 +0000166
Keith Packard095f8c02021-01-08 22:42:51 +0000167#endif
168
Richard Henderson1b3b7692022-06-07 10:31:22 -0700169#include "common-semi-target.h"
Keith Packarda10b9d92021-01-08 22:42:52 +0000170
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100171/*
Richard Henderson3753b002022-04-28 11:40:14 -0700172 * Read the input value from the argument block; fail the semihosting
173 * call if the memory read fails. Eventually we could use a generic
174 * CPUState helper function here.
Peter Maydellfed49cd2022-07-25 15:05:15 +0100175 * Note that GET_ARG() handles memory access errors by jumping to
176 * do_fault, so must be used as the first thing done in handling a
177 * semihosting call, to avoid accidentally leaking allocated resources.
178 * SET_ARG(), since it unavoidably happens late, instead returns an
179 * error indication (0 on success, non-0 for error) which the caller
180 * should check.
Richard Henderson3753b002022-04-28 11:40:14 -0700181 */
182
183#define GET_ARG(n) do { \
184 if (is_64bit_semihosting(env)) { \
185 if (get_user_u64(arg ## n, args + (n) * 8)) { \
186 goto do_fault; \
187 } \
188 } else { \
189 if (get_user_u32(arg ## n, args + (n) * 4)) { \
190 goto do_fault; \
191 } \
192 } \
193} while (0)
194
195#define SET_ARG(n, val) \
196 (is_64bit_semihosting(env) ? \
197 put_user_u64(val, args + (n) * 8) : \
198 put_user_u32(val, args + (n) * 4))
199
200
201/*
Peter Maydell6ed68452019-09-16 15:15:34 +0100202 * The semihosting API has no concept of its errno being thread-safe,
203 * as the API design predates SMP CPUs and was intended as a simple
204 * real-hardware set of debug functionality. For QEMU, we make the
Philippe Mathieu-Daudéf14eced2023-10-04 11:06:23 +0200205 * errno be per-thread in linux-user mode; in system-mode it is a simple
Peter Maydell6ed68452019-09-16 15:15:34 +0100206 * global, and we assume that the guest takes care of avoiding any races.
207 */
208#ifndef CONFIG_USER_ONLY
Peter Maydell1b003822019-09-16 15:15:30 +0100209static target_ulong syscall_err;
210
Philippe Mathieu-Daudéf14eced2023-10-04 11:06:23 +0200211#include "semihosting/uaccess.h"
Peter Maydell6ed68452019-09-16 15:15:34 +0100212#endif
213
Keith Packard3c37cfe2021-01-08 22:42:50 +0000214static inline uint32_t get_swi_errno(CPUState *cs)
Peter Maydell6ed68452019-09-16 15:15:34 +0100215{
216#ifdef CONFIG_USER_ONLY
Ilya Leoshkeviche4e5cb42024-03-05 12:09:39 +0000217 TaskState *ts = get_task_state(cs);
Peter Maydell6ed68452019-09-16 15:15:34 +0100218
219 return ts->swi_errno;
220#else
221 return syscall_err;
pbrook8e716212007-01-20 17:12:09 +0000222#endif
Peter Maydell6ed68452019-09-16 15:15:34 +0100223}
bellarda4f81972005-04-23 18:25:41 +0000224
Richard Henderson64c8c6a2022-04-29 16:21:43 -0700225static void common_semi_cb(CPUState *cs, uint64_t ret, int err)
pbrooka2d1eba2007-01-28 03:10:55 +0000226{
Richard Henderson709fe272022-04-29 12:32:24 -0700227 if (err) {
Richard Henderson5aadd182022-05-16 19:25:19 -0700228#ifdef CONFIG_USER_ONLY
Ilya Leoshkeviche4e5cb42024-03-05 12:09:39 +0000229 TaskState *ts = get_task_state(cs);
Richard Henderson5aadd182022-05-16 19:25:19 -0700230 ts->swi_errno = err;
231#else
232 syscall_err = err;
233#endif
pbrooka2d1eba2007-01-28 03:10:55 +0000234 }
Richard Henderson5aadd182022-05-16 19:25:19 -0700235 common_semi_set_ret(cs, ret);
Peter Maydellfaacc042015-09-07 10:39:28 +0100236}
237
Richard Henderson3c820dd2022-04-29 13:59:52 -0700238/*
Richard Henderson5d772892022-05-01 17:55:20 -0700239 * Use 0xdeadbeef as the return value when there isn't a defined
240 * return value for the call.
241 */
242static void common_semi_dead_cb(CPUState *cs, uint64_t ret, int err)
243{
244 common_semi_set_ret(cs, 0xdeadbeef);
245}
246
247/*
Richard Hendersonaf0484b2022-04-28 11:40:41 -0700248 * SYS_READ and SYS_WRITE always return the number of bytes not read/written.
249 * There is no error condition, other than returning the original length.
250 */
Richard Henderson64c8c6a2022-04-29 16:21:43 -0700251static void common_semi_rw_cb(CPUState *cs, uint64_t ret, int err)
Richard Hendersonaf0484b2022-04-28 11:40:41 -0700252{
253 /* Recover the original length from the third argument. */
Richard Hendersonb77af262023-09-13 17:22:49 -0700254 CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
Richard Hendersonaf0484b2022-04-28 11:40:41 -0700255 target_ulong args = common_semi_arg(cs, 1);
256 target_ulong arg2;
257 GET_ARG(2);
258
259 if (err) {
260 do_fault:
261 ret = 0; /* error: no bytes transmitted */
262 }
263 common_semi_set_ret(cs, arg2 - ret);
264}
265
266/*
Richard Hendersona2212472022-04-28 12:31:25 -0700267 * Convert from Posix ret+errno to Arm SYS_ISTTY return values.
268 * With gdbstub, err is only ever set for protocol errors to EIO.
269 */
Richard Henderson64c8c6a2022-04-29 16:21:43 -0700270static void common_semi_istty_cb(CPUState *cs, uint64_t ret, int err)
Richard Hendersona2212472022-04-28 12:31:25 -0700271{
272 if (err) {
273 ret = (err == ENOTTY ? 0 : -1);
274 }
275 common_semi_cb(cs, ret, err);
276}
277
278/*
Richard Henderson9a894702022-04-28 12:04:44 -0700279 * SYS_SEEK returns 0 on success, not the resulting offset.
280 */
Richard Henderson64c8c6a2022-04-29 16:21:43 -0700281static void common_semi_seek_cb(CPUState *cs, uint64_t ret, int err)
Richard Henderson9a894702022-04-28 12:04:44 -0700282{
283 if (!err) {
284 ret = 0;
285 }
286 common_semi_cb(cs, ret, err);
287}
288
289/*
Richard Henderson3c820dd2022-04-29 13:59:52 -0700290 * Return an address in target memory of 64 bytes where the remote
291 * gdb should write its stat struct. (The format of this structure
292 * is defined by GDB's remote protocol and is not target-specific.)
293 * We put this on the guest's stack just below SP.
294 */
Keith Packard3c37cfe2021-01-08 22:42:50 +0000295static target_ulong common_semi_flen_buf(CPUState *cs)
Peter Maydellfaacc042015-09-07 10:39:28 +0100296{
Richard Henderson3c820dd2022-04-29 13:59:52 -0700297 target_ulong sp = common_semi_stack_bottom(cs);
Peter Maydellfaacc042015-09-07 10:39:28 +0100298 return sp - 64;
pbrooka2d1eba2007-01-28 03:10:55 +0000299}
300
Keith Packard3c37cfe2021-01-08 22:42:50 +0000301static void
Richard Henderson64c8c6a2022-04-29 16:21:43 -0700302common_semi_flen_fstat_cb(CPUState *cs, uint64_t ret, int err)
pbrook33d9cc82007-06-09 14:44:00 +0000303{
Richard Henderson84ca0df2022-05-16 19:34:06 -0700304 if (!err) {
Richard Hendersoncd7f29e2022-04-29 14:55:21 -0700305 /* The size is always stored in big-endian order, extract the value. */
306 uint64_t size;
Richard Hendersona6300ed2022-04-29 09:05:36 -0700307 if (cpu_memory_rw_debug(cs, common_semi_flen_buf(cs) +
308 offsetof(struct gdb_stat, gdb_st_size),
309 &size, 8, 0)) {
310 ret = -1, err = EFAULT;
311 } else {
312 size = be64_to_cpu(size);
313 if (ret != size) {
314 ret = -1, err = EOVERFLOW;
315 }
316 }
Richard Henderson84ca0df2022-05-16 19:34:06 -0700317 }
318 common_semi_cb(cs, ret, err);
pbrook33d9cc82007-06-09 14:44:00 +0000319}
320
Richard Henderson1577eec2022-05-01 17:42:43 -0700321static void
322common_semi_readc_cb(CPUState *cs, uint64_t ret, int err)
323{
324 if (!err) {
Richard Hendersonb77af262023-09-13 17:22:49 -0700325 CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
Richard Henderson1577eec2022-05-01 17:42:43 -0700326 uint8_t ch;
327
328 if (get_user_u8(ch, common_semi_stack_bottom(cs) - 1)) {
329 ret = -1, err = EFAULT;
330 } else {
331 ret = ch;
332 }
333 }
334 common_semi_cb(cs, ret, err);
335}
336
Peter Maydellc46a6532019-09-16 15:15:42 +0100337#define SHFB_MAGIC_0 0x53
338#define SHFB_MAGIC_1 0x48
339#define SHFB_MAGIC_2 0x46
340#define SHFB_MAGIC_3 0x42
341
Peter Maydell22a43bb2019-09-16 15:15:43 +0100342/* Feature bits reportable in feature byte 0 */
343#define SH_EXT_EXIT_EXTENDED (1 << 0)
Peter Maydell6ee18642019-09-16 15:15:44 +0100344#define SH_EXT_STDOUT_STDERR (1 << 1)
Peter Maydell22a43bb2019-09-16 15:15:43 +0100345
Peter Maydellc46a6532019-09-16 15:15:42 +0100346static const uint8_t featurefile_data[] = {
347 SHFB_MAGIC_0,
348 SHFB_MAGIC_1,
349 SHFB_MAGIC_2,
350 SHFB_MAGIC_3,
Peter Maydell6ee18642019-09-16 15:15:44 +0100351 SH_EXT_EXIT_EXTENDED | SH_EXT_STDOUT_STDERR, /* Feature byte 0 */
Peter Maydellc46a6532019-09-16 15:15:42 +0100352};
353
Alex Bennée3960ca52021-03-23 16:52:52 +0000354/*
Alex Bennée4cb28db2019-05-14 12:08:39 +0100355 * Do a semihosting call.
356 *
357 * The specification always says that the "return register" either
358 * returns a specific value or is corrupted, so we don't need to
359 * report to our caller whether we are returning a value or trying to
Richard Henderson5d772892022-05-01 17:55:20 -0700360 * leave the register unchanged.
Alex Bennée4cb28db2019-05-14 12:08:39 +0100361 */
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700362void do_common_semihosting(CPUState *cs)
bellarda4f81972005-04-23 18:25:41 +0000363{
Richard Hendersonb77af262023-09-13 17:22:49 -0700364 CPUArchState *env = cpu_env(cs);
pbrook53a59602006-03-25 19:31:22 +0000365 target_ulong args;
Peter Maydellf296c0d2012-10-14 09:52:27 +0000366 target_ulong arg0, arg1, arg2, arg3;
Keith Packard27e3b102021-01-08 22:42:55 +0000367 target_ulong ul_ret;
bellarda4f81972005-04-23 18:25:41 +0000368 char * s;
369 int nr;
Keith Packard4d834032021-01-08 22:42:54 +0000370 int64_t elapsed;
bellarda4f81972005-04-23 18:25:41 +0000371
Keith Packard3c37cfe2021-01-08 22:42:50 +0000372 nr = common_semi_arg(cs, 0) & 0xffffffffU;
373 args = common_semi_arg(cs, 1);
Peter Maydellfaacc042015-09-07 10:39:28 +0100374
bellarda4f81972005-04-23 18:25:41 +0000375 switch (nr) {
Stefan Weil38817252012-04-28 05:07:47 +0000376 case TARGET_SYS_OPEN:
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100377 {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700378 int ret, err = 0;
379 int hostfd;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100380
Peter Maydellf296c0d2012-10-14 09:52:27 +0000381 GET_ARG(0);
382 GET_ARG(1);
383 GET_ARG(2);
384 s = lock_user_string(arg0);
385 if (!s) {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700386 goto do_fault;
Peter Maydellf296c0d2012-10-14 09:52:27 +0000387 }
388 if (arg1 >= 12) {
389 unlock_user(s, arg0, 0);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700390 common_semi_cb(cs, -1, EINVAL);
391 break;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100392 }
393
bellarda4f81972005-04-23 18:25:41 +0000394 if (strcmp(s, ":tt") == 0) {
Peter Maydell6ee18642019-09-16 15:15:44 +0100395 /*
396 * We implement SH_EXT_STDOUT_STDERR, so:
397 * open for read == stdin
398 * open for write == stdout
399 * open for append == stderr
400 */
401 if (arg1 < 4) {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700402 hostfd = STDIN_FILENO;
Peter Maydell6ee18642019-09-16 15:15:44 +0100403 } else if (arg1 < 8) {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700404 hostfd = STDOUT_FILENO;
Peter Maydell6ee18642019-09-16 15:15:44 +0100405 } else {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700406 hostfd = STDERR_FILENO;
Peter Maydell6ee18642019-09-16 15:15:44 +0100407 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700408 ret = alloc_guestfd();
409 associate_guestfd(ret, hostfd);
410 } else if (strcmp(s, ":semihosting-features") == 0) {
Peter Maydellc46a6532019-09-16 15:15:42 +0100411 /* We must fail opens for modes other than 0 ('r') or 1 ('rb') */
412 if (arg1 != 0 && arg1 != 1) {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700413 ret = -1;
414 err = EACCES;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100415 } else {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700416 ret = alloc_guestfd();
417 staticfile_guestfd(ret, featurefile_data,
418 sizeof(featurefile_data));
419 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700420 } else {
Richard Henderson5b3f39c2022-04-28 01:44:28 -0700421 unlock_user(s, arg0, 0);
422 semihost_sys_open(cs, common_semi_cb, arg0, arg2 + 1,
423 gdb_open_modeflags[arg1], 0644);
424 break;
pbrooka2d1eba2007-01-28 03:10:55 +0000425 }
Peter Maydellf296c0d2012-10-14 09:52:27 +0000426 unlock_user(s, arg0, 0);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700427 common_semi_cb(cs, ret, err);
428 break;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100429 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700430
Stefan Weil38817252012-04-28 05:07:47 +0000431 case TARGET_SYS_CLOSE:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000432 GET_ARG(0);
Richard Henderson5eadbbf2022-04-28 09:22:18 -0700433 semihost_sys_close(cs, common_semi_cb, arg0);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700434 break;
435
Stefan Weil38817252012-04-28 05:07:47 +0000436 case TARGET_SYS_WRITEC:
Richard Henderson5d772892022-05-01 17:55:20 -0700437 /*
438 * FIXME: the byte to be written is in a target_ulong slot,
439 * which means this is wrong for a big-endian guest.
440 */
441 semihost_sys_write_gf(cs, common_semi_dead_cb,
442 &console_out_gf, args, 1);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700443 break;
444
Stefan Weil38817252012-04-28 05:07:47 +0000445 case TARGET_SYS_WRITE0:
Richard Henderson72815502022-05-01 18:02:53 -0700446 {
447 ssize_t len = target_strlen(args);
448 if (len < 0) {
449 common_semi_dead_cb(cs, -1, EFAULT);
450 } else {
451 semihost_sys_write_gf(cs, common_semi_dead_cb,
452 &console_out_gf, args, len);
453 }
454 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700455 break;
456
Stefan Weil38817252012-04-28 05:07:47 +0000457 case TARGET_SYS_WRITE:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000458 GET_ARG(0);
459 GET_ARG(1);
460 GET_ARG(2);
Richard Hendersonaa915bd2022-04-28 11:49:47 -0700461 semihost_sys_write(cs, common_semi_rw_cb, arg0, arg1, arg2);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700462 break;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100463
Stefan Weil38817252012-04-28 05:07:47 +0000464 case TARGET_SYS_READ:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000465 GET_ARG(0);
466 GET_ARG(1);
467 GET_ARG(2);
Richard Hendersonaf0484b2022-04-28 11:40:41 -0700468 semihost_sys_read(cs, common_semi_rw_cb, arg0, arg1, arg2);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700469 break;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100470
Stefan Weil38817252012-04-28 05:07:47 +0000471 case TARGET_SYS_READC:
Richard Henderson1577eec2022-05-01 17:42:43 -0700472 semihost_sys_read_gf(cs, common_semi_readc_cb, &console_in_gf,
473 common_semi_stack_bottom(cs) - 1, 1);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700474 break;
475
Keith Packard767ba042021-01-08 22:42:56 +0000476 case TARGET_SYS_ISERROR:
477 GET_ARG(0);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700478 common_semi_set_ret(cs, (target_long)arg0 < 0);
479 break;
480
Stefan Weil38817252012-04-28 05:07:47 +0000481 case TARGET_SYS_ISTTY:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000482 GET_ARG(0);
Richard Hendersona2212472022-04-28 12:31:25 -0700483 semihost_sys_isatty(cs, common_semi_istty_cb, arg0);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700484 break;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100485
Stefan Weil38817252012-04-28 05:07:47 +0000486 case TARGET_SYS_SEEK:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000487 GET_ARG(0);
488 GET_ARG(1);
Richard Henderson9a894702022-04-28 12:04:44 -0700489 semihost_sys_lseek(cs, common_semi_seek_cb, arg0, arg1, GDB_SEEK_SET);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700490 break;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100491
Stefan Weil38817252012-04-28 05:07:47 +0000492 case TARGET_SYS_FLEN:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000493 GET_ARG(0);
Richard Hendersona6300ed2022-04-29 09:05:36 -0700494 semihost_sys_flen(cs, common_semi_flen_fstat_cb, common_semi_cb,
495 arg0, common_semi_flen_buf(cs));
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700496 break;
Peter Maydell35e9a0a2019-09-16 15:15:33 +0100497
Stefan Weil38817252012-04-28 05:07:47 +0000498 case TARGET_SYS_TMPNAM:
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700499 {
500 int len;
501 char *p;
502
Keith Packard27e3b102021-01-08 22:42:55 +0000503 GET_ARG(0);
504 GET_ARG(1);
505 GET_ARG(2);
Bin Meng3878d0c2022-10-27 19:36:16 +0100506 len = asprintf(&s, "%s/qemu-%x%02x", g_get_tmp_dir(),
507 getpid(), (int)arg1 & 0xff);
Peter Maydell9b1268f2022-07-25 15:05:16 +0100508 if (len < 0) {
509 common_semi_set_ret(cs, -1);
510 break;
511 }
512
513 /* Allow for trailing NUL */
514 len++;
Keith Packard27e3b102021-01-08 22:42:55 +0000515 /* Make sure there's enough space in the buffer */
Peter Maydell9b1268f2022-07-25 15:05:16 +0100516 if (len > arg2) {
517 free(s);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700518 common_semi_set_ret(cs, -1);
519 break;
Keith Packard27e3b102021-01-08 22:42:55 +0000520 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700521 p = lock_user(VERIFY_WRITE, arg0, len, 0);
522 if (!p) {
Peter Maydell9b1268f2022-07-25 15:05:16 +0100523 free(s);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700524 goto do_fault;
525 }
Peter Maydell9b1268f2022-07-25 15:05:16 +0100526 memcpy(p, s, len);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700527 unlock_user(p, arg0, len);
Keith Packard27e3b102021-01-08 22:42:55 +0000528 free(s);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700529 common_semi_set_ret(cs, 0);
530 break;
531 }
532
Stefan Weil38817252012-04-28 05:07:47 +0000533 case TARGET_SYS_REMOVE:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000534 GET_ARG(0);
535 GET_ARG(1);
Richard Hendersond49e79b2022-04-29 09:29:27 -0700536 semihost_sys_remove(cs, common_semi_cb, arg0, arg1 + 1);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700537 break;
538
Stefan Weil38817252012-04-28 05:07:47 +0000539 case TARGET_SYS_RENAME:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000540 GET_ARG(0);
541 GET_ARG(1);
542 GET_ARG(2);
543 GET_ARG(3);
Richard Henderson25a95da2022-04-29 10:11:31 -0700544 semihost_sys_rename(cs, common_semi_cb, arg0, arg1 + 1, arg2, arg3 + 1);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700545 break;
546
Stefan Weil38817252012-04-28 05:07:47 +0000547 case TARGET_SYS_CLOCK:
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700548 common_semi_set_ret(cs, clock() / (CLOCKS_PER_SEC / 100));
549 break;
550
Stefan Weil38817252012-04-28 05:07:47 +0000551 case TARGET_SYS_TIME:
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700552 ul_ret = time(NULL);
553 common_semi_cb(cs, ul_ret, ul_ret == -1 ? errno : 0);
554 break;
555
Stefan Weil38817252012-04-28 05:07:47 +0000556 case TARGET_SYS_SYSTEM:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000557 GET_ARG(0);
558 GET_ARG(1);
Richard Henderson90d8e0b2022-04-29 13:57:19 -0700559 semihost_sys_system(cs, common_semi_cb, arg0, arg1 + 1);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700560 break;
561
Stefan Weil38817252012-04-28 05:07:47 +0000562 case TARGET_SYS_ERRNO:
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700563 common_semi_set_ret(cs, get_swi_errno(cs));
564 break;
565
Stefan Weil38817252012-04-28 05:07:47 +0000566 case TARGET_SYS_GET_CMDLINE:
pbrook38d06622006-11-19 20:29:35 +0000567 {
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200568 /* Build a command-line from the original argv.
569 *
570 * The inputs are:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000571 * * arg0, pointer to a buffer of at least the size
572 * specified in arg1.
573 * * arg1, size of the buffer pointed to by arg0 in
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200574 * bytes.
575 *
576 * The outputs are:
Peter Maydellf296c0d2012-10-14 09:52:27 +0000577 * * arg0, pointer to null-terminated string of the
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200578 * command line.
Peter Maydellf296c0d2012-10-14 09:52:27 +0000579 * * arg1, length of the string pointed to by arg0.
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200580 */
bellard579a97f2007-11-11 14:26:47 +0000581
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200582 char *output_buffer;
Peter Maydellf296c0d2012-10-14 09:52:27 +0000583 size_t input_size;
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200584 size_t output_size;
585 int status = 0;
Liviu Ionescuf3c2bda2015-06-26 14:22:36 +0100586#if !defined(CONFIG_USER_ONLY)
587 const char *cmdline;
Peter Maydell6ed68452019-09-16 15:15:34 +0100588#else
Ilya Leoshkeviche4e5cb42024-03-05 12:09:39 +0000589 TaskState *ts = get_task_state(cs);
Liviu Ionescuf3c2bda2015-06-26 14:22:36 +0100590#endif
Peter Maydellf296c0d2012-10-14 09:52:27 +0000591 GET_ARG(0);
592 GET_ARG(1);
593 input_size = arg1;
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200594 /* Compute the size of the output string. */
595#if !defined(CONFIG_USER_ONLY)
Liviu Ionescuf3c2bda2015-06-26 14:22:36 +0100596 cmdline = semihosting_get_cmdline();
597 if (cmdline == NULL) {
598 cmdline = ""; /* Default to an empty line. */
599 }
600 output_size = strlen(cmdline) + 1; /* Count terminating 0. */
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200601#else
Wolfgang Schildbach2e8785a2010-12-06 15:06:05 +0000602 unsigned int i;
pbrook38d06622006-11-19 20:29:35 +0000603
Richard Henderson60f1c802022-04-26 19:51:29 -0700604 output_size = ts->info->env_strings - ts->info->arg_strings;
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200605 if (!output_size) {
Alex Bennée4cb28db2019-05-14 12:08:39 +0100606 /*
607 * We special-case the "empty command line" case (argc==0).
608 * Just provide the terminating 0.
609 */
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200610 output_size = 1;
Wolfgang Schildbach2e8785a2010-12-06 15:06:05 +0000611 }
pbrook8e716212007-01-20 17:12:09 +0000612#endif
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200613
614 if (output_size > input_size) {
Alex Bennée4cb28db2019-05-14 12:08:39 +0100615 /* Not enough space to store command-line arguments. */
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700616 common_semi_cb(cs, -1, E2BIG);
617 break;
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200618 }
619
620 /* Adjust the command-line length. */
Peter Maydellf296c0d2012-10-14 09:52:27 +0000621 if (SET_ARG(1, output_size - 1)) {
622 /* Couldn't write back to argument block */
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700623 goto do_fault;
Peter Maydellf296c0d2012-10-14 09:52:27 +0000624 }
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200625
626 /* Lock the buffer on the ARM side. */
Peter Maydellf296c0d2012-10-14 09:52:27 +0000627 output_buffer = lock_user(VERIFY_WRITE, arg0, output_size, 0);
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200628 if (!output_buffer) {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700629 goto do_fault;
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200630 }
631
632 /* Copy the command-line arguments. */
633#if !defined(CONFIG_USER_ONLY)
Liviu Ionescuf3c2bda2015-06-26 14:22:36 +0100634 pstrcpy(output_buffer, output_size, cmdline);
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200635#else
636 if (output_size == 1) {
637 /* Empty command-line. */
638 output_buffer[0] = '\0';
639 goto out;
640 }
641
Richard Henderson60f1c802022-04-26 19:51:29 -0700642 if (copy_from_user(output_buffer, ts->info->arg_strings,
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200643 output_size)) {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700644 unlock_user(output_buffer, arg0, 0);
645 goto do_fault;
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200646 }
647
648 /* Separate arguments by white spaces. */
649 for (i = 0; i < output_size - 1; i++) {
650 if (output_buffer[i] == 0) {
651 output_buffer[i] = ' ';
652 }
653 }
654 out:
655#endif
656 /* Unlock the buffer on the ARM side. */
Peter Maydellf296c0d2012-10-14 09:52:27 +0000657 unlock_user(output_buffer, arg0, output_size);
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700658 common_semi_cb(cs, status, 0);
Cédric VINCENT1c1b40c2011-06-29 12:49:41 +0200659 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700660 break;
661
Stefan Weil38817252012-04-28 05:07:47 +0000662 case TARGET_SYS_HEAPINFO:
bellarda4f81972005-04-23 18:25:41 +0000663 {
Peter Maydellf5666412016-07-04 13:06:35 +0100664 target_ulong retvals[4];
Peter Maydellf5666412016-07-04 13:06:35 +0100665 int i;
Peter Maydell6ed68452019-09-16 15:15:34 +0100666#ifdef CONFIG_USER_ONLY
Ilya Leoshkeviche4e5cb42024-03-05 12:09:39 +0000667 TaskState *ts = get_task_state(cs);
Alex Bennée5fc983a2022-02-25 17:20:20 +0000668 target_ulong limit;
Peter Maydell69515952020-11-19 09:23:46 +0000669#else
Alex Bennée5fc983a2022-02-25 17:20:20 +0000670 LayoutInfo info = common_semi_find_bases(cs);
Peter Maydell6ed68452019-09-16 15:15:34 +0100671#endif
Peter Maydellf5666412016-07-04 13:06:35 +0100672
Peter Maydellf296c0d2012-10-14 09:52:27 +0000673 GET_ARG(0);
bellarda4f81972005-04-23 18:25:41 +0000674
pbrook8e716212007-01-20 17:12:09 +0000675#ifdef CONFIG_USER_ONLY
Alex Bennée4cb28db2019-05-14 12:08:39 +0100676 /*
677 * Some C libraries assume the heap immediately follows .bss, so
678 * allocate it using sbrk.
679 */
bellarda4f81972005-04-23 18:25:41 +0000680 if (!ts->heap_limit) {
Peter Maydell206ae742011-04-18 16:34:25 +0100681 abi_ulong ret;
bellarda4f81972005-04-23 18:25:41 +0000682
pbrook53a59602006-03-25 19:31:22 +0000683 ts->heap_base = do_brk(0);
Keith Packard3c37cfe2021-01-08 22:42:50 +0000684 limit = ts->heap_base + COMMON_SEMI_HEAP_SIZE;
bellarda4f81972005-04-23 18:25:41 +0000685 /* Try a big heap, and reduce the size if that fails. */
686 for (;;) {
pbrook53a59602006-03-25 19:31:22 +0000687 ret = do_brk(limit);
Peter Maydell206ae742011-04-18 16:34:25 +0100688 if (ret >= limit) {
bellarda4f81972005-04-23 18:25:41 +0000689 break;
Peter Maydell206ae742011-04-18 16:34:25 +0100690 }
bellarda4f81972005-04-23 18:25:41 +0000691 limit = (ts->heap_base >> 1) + (limit >> 1);
692 }
693 ts->heap_limit = limit;
694 }
ths3b46e622007-09-17 08:09:54 +0000695
Peter Maydellf5666412016-07-04 13:06:35 +0100696 retvals[0] = ts->heap_base;
697 retvals[1] = ts->heap_limit;
698 retvals[2] = ts->stack_base;
699 retvals[3] = 0; /* Stack limit. */
pbrook8e716212007-01-20 17:12:09 +0000700#else
Alex Bennée5fc983a2022-02-25 17:20:20 +0000701 retvals[0] = info.heapbase; /* Heap Base */
702 retvals[1] = info.heaplimit; /* Heap Limit */
703 retvals[2] = info.heaplimit; /* Stack base */
704 retvals[3] = info.heapbase; /* Stack limit. */
pbrook8e716212007-01-20 17:12:09 +0000705#endif
Peter Maydellf5666412016-07-04 13:06:35 +0100706
707 for (i = 0; i < ARRAY_SIZE(retvals); i++) {
708 bool fail;
709
Alex Bennée35e3f022021-03-23 16:52:53 +0000710 if (is_64bit_semihosting(env)) {
711 fail = put_user_u64(retvals[i], arg0 + i * 8);
712 } else {
713 fail = put_user_u32(retvals[i], arg0 + i * 4);
714 }
Peter Maydellf5666412016-07-04 13:06:35 +0100715
716 if (fail) {
717 /* Couldn't write back to argument block */
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700718 goto do_fault;
Peter Maydellf5666412016-07-04 13:06:35 +0100719 }
720 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700721 common_semi_set_ret(cs, 0);
bellarda4f81972005-04-23 18:25:41 +0000722 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700723 break;
724
Stefan Weil38817252012-04-28 05:07:47 +0000725 case TARGET_SYS_EXIT:
Peter Maydell22a43bb2019-09-16 15:15:43 +0100726 case TARGET_SYS_EXIT_EXTENDED:
Philippe Mathieu-Daudéa60e5732023-10-04 14:00:16 +0200727 {
728 uint32_t ret;
729
Keith Packard3c37cfe2021-01-08 22:42:50 +0000730 if (common_semi_sys_exit_extended(cs, nr)) {
Alex Bennée4cb28db2019-05-14 12:08:39 +0100731 /*
Peter Maydell22a43bb2019-09-16 15:15:43 +0100732 * The A64 version of SYS_EXIT takes a parameter block,
Peter Maydell7446d352015-09-07 10:39:28 +0100733 * so the application-exit type can return a subcode which
734 * is the exit status code from the application.
Peter Maydell22a43bb2019-09-16 15:15:43 +0100735 * SYS_EXIT_EXTENDED is an a new-in-v2.0 optional function
736 * which allows A32/T32 guests to also provide a status code.
Peter Maydell7446d352015-09-07 10:39:28 +0100737 */
738 GET_ARG(0);
739 GET_ARG(1);
740
741 if (arg0 == ADP_Stopped_ApplicationExit) {
742 ret = arg1;
743 } else {
744 ret = 1;
745 }
746 } else {
Alex Bennée4cb28db2019-05-14 12:08:39 +0100747 /*
Peter Maydell22a43bb2019-09-16 15:15:43 +0100748 * The A32/T32 version of SYS_EXIT specifies only
749 * Stopped_ApplicationExit as normal exit, but does not
750 * allow the guest to specify the exit status code.
751 * Everything else is considered an error.
Alex Bennée4cb28db2019-05-14 12:08:39 +0100752 */
Peter Maydell7446d352015-09-07 10:39:28 +0100753 ret = (args == ADP_Stopped_ApplicationExit) ? 0 : 1;
754 }
Alex Bennéead9dcb22021-01-08 22:42:43 +0000755 gdb_exit(ret);
Liviu Ionescu1ecc3a22014-12-11 12:07:48 +0000756 exit(ret);
Philippe Mathieu-Daudéa60e5732023-10-04 14:00:16 +0200757 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700758
Keith Packard4d834032021-01-08 22:42:54 +0000759 case TARGET_SYS_ELAPSED:
760 elapsed = get_clock() - clock_start;
761 if (sizeof(target_ulong) == 8) {
Peter Maydellfed49cd2022-07-25 15:05:15 +0100762 if (SET_ARG(0, elapsed)) {
763 goto do_fault;
764 }
Keith Packard4d834032021-01-08 22:42:54 +0000765 } else {
Peter Maydellfed49cd2022-07-25 15:05:15 +0100766 if (SET_ARG(0, (uint32_t) elapsed) ||
767 SET_ARG(1, (uint32_t) (elapsed >> 32))) {
768 goto do_fault;
769 }
Keith Packard4d834032021-01-08 22:42:54 +0000770 }
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700771 common_semi_set_ret(cs, 0);
772 break;
773
Keith Packard4d834032021-01-08 22:42:54 +0000774 case TARGET_SYS_TICKFREQ:
775 /* qemu always uses nsec */
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700776 common_semi_set_ret(cs, 1000000000);
777 break;
778
Peter Maydelle9ebfbf2015-09-07 10:39:28 +0100779 case TARGET_SYS_SYNCCACHE:
Alex Bennée4cb28db2019-05-14 12:08:39 +0100780 /*
781 * Clean the D-cache and invalidate the I-cache for the specified
Peter Maydelle9ebfbf2015-09-07 10:39:28 +0100782 * virtual address range. This is a nop for us since we don't
783 * implement caches. This is only present on A64.
784 */
Richard Hendersona1df4ba2022-04-29 14:16:01 -0700785 if (common_semi_has_synccache(env)) {
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700786 common_semi_set_ret(cs, 0);
787 break;
Peter Maydelle9ebfbf2015-09-07 10:39:28 +0100788 }
Richard Hendersona1df4ba2022-04-29 14:16:01 -0700789 /* fall through */
bellarda4f81972005-04-23 18:25:41 +0000790 default:
791 fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
Markus Armbruster90c84c52019-04-17 21:18:02 +0200792 cpu_dump_state(cs, stderr, 0);
bellarda4f81972005-04-23 18:25:41 +0000793 abort();
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700794
Richard Hendersoned3a06b2022-04-28 01:10:55 -0700795 do_fault:
796 common_semi_cb(cs, -1, EFAULT);
797 break;
bellarda4f81972005-04-23 18:25:41 +0000798 }
799}