File:  [Qemu by Fabrice Bellard] / qemu / arm-semi.c
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 16:45:07 2018 UTC (19 months, 2 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu0090, HEAD
qemu 0.9.0

    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