2 * m68k/ColdFire Semihosting syscall interface
4 * Copyright (c) 2005-2007 CodeSourcery.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 #include "qemu/osdep.h"
23 #if defined(CONFIG_USER_ONLY)
25 #define SEMIHOSTING_HEAP_SIZE (128 * 1024 * 1024)
27 #include "exec/gdbstub.h"
28 #include "exec/softmmu-semi.h"
29 #include "hw/boards.h"
34 #define HOSTED_INIT_SIM 1
36 #define HOSTED_CLOSE 3
38 #define HOSTED_WRITE 5
39 #define HOSTED_LSEEK 6
40 #define HOSTED_RENAME 7
41 #define HOSTED_UNLINK 8
43 #define HOSTED_FSTAT 10
44 #define HOSTED_GETTIMEOFDAY 11
45 #define HOSTED_ISATTY 12
46 #define HOSTED_SYSTEM 13
48 typedef uint32_t gdb_mode_t
;
49 typedef uint32_t gdb_time_t
;
51 struct m68k_gdb_stat
{
52 uint32_t gdb_st_dev
; /* device */
53 uint32_t gdb_st_ino
; /* inode */
54 gdb_mode_t gdb_st_mode
; /* protection */
55 uint32_t gdb_st_nlink
; /* number of hard links */
56 uint32_t gdb_st_uid
; /* user ID of owner */
57 uint32_t gdb_st_gid
; /* group ID of owner */
58 uint32_t gdb_st_rdev
; /* device type (if inode device) */
59 uint64_t gdb_st_size
; /* total size, in bytes */
60 uint64_t gdb_st_blksize
; /* blocksize for filesystem I/O */
61 uint64_t gdb_st_blocks
; /* number of blocks allocated */
62 gdb_time_t gdb_st_atime
; /* time of last access */
63 gdb_time_t gdb_st_mtime
; /* time of last modification */
64 gdb_time_t gdb_st_ctime
; /* time of last change */
68 gdb_time_t tv_sec
; /* second */
69 uint64_t tv_usec
; /* microsecond */
72 #define GDB_O_RDONLY 0x0
73 #define GDB_O_WRONLY 0x1
74 #define GDB_O_RDWR 0x2
75 #define GDB_O_APPEND 0x8
76 #define GDB_O_CREAT 0x200
77 #define GDB_O_TRUNC 0x400
78 #define GDB_O_EXCL 0x800
80 static int translate_openflags(int flags
)
84 if (flags
& GDB_O_WRONLY
)
86 else if (flags
& GDB_O_RDWR
)
91 if (flags
& GDB_O_APPEND
) hf
|= O_APPEND
;
92 if (flags
& GDB_O_CREAT
) hf
|= O_CREAT
;
93 if (flags
& GDB_O_TRUNC
) hf
|= O_TRUNC
;
94 if (flags
& GDB_O_EXCL
) hf
|= O_EXCL
;
99 static void translate_stat(CPUM68KState
*env
, target_ulong addr
, struct stat
*s
)
101 struct m68k_gdb_stat
*p
;
103 if (!(p
= lock_user(VERIFY_WRITE
, addr
, sizeof(struct m68k_gdb_stat
), 0)))
104 /* FIXME - should this return an error code? */
106 p
->gdb_st_dev
= cpu_to_be32(s
->st_dev
);
107 p
->gdb_st_ino
= cpu_to_be32(s
->st_ino
);
108 p
->gdb_st_mode
= cpu_to_be32(s
->st_mode
);
109 p
->gdb_st_nlink
= cpu_to_be32(s
->st_nlink
);
110 p
->gdb_st_uid
= cpu_to_be32(s
->st_uid
);
111 p
->gdb_st_gid
= cpu_to_be32(s
->st_gid
);
112 p
->gdb_st_rdev
= cpu_to_be32(s
->st_rdev
);
113 p
->gdb_st_size
= cpu_to_be64(s
->st_size
);
115 /* Windows stat is missing some fields. */
116 p
->gdb_st_blksize
= 0;
117 p
->gdb_st_blocks
= 0;
119 p
->gdb_st_blksize
= cpu_to_be64(s
->st_blksize
);
120 p
->gdb_st_blocks
= cpu_to_be64(s
->st_blocks
);
122 p
->gdb_st_atime
= cpu_to_be32(s
->st_atime
);
123 p
->gdb_st_mtime
= cpu_to_be32(s
->st_mtime
);
124 p
->gdb_st_ctime
= cpu_to_be32(s
->st_ctime
);
125 unlock_user(p
, addr
, sizeof(struct m68k_gdb_stat
));
128 static void m68k_semi_return_u32(CPUM68KState
*env
, uint32_t ret
, uint32_t err
)
130 target_ulong args
= env
->dregs
[1];
131 if (put_user_u32(ret
, args
) ||
132 put_user_u32(err
, args
+ 4)) {
134 * The m68k semihosting ABI does not provide any way to report this
135 * error to the guest, so the best we can do is log it in qemu.
136 * It is always a guest error not to pass us a valid argument block.
138 qemu_log_mask(LOG_GUEST_ERROR
, "m68k-semihosting: return value "
139 "discarded because argument block not writable\n");
143 static void m68k_semi_return_u64(CPUM68KState
*env
, uint64_t ret
, uint32_t err
)
145 target_ulong args
= env
->dregs
[1];
146 if (put_user_u32(ret
>> 32, args
) ||
147 put_user_u32(ret
, args
+ 4) ||
148 put_user_u32(err
, args
+ 8)) {
149 /* No way to report this via m68k semihosting ABI; just log it */
150 qemu_log_mask(LOG_GUEST_ERROR
, "m68k-semihosting: return value "
151 "discarded because argument block not writable\n");
155 static int m68k_semi_is_fseek
;
157 static void m68k_semi_cb(CPUState
*cs
, target_ulong ret
, target_ulong err
)
159 M68kCPU
*cpu
= M68K_CPU(cs
);
160 CPUM68KState
*env
= &cpu
->env
;
162 if (m68k_semi_is_fseek
) {
164 * FIXME: We've already lost the high bits of the fseek
167 m68k_semi_return_u64(env
, ret
, err
);
168 m68k_semi_is_fseek
= 0;
170 m68k_semi_return_u32(env
, ret
, err
);
175 * Read the input value from the argument block; fail the semihosting
176 * call if the memory read fails.
178 #define GET_ARG(n) do { \
179 if (get_user_ual(arg ## n, args + (n) * 4)) { \
186 void do_m68k_semihosting(CPUM68KState
*env
, int nr
)
189 target_ulong arg0
, arg1
, arg2
, arg3
;
195 args
= env
->dregs
[1];
198 gdb_exit(env
->dregs
[0]);
205 if (use_gdb_syscalls()) {
206 gdb_do_syscall(m68k_semi_cb
, "open,%s,%x,%x", arg0
, (int)arg1
,
210 p
= lock_user_string(arg0
);
212 /* FIXME - check error code? */
215 result
= open(p
, translate_openflags(arg2
), arg3
);
216 unlock_user(p
, arg0
, 0);
222 /* Ignore attempts to close stdin/out/err. */
226 if (use_gdb_syscalls()) {
227 gdb_do_syscall(m68k_semi_cb
, "close,%x", arg0
);
242 if (use_gdb_syscalls()) {
243 gdb_do_syscall(m68k_semi_cb
, "read,%x,%x,%x",
247 p
= lock_user(VERIFY_WRITE
, arg1
, len
, 0);
249 /* FIXME - check error code? */
252 result
= read(arg0
, p
, len
);
253 unlock_user(p
, arg1
, len
);
262 if (use_gdb_syscalls()) {
263 gdb_do_syscall(m68k_semi_cb
, "write,%x,%x,%x",
267 p
= lock_user(VERIFY_READ
, arg1
, len
, 1);
269 /* FIXME - check error code? */
272 result
= write(arg0
, p
, len
);
273 unlock_user(p
, arg0
, 0);
284 off
= (uint32_t)arg2
| ((uint64_t)arg1
<< 32);
285 if (use_gdb_syscalls()) {
286 m68k_semi_is_fseek
= 1;
287 gdb_do_syscall(m68k_semi_cb
, "fseek,%x,%lx,%x",
290 off
= lseek(arg0
, off
, arg3
);
291 m68k_semi_return_u64(env
, off
, errno
);
300 if (use_gdb_syscalls()) {
301 gdb_do_syscall(m68k_semi_cb
, "rename,%s,%s",
302 arg0
, (int)arg1
, arg2
, (int)arg3
);
305 p
= lock_user_string(arg0
);
306 q
= lock_user_string(arg2
);
308 /* FIXME - check error code? */
311 result
= rename(p
, q
);
313 unlock_user(p
, arg0
, 0);
314 unlock_user(q
, arg2
, 0);
320 if (use_gdb_syscalls()) {
321 gdb_do_syscall(m68k_semi_cb
, "unlink,%s",
325 p
= lock_user_string(arg0
);
327 /* FIXME - check error code? */
331 unlock_user(p
, arg0
, 0);
339 if (use_gdb_syscalls()) {
340 gdb_do_syscall(m68k_semi_cb
, "stat,%s,%x",
341 arg0
, (int)arg1
, arg2
);
345 p
= lock_user_string(arg0
);
347 /* FIXME - check error code? */
350 result
= stat(p
, &s
);
351 unlock_user(p
, arg0
, 0);
354 translate_stat(env
, arg2
, &s
);
361 if (use_gdb_syscalls()) {
362 gdb_do_syscall(m68k_semi_cb
, "fstat,%x,%x",
367 result
= fstat(arg0
, &s
);
369 translate_stat(env
, arg1
, &s
);
373 case HOSTED_GETTIMEOFDAY
:
376 if (use_gdb_syscalls()) {
377 gdb_do_syscall(m68k_semi_cb
, "gettimeofday,%x,%x",
382 struct gdb_timeval
*p
;
383 result
= qemu_gettimeofday(&tv
);
385 if (!(p
= lock_user(VERIFY_WRITE
,
386 arg0
, sizeof(struct gdb_timeval
), 0))) {
387 /* FIXME - check error code? */
390 p
->tv_sec
= cpu_to_be32(tv
.tv_sec
);
391 p
->tv_usec
= cpu_to_be64(tv
.tv_usec
);
392 unlock_user(p
, arg0
, sizeof(struct gdb_timeval
));
399 if (use_gdb_syscalls()) {
400 gdb_do_syscall(m68k_semi_cb
, "isatty,%x", arg0
);
403 result
= isatty(arg0
);
409 if (use_gdb_syscalls()) {
410 gdb_do_syscall(m68k_semi_cb
, "system,%s",
414 p
= lock_user_string(arg0
);
416 /* FIXME - check error code? */
420 unlock_user(p
, arg0
, 0);
424 case HOSTED_INIT_SIM
:
425 #if defined(CONFIG_USER_ONLY)
427 CPUState
*cs
= env_cpu(env
);
428 TaskState
*ts
= cs
->opaque
;
429 /* Allocate the heap using sbrk. */
430 if (!ts
->heap_limit
) {
436 size
= SEMIHOSTING_HEAP_SIZE
;
437 /* Try a big heap, and reduce the size if that fails. */
439 ret
= do_brk(base
+ size
);
440 if (ret
>= (base
+ size
)) {
445 ts
->heap_limit
= base
+ size
;
448 * This call may happen before we have writable memory, so return
449 * values directly in registers.
451 env
->dregs
[1] = ts
->heap_limit
;
452 env
->aregs
[7] = ts
->stack_base
;
456 * FIXME: This is wrong for boards where RAM does not start at
459 env
->dregs
[1] = current_machine
->ram_size
;
460 env
->aregs
[7] = current_machine
->ram_size
;
464 cpu_abort(env_cpu(env
), "Unsupported semihosting syscall %d\n", nr
);
468 m68k_semi_return_u32(env
, result
, errno
);