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 #include "exec/gdbstub.h"
28 #if defined(CONFIG_USER_ONLY)
31 #include "exec/softmmu-semi.h"
36 #define HOSTED_INIT_SIM 1
38 #define HOSTED_CLOSE 3
40 #define HOSTED_WRITE 5
41 #define HOSTED_LSEEK 6
42 #define HOSTED_RENAME 7
43 #define HOSTED_UNLINK 8
45 #define HOSTED_FSTAT 10
46 #define HOSTED_GETTIMEOFDAY 11
47 #define HOSTED_ISATTY 12
48 #define HOSTED_SYSTEM 13
50 typedef uint32_t gdb_mode_t
;
51 typedef uint32_t gdb_time_t
;
53 struct nios2_gdb_stat
{
54 uint32_t gdb_st_dev
; /* device */
55 uint32_t gdb_st_ino
; /* inode */
56 gdb_mode_t gdb_st_mode
; /* protection */
57 uint32_t gdb_st_nlink
; /* number of hard links */
58 uint32_t gdb_st_uid
; /* user ID of owner */
59 uint32_t gdb_st_gid
; /* group ID of owner */
60 uint32_t gdb_st_rdev
; /* device type (if inode device) */
61 uint64_t gdb_st_size
; /* total size, in bytes */
62 uint64_t gdb_st_blksize
; /* blocksize for filesystem I/O */
63 uint64_t gdb_st_blocks
; /* number of blocks allocated */
64 gdb_time_t gdb_st_atime
; /* time of last access */
65 gdb_time_t gdb_st_mtime
; /* time of last modification */
66 gdb_time_t gdb_st_ctime
; /* time of last change */
70 gdb_time_t tv_sec
; /* second */
71 uint64_t tv_usec
; /* microsecond */
74 #define GDB_O_RDONLY 0x0
75 #define GDB_O_WRONLY 0x1
76 #define GDB_O_RDWR 0x2
77 #define GDB_O_APPEND 0x8
78 #define GDB_O_CREAT 0x200
79 #define GDB_O_TRUNC 0x400
80 #define GDB_O_EXCL 0x800
82 static int translate_openflags(int flags
)
86 if (flags
& GDB_O_WRONLY
) {
88 } else if (flags
& GDB_O_RDWR
) {
94 if (flags
& GDB_O_APPEND
) {
97 if (flags
& GDB_O_CREAT
) {
100 if (flags
& GDB_O_TRUNC
) {
103 if (flags
& GDB_O_EXCL
) {
110 static bool translate_stat(CPUNios2State
*env
, target_ulong addr
,
113 struct nios2_gdb_stat
*p
;
115 p
= lock_user(VERIFY_WRITE
, addr
, sizeof(struct nios2_gdb_stat
), 0);
120 p
->gdb_st_dev
= cpu_to_be32(s
->st_dev
);
121 p
->gdb_st_ino
= cpu_to_be32(s
->st_ino
);
122 p
->gdb_st_mode
= cpu_to_be32(s
->st_mode
);
123 p
->gdb_st_nlink
= cpu_to_be32(s
->st_nlink
);
124 p
->gdb_st_uid
= cpu_to_be32(s
->st_uid
);
125 p
->gdb_st_gid
= cpu_to_be32(s
->st_gid
);
126 p
->gdb_st_rdev
= cpu_to_be32(s
->st_rdev
);
127 p
->gdb_st_size
= cpu_to_be64(s
->st_size
);
129 /* Windows stat is missing some fields. */
130 p
->gdb_st_blksize
= 0;
131 p
->gdb_st_blocks
= 0;
133 p
->gdb_st_blksize
= cpu_to_be64(s
->st_blksize
);
134 p
->gdb_st_blocks
= cpu_to_be64(s
->st_blocks
);
136 p
->gdb_st_atime
= cpu_to_be32(s
->st_atime
);
137 p
->gdb_st_mtime
= cpu_to_be32(s
->st_mtime
);
138 p
->gdb_st_ctime
= cpu_to_be32(s
->st_ctime
);
139 unlock_user(p
, addr
, sizeof(struct nios2_gdb_stat
));
143 static void nios2_semi_return_u32(CPUNios2State
*env
, uint32_t ret
,
146 target_ulong args
= env
->regs
[R_ARG1
];
147 if (put_user_u32(ret
, args
) ||
148 put_user_u32(err
, args
+ 4)) {
150 * The nios2 semihosting ABI does not provide any way to report this
151 * error to the guest, so the best we can do is log it in qemu.
152 * It is always a guest error not to pass us a valid argument block.
154 qemu_log_mask(LOG_GUEST_ERROR
, "nios2-semihosting: return value "
155 "discarded because argument block not writable\n");
159 static void nios2_semi_return_u64(CPUNios2State
*env
, uint64_t ret
,
162 target_ulong args
= env
->regs
[R_ARG1
];
163 if (put_user_u32(ret
>> 32, args
) ||
164 put_user_u32(ret
, args
+ 4) ||
165 put_user_u32(err
, args
+ 8)) {
166 /* No way to report this via nios2 semihosting ABI; just log it */
167 qemu_log_mask(LOG_GUEST_ERROR
, "nios2-semihosting: return value "
168 "discarded because argument block not writable\n");
172 static int nios2_semi_is_lseek
;
174 static void nios2_semi_cb(CPUState
*cs
, target_ulong ret
, target_ulong err
)
176 Nios2CPU
*cpu
= NIOS2_CPU(cs
);
177 CPUNios2State
*env
= &cpu
->env
;
179 if (nios2_semi_is_lseek
) {
181 * FIXME: We've already lost the high bits of the lseek
184 nios2_semi_return_u64(env
, ret
, err
);
185 nios2_semi_is_lseek
= 0;
187 nios2_semi_return_u32(env
, ret
, err
);
192 * Read the input value from the argument block; fail the semihosting
193 * call if the memory read fails.
195 #define GET_ARG(n) do { \
196 if (get_user_ual(arg ## n, args + (n) * 4)) { \
203 void do_nios2_semihosting(CPUNios2State
*env
)
207 target_ulong arg0
, arg1
, arg2
, arg3
;
213 nr
= env
->regs
[R_ARG0
];
214 args
= env
->regs
[R_ARG1
];
217 gdb_exit(env
->regs
[R_ARG0
]);
218 exit(env
->regs
[R_ARG0
]);
224 if (use_gdb_syscalls()) {
225 gdb_do_syscall(nios2_semi_cb
, "open,%s,%x,%x", arg0
, (int)arg1
,
229 p
= lock_user_string(arg0
);
234 result
= open(p
, translate_openflags(arg2
), arg3
);
235 unlock_user(p
, arg0
, 0);
241 /* Ignore attempts to close stdin/out/err. */
245 if (use_gdb_syscalls()) {
246 gdb_do_syscall(nios2_semi_cb
, "close,%x", arg0
);
261 if (use_gdb_syscalls()) {
262 gdb_do_syscall(nios2_semi_cb
, "read,%x,%x,%x",
266 p
= lock_user(VERIFY_WRITE
, arg1
, len
, 0);
271 result
= read(arg0
, p
, len
);
272 unlock_user(p
, arg1
, len
);
281 if (use_gdb_syscalls()) {
282 gdb_do_syscall(nios2_semi_cb
, "write,%x,%x,%x",
286 p
= lock_user(VERIFY_READ
, arg1
, len
, 1);
291 result
= write(arg0
, p
, len
);
292 unlock_user(p
, arg0
, 0);
303 off
= (uint32_t)arg2
| ((uint64_t)arg1
<< 32);
304 if (use_gdb_syscalls()) {
305 nios2_semi_is_lseek
= 1;
306 gdb_do_syscall(nios2_semi_cb
, "lseek,%x,%lx,%x",
309 off
= lseek(arg0
, off
, arg3
);
310 nios2_semi_return_u64(env
, off
, errno
);
319 if (use_gdb_syscalls()) {
320 gdb_do_syscall(nios2_semi_cb
, "rename,%s,%s",
321 arg0
, (int)arg1
, arg2
, (int)arg3
);
324 p
= lock_user_string(arg0
);
325 q
= lock_user_string(arg2
);
330 result
= rename(p
, q
);
332 unlock_user(p
, arg0
, 0);
333 unlock_user(q
, arg2
, 0);
339 if (use_gdb_syscalls()) {
340 gdb_do_syscall(nios2_semi_cb
, "unlink,%s",
344 p
= lock_user_string(arg0
);
350 unlock_user(p
, arg0
, 0);
358 if (use_gdb_syscalls()) {
359 gdb_do_syscall(nios2_semi_cb
, "stat,%s,%x",
360 arg0
, (int)arg1
, arg2
);
364 p
= lock_user_string(arg0
);
369 result
= stat(p
, &s
);
370 unlock_user(p
, arg0
, 0);
372 if (result
== 0 && !translate_stat(env
, arg2
, &s
)) {
381 if (use_gdb_syscalls()) {
382 gdb_do_syscall(nios2_semi_cb
, "fstat,%x,%x",
387 result
= fstat(arg0
, &s
);
388 if (result
== 0 && !translate_stat(env
, arg1
, &s
)) {
394 case HOSTED_GETTIMEOFDAY
:
395 /* Only the tv parameter is used. tz is assumed NULL. */
397 if (use_gdb_syscalls()) {
398 gdb_do_syscall(nios2_semi_cb
, "gettimeofday,%x,%x",
402 struct gdb_timeval
*p
;
403 int64_t rt
= g_get_real_time();
404 p
= lock_user(VERIFY_WRITE
, arg0
, sizeof(struct gdb_timeval
), 0);
410 p
->tv_sec
= cpu_to_be32(rt
/ G_USEC_PER_SEC
);
411 p
->tv_usec
= cpu_to_be64(rt
% G_USEC_PER_SEC
);
412 unlock_user(p
, arg0
, sizeof(struct gdb_timeval
));
418 if (use_gdb_syscalls()) {
419 gdb_do_syscall(nios2_semi_cb
, "isatty,%x", arg0
);
422 result
= isatty(arg0
);
428 if (use_gdb_syscalls()) {
429 gdb_do_syscall(nios2_semi_cb
, "system,%s",
433 p
= lock_user_string(arg0
);
439 unlock_user(p
, arg0
, 0);
444 qemu_log_mask(LOG_GUEST_ERROR
, "nios2-semihosting: unsupported "
445 "semihosting syscall %d\n", nr
);
449 nios2_semi_return_u32(env
, result
, errno
);