Annotation of qemu/arm-semi.c, revision 1.1.1.1

1.1       root        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