1: /*
2: * Arm "Angel" semihosting syscalls
3: *
4: * Copyright (c) 2005, 2007 CodeSourcery.
5: * Written by Paul Brook.
6: *
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.
11: *
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.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with this program; if not, write to the Free Software
19: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20: */
21:
22: #include <sys/types.h>
23: #include <sys/stat.h>
24: #include <fcntl.h>
25: #include <unistd.h>
26: #include <stdlib.h>
27: #include <stdio.h>
28: #include <time.h>
29:
30: #include "cpu.h"
31: #ifdef CONFIG_USER_ONLY
32: #include "qemu.h"
33:
34: #define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024)
35: #else
36: #include "vl.h"
37: #endif
38:
39: #define SYS_OPEN 0x01
40: #define SYS_CLOSE 0x02
41: #define SYS_WRITEC 0x03
42: #define SYS_WRITE0 0x04
43: #define SYS_WRITE 0x05
44: #define SYS_READ 0x06
45: #define SYS_READC 0x07
46: #define SYS_ISTTY 0x09
47: #define SYS_SEEK 0x0a
48: #define SYS_FLEN 0x0c
49: #define SYS_TMPNAM 0x0d
50: #define SYS_REMOVE 0x0e
51: #define SYS_RENAME 0x0f
52: #define SYS_CLOCK 0x10
53: #define SYS_TIME 0x11
54: #define SYS_SYSTEM 0x12
55: #define SYS_ERRNO 0x13
56: #define SYS_GET_CMDLINE 0x15
57: #define SYS_HEAPINFO 0x16
58: #define SYS_EXIT 0x18
59:
60: #ifndef O_BINARY
61: #define O_BINARY 0
62: #endif
63:
64: #define GDB_O_RDONLY 0x000
65: #define GDB_O_WRONLY 0x001
66: #define GDB_O_RDWR 0x002
67: #define GDB_O_APPEND 0x008
68: #define GDB_O_CREAT 0x200
69: #define GDB_O_TRUNC 0x400
70: #define GDB_O_BINARY 0
71:
72: static int gdb_open_modeflags[12] = {
73: GDB_O_RDONLY,
74: GDB_O_RDONLY | GDB_O_BINARY,
75: GDB_O_RDWR,
76: GDB_O_RDWR | GDB_O_BINARY,
77: GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC,
78: GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
79: GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC,
80: GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
81: GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND,
82: GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY,
83: GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND,
84: GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY
85: };
86:
87: static int open_modeflags[12] = {
88: O_RDONLY,
89: O_RDONLY | O_BINARY,
90: O_RDWR,
91: O_RDWR | O_BINARY,
92: O_WRONLY | O_CREAT | O_TRUNC,
93: O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
94: O_RDWR | O_CREAT | O_TRUNC,
95: O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
96: O_WRONLY | O_CREAT | O_APPEND,
97: O_WRONLY | O_CREAT | O_APPEND | O_BINARY,
98: O_RDWR | O_CREAT | O_APPEND,
99: O_RDWR | O_CREAT | O_APPEND | O_BINARY
100: };
101:
102: #ifdef CONFIG_USER_ONLY
103: static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
104: {
105: if (code == (uint32_t)-1)
106: ts->swi_errno = errno;
107: return code;
108: }
109: #else
110: static inline uint32_t set_swi_errno(CPUState *env, uint32_t code)
111: {
112: return code;
113: }
114:
115: static uint32_t softmmu_tget32(CPUState *env, uint32_t addr)
116: {
117: uint32_t val;
118:
119: cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 0);
120: return tswap32(val);
121: }
122: static uint32_t softmmu_tget8(CPUState *env, uint32_t addr)
123: {
124: uint8_t val;
125:
126: cpu_memory_rw_debug(env, addr, &val, 1, 0);
127: return val;
128: }
129: #define tget32(p) softmmu_tget32(env, p)
130: #define tget8(p) softmmu_tget8(env, p)
131:
132: static void *softmmu_lock_user(CPUState *env, uint32_t addr, uint32_t len,
133: int copy)
134: {
135: char *p;
136: /* TODO: Make this something that isn't fixed size. */
137: p = malloc(len);
138: if (copy)
139: cpu_memory_rw_debug(env, addr, p, len, 0);
140: return p;
141: }
142: #define lock_user(p, len, copy) softmmu_lock_user(env, p, len, copy)
143: static char *softmmu_lock_user_string(CPUState *env, uint32_t addr)
144: {
145: char *p;
146: char *s;
147: uint8_t c;
148: /* TODO: Make this something that isn't fixed size. */
149: s = p = malloc(1024);
150: do {
151: cpu_memory_rw_debug(env, addr, &c, 1, 0);
152: addr++;
153: *(p++) = c;
154: } while (c);
155: return s;
156: }
157: #define lock_user_string(p) softmmu_lock_user_string(env, p)
158: static void softmmu_unlock_user(CPUState *env, void *p, target_ulong addr,
159: target_ulong len)
160: {
161: if (len)
162: cpu_memory_rw_debug(env, addr, p, len, 1);
163: free(p);
164: }
165: #define unlock_user(s, args, len) softmmu_unlock_user(env, s, args, len)
166: #endif
167:
168: static target_ulong arm_semi_syscall_len;
169:
170: static void arm_semi_cb(CPUState *env, target_ulong ret, target_ulong err)
171: {
172: #ifdef CONFIG_USER_ONLY
173: TaskState *ts = env->opaque;
174: #endif
175: if (ret == (target_ulong)-1) {
176: #ifdef CONFIG_USER_ONLY
177: ts->swi_errno = err;
178: #endif
179: env->regs[0] = ret;
180: } else {
181: /* Fixup syscalls that use nonstardard return conventions. */
182: switch (env->regs[0]) {
183: case SYS_WRITE:
184: case SYS_READ:
185: env->regs[0] = arm_semi_syscall_len - ret;
186: break;
187: case SYS_SEEK:
188: env->regs[0] = 0;
189: break;
190: default:
191: env->regs[0] = ret;
192: break;
193: }
194: }
195: }
196:
197: #define ARG(n) tget32(args + (n) * 4)
198: #define SET_ARG(n, val) tput32(args + (n) * 4,val)
199: uint32_t do_arm_semihosting(CPUState *env)
200: {
201: target_ulong args;
202: char * s;
203: int nr;
204: uint32_t ret;
205: uint32_t len;
206: #ifdef CONFIG_USER_ONLY
207: TaskState *ts = env->opaque;
208: #else
209: CPUState *ts = env;
210: #endif
211:
212: nr = env->regs[0];
213: args = env->regs[1];
214: switch (nr) {
215: case SYS_OPEN:
216: s = lock_user_string(ARG(0));
217: if (ARG(1) >= 12)
218: return (uint32_t)-1;
219: if (strcmp(s, ":tt") == 0) {
220: if (ARG(1) < 4)
221: return STDIN_FILENO;
222: else
223: return STDOUT_FILENO;
224: }
225: if (use_gdb_syscalls()) {
226: gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", ARG(0), (int)ARG(2),
227: gdb_open_modeflags[ARG(1)]);
228: return env->regs[0];
229: } else {
230: ret = set_swi_errno(ts, open(s, open_modeflags[ARG(1)], 0644));
231: }
232: unlock_user(s, ARG(0), 0);
233: return ret;
234: case SYS_CLOSE:
235: if (use_gdb_syscalls()) {
236: gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0));
237: return env->regs[0];
238: } else {
239: return set_swi_errno(ts, close(ARG(0)));
240: }
241: case SYS_WRITEC:
242: {
243: char c = tget8(args);
244: /* Write to debug console. stderr is near enough. */
245: if (use_gdb_syscalls()) {
246: gdb_do_syscall(arm_semi_cb, "write,2,%x,1", args);
247: return env->regs[0];
248: } else {
249: return write(STDERR_FILENO, &c, 1);
250: }
251: }
252: case SYS_WRITE0:
253: s = lock_user_string(args);
254: len = strlen(s);
255: if (use_gdb_syscalls()) {
256: gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len);
257: ret = env->regs[0];
258: } else {
259: ret = write(STDERR_FILENO, s, len);
260: }
261: unlock_user(s, args, 0);
262: return ret;
263: case SYS_WRITE:
264: len = ARG(2);
265: if (use_gdb_syscalls()) {
266: arm_semi_syscall_len = len;
267: gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", ARG(0), ARG(1), len);
268: return env->regs[0];
269: } else {
270: s = lock_user(ARG(1), len, 1);
271: ret = set_swi_errno(ts, write(ARG(0), s, len));
272: unlock_user(s, ARG(1), 0);
273: if (ret == (uint32_t)-1)
274: return -1;
275: return len - ret;
276: }
277: case SYS_READ:
278: len = ARG(2);
279: if (use_gdb_syscalls()) {
280: arm_semi_syscall_len = len;
281: gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", ARG(0), ARG(1), len);
282: return env->regs[0];
283: } else {
284: s = lock_user(ARG(1), len, 0);
285: do
286: ret = set_swi_errno(ts, read(ARG(0), s, len));
287: while (ret == -1 && errno == EINTR);
288: unlock_user(s, ARG(1), len);
289: if (ret == (uint32_t)-1)
290: return -1;
291: return len - ret;
292: }
293: case SYS_READC:
294: /* XXX: Read from debug cosole. Not implemented. */
295: return 0;
296: case SYS_ISTTY:
297: if (use_gdb_syscalls()) {
298: gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0));
299: return env->regs[0];
300: } else {
301: return isatty(ARG(0));
302: }
303: case SYS_SEEK:
304: if (use_gdb_syscalls()) {
305: gdb_do_syscall(arm_semi_cb, "fseek,%x,%x,0", ARG(0), ARG(1));
306: return env->regs[0];
307: } else {
308: ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET));
309: if (ret == (uint32_t)-1)
310: return -1;
311: return 0;
312: }
313: case SYS_FLEN:
314: if (use_gdb_syscalls()) {
315: /* TODO: Use stat syscall. */
316: return -1;
317: } else {
318: struct stat buf;
319: ret = set_swi_errno(ts, fstat(ARG(0), &buf));
320: if (ret == (uint32_t)-1)
321: return -1;
322: return buf.st_size;
323: }
324: case SYS_TMPNAM:
325: /* XXX: Not implemented. */
326: return -1;
327: case SYS_REMOVE:
328: if (use_gdb_syscalls()) {
329: gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1));
330: ret = env->regs[0];
331: } else {
332: s = lock_user_string(ARG(0));
333: ret = set_swi_errno(ts, remove(s));
334: unlock_user(s, ARG(0), 0);
335: }
336: return ret;
337: case SYS_RENAME:
338: if (use_gdb_syscalls()) {
339: gdb_do_syscall(arm_semi_cb, "rename,%s,%s",
340: ARG(0), (int)ARG(1), ARG(2), (int)ARG(3));
341: return env->regs[0];
342: } else {
343: char *s2;
344: s = lock_user_string(ARG(0));
345: s2 = lock_user_string(ARG(2));
346: ret = set_swi_errno(ts, rename(s, s2));
347: unlock_user(s2, ARG(2), 0);
348: unlock_user(s, ARG(0), 0);
349: return ret;
350: }
351: case SYS_CLOCK:
352: return clock() / (CLOCKS_PER_SEC / 100);
353: case SYS_TIME:
354: return set_swi_errno(ts, time(NULL));
355: case SYS_SYSTEM:
356: if (use_gdb_syscalls()) {
357: gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1));
358: return env->regs[0];
359: } else {
360: s = lock_user_string(ARG(0));
361: ret = set_swi_errno(ts, system(s));
362: unlock_user(s, ARG(0), 0);
363: }
364: case SYS_ERRNO:
365: #ifdef CONFIG_USER_ONLY
366: return ts->swi_errno;
367: #else
368: return 0;
369: #endif
370: case SYS_GET_CMDLINE:
371: #ifdef CONFIG_USER_ONLY
372: /* Build a commandline from the original argv. */
373: {
374: char **arg = ts->info->host_argv;
375: int len = ARG(1);
376: /* lock the buffer on the ARM side */
377: char *cmdline_buffer = (char*)lock_user(ARG(0), len, 0);
378:
379: s = cmdline_buffer;
380: while (*arg && len > 2) {
381: int n = strlen(*arg);
382:
383: if (s != cmdline_buffer) {
384: *(s++) = ' ';
385: len--;
386: }
387: if (n >= len)
388: n = len - 1;
389: memcpy(s, *arg, n);
390: s += n;
391: len -= n;
392: arg++;
393: }
394: /* Null terminate the string. */
395: *s = 0;
396: len = s - cmdline_buffer;
397:
398: /* Unlock the buffer on the ARM side. */
399: unlock_user(cmdline_buffer, ARG(0), len);
400:
401: /* Adjust the commandline length argument. */
402: SET_ARG(1, len);
403:
404: /* Return success if commandline fit into buffer. */
405: return *arg ? -1 : 0;
406: }
407: #else
408: return -1;
409: #endif
410: case SYS_HEAPINFO:
411: {
412: uint32_t *ptr;
413: uint32_t limit;
414:
415: #ifdef CONFIG_USER_ONLY
416: /* Some C libraries assume the heap immediately follows .bss, so
417: allocate it using sbrk. */
418: if (!ts->heap_limit) {
419: long ret;
420:
421: ts->heap_base = do_brk(0);
422: limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
423: /* Try a big heap, and reduce the size if that fails. */
424: for (;;) {
425: ret = do_brk(limit);
426: if (ret != -1)
427: break;
428: limit = (ts->heap_base >> 1) + (limit >> 1);
429: }
430: ts->heap_limit = limit;
431: }
432:
433: ptr = lock_user(ARG(0), 16, 0);
434: ptr[0] = tswap32(ts->heap_base);
435: ptr[1] = tswap32(ts->heap_limit);
436: ptr[2] = tswap32(ts->stack_base);
437: ptr[3] = tswap32(0); /* Stack limit. */
438: unlock_user(ptr, ARG(0), 16);
439: #else
440: limit = ram_size;
441: ptr = lock_user(ARG(0), 16, 0);
442: /* TODO: Make this use the limit of the loaded application. */
443: ptr[0] = tswap32(limit / 2);
444: ptr[1] = tswap32(limit);
445: ptr[2] = tswap32(limit); /* Stack base */
446: ptr[3] = tswap32(0); /* Stack limit. */
447: unlock_user(ptr, ARG(0), 16);
448: #endif
449: return 0;
450: }
451: case SYS_EXIT:
452: exit(0);
453: default:
454: fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
455: cpu_dump_state(env, stderr, fprintf, 0);
456: abort();
457: }
458: }
unix.superglobalmegacorp.com
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to arm-semi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu