2 * Nios II Semihosting syscall interface.
3 * This code is derived from m68k-semi.c.
4 * The semihosting protocol implemented here is described in the
6 * https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;a=blob;f=libgloss/nios2/nios2-semi.txt;hb=HEAD
8 * Copyright (c) 2017-2019 Mentor Graphics
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 #include "qemu/osdep.h"
27 #if defined(CONFIG_USER_ONLY)
30 #include "qemu-common.h"
31 #include "exec/gdbstub.h"
32 #include "exec/softmmu-semi.h"
35 #include "sysemu/sysemu.h"
38 #define HOSTED_INIT_SIM 1
40 #define HOSTED_CLOSE 3
42 #define HOSTED_WRITE 5
43 #define HOSTED_LSEEK 6
44 #define HOSTED_RENAME 7
45 #define HOSTED_UNLINK 8
47 #define HOSTED_FSTAT 10
48 #define HOSTED_GETTIMEOFDAY 11
49 #define HOSTED_ISATTY 12
50 #define HOSTED_SYSTEM 13
52 typedef uint32_t gdb_mode_t
;
53 typedef uint32_t gdb_time_t
;
55 struct nios2_gdb_stat
{
56 uint32_t gdb_st_dev
; /* device */
57 uint32_t gdb_st_ino
; /* inode */
58 gdb_mode_t gdb_st_mode
; /* protection */
59 uint32_t gdb_st_nlink
; /* number of hard links */
60 uint32_t gdb_st_uid
; /* user ID of owner */
61 uint32_t gdb_st_gid
; /* group ID of owner */
62 uint32_t gdb_st_rdev
; /* device type (if inode device) */
63 uint64_t gdb_st_size
; /* total size, in bytes */
64 uint64_t gdb_st_blksize
; /* blocksize for filesystem I/O */
65 uint64_t gdb_st_blocks
; /* number of blocks allocated */
66 gdb_time_t gdb_st_atime
; /* time of last access */
67 gdb_time_t gdb_st_mtime
; /* time of last modification */
68 gdb_time_t gdb_st_ctime
; /* time of last change */
72 gdb_time_t tv_sec
; /* second */
73 uint64_t tv_usec
; /* microsecond */
76 #define GDB_O_RDONLY 0x0
77 #define GDB_O_WRONLY 0x1
78 #define GDB_O_RDWR 0x2
79 #define GDB_O_APPEND 0x8
80 #define GDB_O_CREAT 0x200
81 #define GDB_O_TRUNC 0x400
82 #define GDB_O_EXCL 0x800
84 static int translate_openflags(int flags
)
88 if (flags
& GDB_O_WRONLY
) {
90 } else if (flags
& GDB_O_RDWR
) {
96 if (flags
& GDB_O_APPEND
) {
99 if (flags
& GDB_O_CREAT
) {
102 if (flags
& GDB_O_TRUNC
) {
105 if (flags
& GDB_O_EXCL
) {
112 static bool translate_stat(CPUNios2State
*env
, target_ulong addr
,
115 struct nios2_gdb_stat
*p
;
117 p
= lock_user(VERIFY_WRITE
, addr
, sizeof(struct nios2_gdb_stat
), 0);
122 p
->gdb_st_dev
= cpu_to_be32(s
->st_dev
);
123 p
->gdb_st_ino
= cpu_to_be32(s
->st_ino
);
124 p
->gdb_st_mode
= cpu_to_be32(s
->st_mode
);
125 p
->gdb_st_nlink
= cpu_to_be32(s
->st_nlink
);
126 p
->gdb_st_uid
= cpu_to_be32(s
->st_uid
);
127 p
->gdb_st_gid
= cpu_to_be32(s
->st_gid
);
128 p
->gdb_st_rdev
= cpu_to_be32(s
->st_rdev
);
129 p
->gdb_st_size
= cpu_to_be64(s
->st_size
);
131 /* Windows stat is missing some fields. */
132 p
->gdb_st_blksize
= 0;
133 p
->gdb_st_blocks
= 0;
135 p
->gdb_st_blksize
= cpu_to_be64(s
->st_blksize
);
136 p
->gdb_st_blocks
= cpu_to_be64(s
->st_blocks
);
138 p
->gdb_st_atime
= cpu_to_be32(s
->st_atime
);
139 p
->gdb_st_mtime
= cpu_to_be32(s
->st_mtime
);
140 p
->gdb_st_ctime
= cpu_to_be32(s
->st_ctime
);
141 unlock_user(p
, addr
, sizeof(struct nios2_gdb_stat
));
145 static void nios2_semi_return_u32(CPUNios2State
*env
, uint32_t ret
,
148 target_ulong args
= env
->regs
[R_ARG1
];
149 if (put_user_u32(ret
, args
) ||
150 put_user_u32(err
, args
+ 4)) {
152 * The nios2 semihosting ABI does not provide any way to report this
153 * error to the guest, so the best we can do is log it in qemu.
154 * It is always a guest error not to pass us a valid argument block.
156 qemu_log_mask(LOG_GUEST_ERROR
, "nios2-semihosting: return value "
157 "discarded because argument block not writable\n");
161 static void nios2_semi_return_u64(CPUNios2State
*env
, uint64_t ret
,
164 target_ulong args
= env
->regs
[R_ARG1
];
165 if (put_user_u32(ret
>> 32, args
) ||
166 put_user_u32(ret
, args
+ 4) ||
167 put_user_u32(err
, args
+ 8)) {
168 /* No way to report this via nios2 semihosting ABI; just log it */
169 qemu_log_mask(LOG_GUEST_ERROR
, "nios2-semihosting: return value "
170 "discarded because argument block not writable\n");
174 static int nios2_semi_is_lseek
;
176 static void nios2_semi_cb(CPUState
*cs
, target_ulong ret
, target_ulong err
)
178 Nios2CPU
*cpu
= NIOS2_CPU(cs
);
179 CPUNios2State
*env
= &cpu
->env
;
181 if (nios2_semi_is_lseek
) {
183 * FIXME: We've already lost the high bits of the lseek
186 nios2_semi_return_u64(env
, ret
, err
);
187 nios2_semi_is_lseek
= 0;
189 nios2_semi_return_u32(env
, ret
, err
);
194 * Read the input value from the argument block; fail the semihosting
195 * call if the memory read fails.
197 #define GET_ARG(n) do { \
198 if (get_user_ual(arg ## n, args + (n) * 4)) { \
205 void do_nios2_semihosting(CPUNios2State
*env
)
209 target_ulong arg0
, arg1
, arg2
, arg3
;
215 nr
= env
->regs
[R_ARG0
];
216 args
= env
->regs
[R_ARG1
];
219 gdb_exit(env
, env
->regs
[R_ARG0
]);
220 exit(env
->regs
[R_ARG0
]);
226 if (use_gdb_syscalls()) {
227 gdb_do_syscall(nios2_semi_cb
, "open,%s,%x,%x", arg0
, (int)arg1
,
231 p
= lock_user_string(arg0
);
236 result
= open(p
, translate_openflags(arg2
), arg3
);
237 unlock_user(p
, arg0
, 0);
243 /* Ignore attempts to close stdin/out/err. */
247 if (use_gdb_syscalls()) {
248 gdb_do_syscall(nios2_semi_cb
, "close,%x", arg0
);
263 if (use_gdb_syscalls()) {
264 gdb_do_syscall(nios2_semi_cb
, "read,%x,%x,%x",
268 p
= lock_user(VERIFY_WRITE
, arg1
, len
, 0);
273 result
= read(arg0
, p
, len
);
274 unlock_user(p
, arg1
, len
);
283 if (use_gdb_syscalls()) {
284 gdb_do_syscall(nios2_semi_cb
, "write,%x,%x,%x",
288 p
= lock_user(VERIFY_READ
, arg1
, len
, 1);
293 result
= write(arg0
, p
, len
);
294 unlock_user(p
, arg0
, 0);
305 off
= (uint32_t)arg2
| ((uint64_t)arg1
<< 32);
306 if (use_gdb_syscalls()) {
307 nios2_semi_is_lseek
= 1;
308 gdb_do_syscall(nios2_semi_cb
, "lseek,%x,%lx,%x",
311 off
= lseek(arg0
, off
, arg3
);
312 nios2_semi_return_u64(env
, off
, errno
);
321 if (use_gdb_syscalls()) {
322 gdb_do_syscall(nios2_semi_cb
, "rename,%s,%s",
323 arg0
, (int)arg1
, arg2
, (int)arg3
);
326 p
= lock_user_string(arg0
);
327 q
= lock_user_string(arg2
);
332 result
= rename(p
, q
);
334 unlock_user(p
, arg0
, 0);
335 unlock_user(q
, arg2
, 0);
341 if (use_gdb_syscalls()) {
342 gdb_do_syscall(nios2_semi_cb
, "unlink,%s",
346 p
= lock_user_string(arg0
);
352 unlock_user(p
, arg0
, 0);
360 if (use_gdb_syscalls()) {
361 gdb_do_syscall(nios2_semi_cb
, "stat,%s,%x",
362 arg0
, (int)arg1
, arg2
);
366 p
= lock_user_string(arg0
);
371 result
= stat(p
, &s
);
372 unlock_user(p
, arg0
, 0);
374 if (result
== 0 && !translate_stat(env
, arg2
, &s
)) {
383 if (use_gdb_syscalls()) {
384 gdb_do_syscall(nios2_semi_cb
, "fstat,%x,%x",
389 result
= fstat(arg0
, &s
);
390 if (result
== 0 && !translate_stat(env
, arg1
, &s
)) {
396 case HOSTED_GETTIMEOFDAY
:
397 /* Only the tv parameter is used. tz is assumed NULL. */
399 if (use_gdb_syscalls()) {
400 gdb_do_syscall(nios2_semi_cb
, "gettimeofday,%x,%x",
405 struct gdb_timeval
*p
;
406 result
= qemu_gettimeofday(&tv
);
408 p
= lock_user(VERIFY_WRITE
, arg0
, sizeof(struct gdb_timeval
),
414 p
->tv_sec
= cpu_to_be32(tv
.tv_sec
);
415 p
->tv_usec
= cpu_to_be64(tv
.tv_usec
);
416 unlock_user(p
, arg0
, sizeof(struct gdb_timeval
));
423 if (use_gdb_syscalls()) {
424 gdb_do_syscall(nios2_semi_cb
, "isatty,%x", arg0
);
427 result
= isatty(arg0
);
433 if (use_gdb_syscalls()) {
434 gdb_do_syscall(nios2_semi_cb
, "system,%s",
438 p
= lock_user_string(arg0
);
444 unlock_user(p
, arg0
, 0);
449 qemu_log_mask(LOG_GUEST_ERROR
, "nios2-semihosting: unsupported "
450 "semihosting syscall %d\n", nr
);
454 nios2_semi_return_u32(env
, result
, errno
);