tests: add BlockJobTxn unit test
[qemu/ar7.git] / target-arm / arm-semi.c
blobd7cff3db23fb3accc003946e7b5cc2932857401f
1 /*
2 * Arm "Angel" semihosting syscalls
4 * Copyright (c) 2005, 2007 CodeSourcery.
5 * Written by Paul Brook.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #include <fcntl.h>
24 #include <unistd.h>
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <time.h>
29 #include "cpu.h"
30 #include "exec/semihost.h"
31 #ifdef CONFIG_USER_ONLY
32 #include "qemu.h"
34 #define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024)
35 #else
36 #include "qemu-common.h"
37 #include "exec/gdbstub.h"
38 #include "hw/arm/arm.h"
39 #endif
41 #define TARGET_SYS_OPEN 0x01
42 #define TARGET_SYS_CLOSE 0x02
43 #define TARGET_SYS_WRITEC 0x03
44 #define TARGET_SYS_WRITE0 0x04
45 #define TARGET_SYS_WRITE 0x05
46 #define TARGET_SYS_READ 0x06
47 #define TARGET_SYS_READC 0x07
48 #define TARGET_SYS_ISTTY 0x09
49 #define TARGET_SYS_SEEK 0x0a
50 #define TARGET_SYS_FLEN 0x0c
51 #define TARGET_SYS_TMPNAM 0x0d
52 #define TARGET_SYS_REMOVE 0x0e
53 #define TARGET_SYS_RENAME 0x0f
54 #define TARGET_SYS_CLOCK 0x10
55 #define TARGET_SYS_TIME 0x11
56 #define TARGET_SYS_SYSTEM 0x12
57 #define TARGET_SYS_ERRNO 0x13
58 #define TARGET_SYS_GET_CMDLINE 0x15
59 #define TARGET_SYS_HEAPINFO 0x16
60 #define TARGET_SYS_EXIT 0x18
61 #define TARGET_SYS_SYNCCACHE 0x19
63 /* ADP_Stopped_ApplicationExit is used for exit(0),
64 * anything else is implemented as exit(1) */
65 #define ADP_Stopped_ApplicationExit (0x20026)
67 #ifndef O_BINARY
68 #define O_BINARY 0
69 #endif
71 #define GDB_O_RDONLY 0x000
72 #define GDB_O_WRONLY 0x001
73 #define GDB_O_RDWR 0x002
74 #define GDB_O_APPEND 0x008
75 #define GDB_O_CREAT 0x200
76 #define GDB_O_TRUNC 0x400
77 #define GDB_O_BINARY 0
79 static int gdb_open_modeflags[12] = {
80 GDB_O_RDONLY,
81 GDB_O_RDONLY | GDB_O_BINARY,
82 GDB_O_RDWR,
83 GDB_O_RDWR | GDB_O_BINARY,
84 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC,
85 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
86 GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC,
87 GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
88 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND,
89 GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY,
90 GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND,
91 GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY
94 static int open_modeflags[12] = {
95 O_RDONLY,
96 O_RDONLY | O_BINARY,
97 O_RDWR,
98 O_RDWR | O_BINARY,
99 O_WRONLY | O_CREAT | O_TRUNC,
100 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
101 O_RDWR | O_CREAT | O_TRUNC,
102 O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
103 O_WRONLY | O_CREAT | O_APPEND,
104 O_WRONLY | O_CREAT | O_APPEND | O_BINARY,
105 O_RDWR | O_CREAT | O_APPEND,
106 O_RDWR | O_CREAT | O_APPEND | O_BINARY
109 #ifdef CONFIG_USER_ONLY
110 static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
112 if (code == (uint32_t)-1)
113 ts->swi_errno = errno;
114 return code;
116 #else
117 static inline uint32_t set_swi_errno(CPUARMState *env, uint32_t code)
119 return code;
122 #include "exec/softmmu-semi.h"
123 #endif
125 static target_ulong arm_semi_syscall_len;
127 #if !defined(CONFIG_USER_ONLY)
128 static target_ulong syscall_err;
129 #endif
131 static void arm_semi_cb(CPUState *cs, target_ulong ret, target_ulong err)
133 ARMCPU *cpu = ARM_CPU(cs);
134 CPUARMState *env = &cpu->env;
135 #ifdef CONFIG_USER_ONLY
136 TaskState *ts = cs->opaque;
137 #endif
138 target_ulong reg0 = is_a64(env) ? env->xregs[0] : env->regs[0];
140 if (ret == (target_ulong)-1) {
141 #ifdef CONFIG_USER_ONLY
142 ts->swi_errno = err;
143 #else
144 syscall_err = err;
145 #endif
146 reg0 = ret;
147 } else {
148 /* Fixup syscalls that use nonstardard return conventions. */
149 switch (reg0) {
150 case TARGET_SYS_WRITE:
151 case TARGET_SYS_READ:
152 reg0 = arm_semi_syscall_len - ret;
153 break;
154 case TARGET_SYS_SEEK:
155 reg0 = 0;
156 break;
157 default:
158 reg0 = ret;
159 break;
162 if (is_a64(env)) {
163 env->xregs[0] = reg0;
164 } else {
165 env->regs[0] = reg0;
169 static target_ulong arm_flen_buf(ARMCPU *cpu)
171 /* Return an address in target memory of 64 bytes where the remote
172 * gdb should write its stat struct. (The format of this structure
173 * is defined by GDB's remote protocol and is not target-specific.)
174 * We put this on the guest's stack just below SP.
176 CPUARMState *env = &cpu->env;
177 target_ulong sp;
179 if (is_a64(env)) {
180 sp = env->xregs[31];
181 } else {
182 sp = env->regs[13];
185 return sp - 64;
188 static void arm_semi_flen_cb(CPUState *cs, target_ulong ret, target_ulong err)
190 ARMCPU *cpu = ARM_CPU(cs);
191 CPUARMState *env = &cpu->env;
192 /* The size is always stored in big-endian order, extract
193 the value. We assume the size always fit in 32 bits. */
194 uint32_t size;
195 cpu_memory_rw_debug(cs, arm_flen_buf(cpu) + 32, (uint8_t *)&size, 4, 0);
196 size = be32_to_cpu(size);
197 if (is_a64(env)) {
198 env->xregs[0] = size;
199 } else {
200 env->regs[0] = size;
202 #ifdef CONFIG_USER_ONLY
203 ((TaskState *)cs->opaque)->swi_errno = err;
204 #else
205 syscall_err = err;
206 #endif
209 static target_ulong arm_gdb_syscall(ARMCPU *cpu, gdb_syscall_complete_cb cb,
210 const char *fmt, ...)
212 va_list va;
213 CPUARMState *env = &cpu->env;
215 va_start(va, fmt);
216 gdb_do_syscallv(cb, fmt, va);
217 va_end(va);
219 /* FIXME: we are implicitly relying on the syscall completing
220 * before this point, which is not guaranteed. We should
221 * put in an explicit synchronization between this and
222 * the callback function.
225 return is_a64(env) ? env->xregs[0] : env->regs[0];
228 /* Read the input value from the argument block; fail the semihosting
229 * call if the memory read fails.
231 #define GET_ARG(n) do { \
232 if (is_a64(env)) { \
233 if (get_user_u64(arg ## n, args + (n) * 8)) { \
234 return -1; \
236 } else { \
237 if (get_user_u32(arg ## n, args + (n) * 4)) { \
238 return -1; \
241 } while (0)
243 #define SET_ARG(n, val) \
244 (is_a64(env) ? \
245 put_user_u64(val, args + (n) * 8) : \
246 put_user_u32(val, args + (n) * 4))
248 target_ulong do_arm_semihosting(CPUARMState *env)
250 ARMCPU *cpu = arm_env_get_cpu(env);
251 CPUState *cs = CPU(cpu);
252 target_ulong args;
253 target_ulong arg0, arg1, arg2, arg3;
254 char * s;
255 int nr;
256 uint32_t ret;
257 uint32_t len;
258 #ifdef CONFIG_USER_ONLY
259 TaskState *ts = cs->opaque;
260 #else
261 CPUARMState *ts = env;
262 #endif
264 if (is_a64(env)) {
265 /* Note that the syscall number is in W0, not X0 */
266 nr = env->xregs[0] & 0xffffffffU;
267 args = env->xregs[1];
268 } else {
269 nr = env->regs[0];
270 args = env->regs[1];
273 switch (nr) {
274 case TARGET_SYS_OPEN:
275 GET_ARG(0);
276 GET_ARG(1);
277 GET_ARG(2);
278 s = lock_user_string(arg0);
279 if (!s) {
280 /* FIXME - should this error code be -TARGET_EFAULT ? */
281 return (uint32_t)-1;
283 if (arg1 >= 12) {
284 unlock_user(s, arg0, 0);
285 return (uint32_t)-1;
287 if (strcmp(s, ":tt") == 0) {
288 int result_fileno = arg1 < 4 ? STDIN_FILENO : STDOUT_FILENO;
289 unlock_user(s, arg0, 0);
290 return result_fileno;
292 if (use_gdb_syscalls()) {
293 ret = arm_gdb_syscall(cpu, arm_semi_cb, "open,%s,%x,1a4", arg0,
294 (int)arg2+1, gdb_open_modeflags[arg1]);
295 } else {
296 ret = set_swi_errno(ts, open(s, open_modeflags[arg1], 0644));
298 unlock_user(s, arg0, 0);
299 return ret;
300 case TARGET_SYS_CLOSE:
301 GET_ARG(0);
302 if (use_gdb_syscalls()) {
303 return arm_gdb_syscall(cpu, arm_semi_cb, "close,%x", arg0);
304 } else {
305 return set_swi_errno(ts, close(arg0));
307 case TARGET_SYS_WRITEC:
309 char c;
311 if (get_user_u8(c, args))
312 /* FIXME - should this error code be -TARGET_EFAULT ? */
313 return (uint32_t)-1;
314 /* Write to debug console. stderr is near enough. */
315 if (use_gdb_syscalls()) {
316 return arm_gdb_syscall(cpu, arm_semi_cb, "write,2,%x,1", args);
317 } else {
318 return write(STDERR_FILENO, &c, 1);
321 case TARGET_SYS_WRITE0:
322 if (!(s = lock_user_string(args)))
323 /* FIXME - should this error code be -TARGET_EFAULT ? */
324 return (uint32_t)-1;
325 len = strlen(s);
326 if (use_gdb_syscalls()) {
327 return arm_gdb_syscall(cpu, arm_semi_cb, "write,2,%x,%x",
328 args, len);
329 } else {
330 ret = write(STDERR_FILENO, s, len);
332 unlock_user(s, args, 0);
333 return ret;
334 case TARGET_SYS_WRITE:
335 GET_ARG(0);
336 GET_ARG(1);
337 GET_ARG(2);
338 len = arg2;
339 if (use_gdb_syscalls()) {
340 arm_semi_syscall_len = len;
341 return arm_gdb_syscall(cpu, arm_semi_cb, "write,%x,%x,%x",
342 arg0, arg1, len);
343 } else {
344 s = lock_user(VERIFY_READ, arg1, len, 1);
345 if (!s) {
346 /* FIXME - should this error code be -TARGET_EFAULT ? */
347 return (uint32_t)-1;
349 ret = set_swi_errno(ts, write(arg0, s, len));
350 unlock_user(s, arg1, 0);
351 if (ret == (uint32_t)-1)
352 return -1;
353 return len - ret;
355 case TARGET_SYS_READ:
356 GET_ARG(0);
357 GET_ARG(1);
358 GET_ARG(2);
359 len = arg2;
360 if (use_gdb_syscalls()) {
361 arm_semi_syscall_len = len;
362 return arm_gdb_syscall(cpu, arm_semi_cb, "read,%x,%x,%x",
363 arg0, arg1, len);
364 } else {
365 s = lock_user(VERIFY_WRITE, arg1, len, 0);
366 if (!s) {
367 /* FIXME - should this error code be -TARGET_EFAULT ? */
368 return (uint32_t)-1;
370 do {
371 ret = set_swi_errno(ts, read(arg0, s, len));
372 } while (ret == -1 && errno == EINTR);
373 unlock_user(s, arg1, len);
374 if (ret == (uint32_t)-1)
375 return -1;
376 return len - ret;
378 case TARGET_SYS_READC:
379 /* XXX: Read from debug console. Not implemented. */
380 return 0;
381 case TARGET_SYS_ISTTY:
382 GET_ARG(0);
383 if (use_gdb_syscalls()) {
384 return arm_gdb_syscall(cpu, arm_semi_cb, "isatty,%x", arg0);
385 } else {
386 return isatty(arg0);
388 case TARGET_SYS_SEEK:
389 GET_ARG(0);
390 GET_ARG(1);
391 if (use_gdb_syscalls()) {
392 return arm_gdb_syscall(cpu, arm_semi_cb, "lseek,%x,%x,0",
393 arg0, arg1);
394 } else {
395 ret = set_swi_errno(ts, lseek(arg0, arg1, SEEK_SET));
396 if (ret == (uint32_t)-1)
397 return -1;
398 return 0;
400 case TARGET_SYS_FLEN:
401 GET_ARG(0);
402 if (use_gdb_syscalls()) {
403 return arm_gdb_syscall(cpu, arm_semi_flen_cb, "fstat,%x,%x",
404 arg0, arm_flen_buf(cpu));
405 } else {
406 struct stat buf;
407 ret = set_swi_errno(ts, fstat(arg0, &buf));
408 if (ret == (uint32_t)-1)
409 return -1;
410 return buf.st_size;
412 case TARGET_SYS_TMPNAM:
413 /* XXX: Not implemented. */
414 return -1;
415 case TARGET_SYS_REMOVE:
416 GET_ARG(0);
417 GET_ARG(1);
418 if (use_gdb_syscalls()) {
419 ret = arm_gdb_syscall(cpu, arm_semi_cb, "unlink,%s",
420 arg0, (int)arg1+1);
421 } else {
422 s = lock_user_string(arg0);
423 if (!s) {
424 /* FIXME - should this error code be -TARGET_EFAULT ? */
425 return (uint32_t)-1;
427 ret = set_swi_errno(ts, remove(s));
428 unlock_user(s, arg0, 0);
430 return ret;
431 case TARGET_SYS_RENAME:
432 GET_ARG(0);
433 GET_ARG(1);
434 GET_ARG(2);
435 GET_ARG(3);
436 if (use_gdb_syscalls()) {
437 return arm_gdb_syscall(cpu, arm_semi_cb, "rename,%s,%s",
438 arg0, (int)arg1+1, arg2, (int)arg3+1);
439 } else {
440 char *s2;
441 s = lock_user_string(arg0);
442 s2 = lock_user_string(arg2);
443 if (!s || !s2)
444 /* FIXME - should this error code be -TARGET_EFAULT ? */
445 ret = (uint32_t)-1;
446 else
447 ret = set_swi_errno(ts, rename(s, s2));
448 if (s2)
449 unlock_user(s2, arg2, 0);
450 if (s)
451 unlock_user(s, arg0, 0);
452 return ret;
454 case TARGET_SYS_CLOCK:
455 return clock() / (CLOCKS_PER_SEC / 100);
456 case TARGET_SYS_TIME:
457 return set_swi_errno(ts, time(NULL));
458 case TARGET_SYS_SYSTEM:
459 GET_ARG(0);
460 GET_ARG(1);
461 if (use_gdb_syscalls()) {
462 return arm_gdb_syscall(cpu, arm_semi_cb, "system,%s",
463 arg0, (int)arg1+1);
464 } else {
465 s = lock_user_string(arg0);
466 if (!s) {
467 /* FIXME - should this error code be -TARGET_EFAULT ? */
468 return (uint32_t)-1;
470 ret = set_swi_errno(ts, system(s));
471 unlock_user(s, arg0, 0);
472 return ret;
474 case TARGET_SYS_ERRNO:
475 #ifdef CONFIG_USER_ONLY
476 return ts->swi_errno;
477 #else
478 return syscall_err;
479 #endif
480 case TARGET_SYS_GET_CMDLINE:
482 /* Build a command-line from the original argv.
484 * The inputs are:
485 * * arg0, pointer to a buffer of at least the size
486 * specified in arg1.
487 * * arg1, size of the buffer pointed to by arg0 in
488 * bytes.
490 * The outputs are:
491 * * arg0, pointer to null-terminated string of the
492 * command line.
493 * * arg1, length of the string pointed to by arg0.
496 char *output_buffer;
497 size_t input_size;
498 size_t output_size;
499 int status = 0;
500 #if !defined(CONFIG_USER_ONLY)
501 const char *cmdline;
502 #endif
503 GET_ARG(0);
504 GET_ARG(1);
505 input_size = arg1;
506 /* Compute the size of the output string. */
507 #if !defined(CONFIG_USER_ONLY)
508 cmdline = semihosting_get_cmdline();
509 if (cmdline == NULL) {
510 cmdline = ""; /* Default to an empty line. */
512 output_size = strlen(cmdline) + 1; /* Count terminating 0. */
513 #else
514 unsigned int i;
516 output_size = ts->info->arg_end - ts->info->arg_start;
517 if (!output_size) {
518 /* We special-case the "empty command line" case (argc==0).
519 Just provide the terminating 0. */
520 output_size = 1;
522 #endif
524 if (output_size > input_size) {
525 /* Not enough space to store command-line arguments. */
526 return -1;
529 /* Adjust the command-line length. */
530 if (SET_ARG(1, output_size - 1)) {
531 /* Couldn't write back to argument block */
532 return -1;
535 /* Lock the buffer on the ARM side. */
536 output_buffer = lock_user(VERIFY_WRITE, arg0, output_size, 0);
537 if (!output_buffer) {
538 return -1;
541 /* Copy the command-line arguments. */
542 #if !defined(CONFIG_USER_ONLY)
543 pstrcpy(output_buffer, output_size, cmdline);
544 #else
545 if (output_size == 1) {
546 /* Empty command-line. */
547 output_buffer[0] = '\0';
548 goto out;
551 if (copy_from_user(output_buffer, ts->info->arg_start,
552 output_size)) {
553 status = -1;
554 goto out;
557 /* Separate arguments by white spaces. */
558 for (i = 0; i < output_size - 1; i++) {
559 if (output_buffer[i] == 0) {
560 output_buffer[i] = ' ';
563 out:
564 #endif
565 /* Unlock the buffer on the ARM side. */
566 unlock_user(output_buffer, arg0, output_size);
568 return status;
570 case TARGET_SYS_HEAPINFO:
572 uint32_t *ptr;
573 uint32_t limit;
574 GET_ARG(0);
576 #ifdef CONFIG_USER_ONLY
577 /* Some C libraries assume the heap immediately follows .bss, so
578 allocate it using sbrk. */
579 if (!ts->heap_limit) {
580 abi_ulong ret;
582 ts->heap_base = do_brk(0);
583 limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
584 /* Try a big heap, and reduce the size if that fails. */
585 for (;;) {
586 ret = do_brk(limit);
587 if (ret >= limit) {
588 break;
590 limit = (ts->heap_base >> 1) + (limit >> 1);
592 ts->heap_limit = limit;
595 ptr = lock_user(VERIFY_WRITE, arg0, 16, 0);
596 if (!ptr) {
597 /* FIXME - should this error code be -TARGET_EFAULT ? */
598 return (uint32_t)-1;
600 ptr[0] = tswap32(ts->heap_base);
601 ptr[1] = tswap32(ts->heap_limit);
602 ptr[2] = tswap32(ts->stack_base);
603 ptr[3] = tswap32(0); /* Stack limit. */
604 unlock_user(ptr, arg0, 16);
605 #else
606 limit = ram_size;
607 ptr = lock_user(VERIFY_WRITE, arg0, 16, 0);
608 if (!ptr) {
609 /* FIXME - should this error code be -TARGET_EFAULT ? */
610 return (uint32_t)-1;
612 /* TODO: Make this use the limit of the loaded application. */
613 ptr[0] = tswap32(limit / 2);
614 ptr[1] = tswap32(limit);
615 ptr[2] = tswap32(limit); /* Stack base */
616 ptr[3] = tswap32(0); /* Stack limit. */
617 unlock_user(ptr, arg0, 16);
618 #endif
619 return 0;
621 case TARGET_SYS_EXIT:
622 if (is_a64(env)) {
623 /* The A64 version of this call takes a parameter block,
624 * so the application-exit type can return a subcode which
625 * is the exit status code from the application.
627 GET_ARG(0);
628 GET_ARG(1);
630 if (arg0 == ADP_Stopped_ApplicationExit) {
631 ret = arg1;
632 } else {
633 ret = 1;
635 } else {
636 /* ARM specifies only Stopped_ApplicationExit as normal
637 * exit, everything else is considered an error */
638 ret = (args == ADP_Stopped_ApplicationExit) ? 0 : 1;
640 gdb_exit(env, ret);
641 exit(ret);
642 case TARGET_SYS_SYNCCACHE:
643 /* Clean the D-cache and invalidate the I-cache for the specified
644 * virtual address range. This is a nop for us since we don't
645 * implement caches. This is only present on A64.
647 if (is_a64(env)) {
648 return 0;
650 /* fall through -- invalid for A32/T32 */
651 default:
652 fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
653 cpu_dump_state(cs, stderr, fprintf, 0);
654 abort();