target-lm32/lm32-semi.c

   1 /*
   2  *  Lattice Mico32 semihosting syscall interface
   3  *
   4  *  Copyright (c) 2014 Michael Walle <michael@walle.cc>
   5  *
   6  * Based on target-m68k/m68k-semi.c, which is
   7  *  Copyright (c) 2005-2007 CodeSourcery.
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "cpu.h"
  15 #include "exec/helper-proto.h"
  16 #include "qemu/log.h"
  17 #include "exec/softmmu-semi.h"
  18
  19 enum {
  20     TARGET_SYS_exit    = 1,
  21     TARGET_SYS_open    = 2,
  22     TARGET_SYS_close   = 3,
  23     TARGET_SYS_read    = 4,
  24     TARGET_SYS_write   = 5,
  25     TARGET_SYS_lseek   = 6,
  26     TARGET_SYS_fstat   = 10,
  27     TARGET_SYS_stat    = 15,
  28 };
  29
  30 enum {
  31     NEWLIB_O_RDONLY    =   0x0,
  32     NEWLIB_O_WRONLY    =   0x1,
  33     NEWLIB_O_RDWR      =   0x2,
  34     NEWLIB_O_APPEND    =   0x8,
  35     NEWLIB_O_CREAT     = 0x200,
  36     NEWLIB_O_TRUNC     = 0x400,
  37     NEWLIB_O_EXCL      = 0x800,
  38 };
  39
  40 static int translate_openflags(int flags)
  41 {
  42     int hf;
  43
  44     if (flags & NEWLIB_O_WRONLY) {
  45         hf = O_WRONLY;
  46     } else if (flags & NEWLIB_O_RDWR) {
  47         hf = O_RDWR;
  48     } else {
  49         hf = O_RDONLY;
  50     }
  51
  52     if (flags & NEWLIB_O_APPEND) {
  53         hf |= O_APPEND;
  54     }
  55
  56     if (flags & NEWLIB_O_CREAT) {
  57         hf |= O_CREAT;
  58     }
  59
  60     if (flags & NEWLIB_O_TRUNC) {
  61         hf |= O_TRUNC;
  62     }
  63
  64     if (flags & NEWLIB_O_EXCL) {
  65         hf |= O_EXCL;
  66     }
  67
  68     return hf;
  69 }
  70
  71 struct newlib_stat {
  72     int16_t     newlib_st_dev;     /* device */
  73     uint16_t    newlib_st_ino;     /* inode */
  74     uint16_t    newlib_st_mode;    /* protection */
  75     uint16_t    newlib_st_nlink;   /* number of hard links */
  76     uint16_t    newlib_st_uid;     /* user ID of owner */
  77     uint16_t    newlib_st_gid;     /* group ID of owner */
  78     int16_t     newlib_st_rdev;    /* device type (if inode device) */
  79     int32_t     newlib_st_size;    /* total size, in bytes */
  80     int32_t     newlib_st_atime;   /* time of last access */
  81     uint32_t    newlib_st_spare1;
  82     int32_t     newlib_st_mtime;   /* time of last modification */
  83     uint32_t    newlib_st_spare2;
  84     int32_t     newlib_st_ctime;   /* time of last change */
  85     uint32_t    newlib_st_spare3;
  86 } QEMU_PACKED;
  87
  88 static int translate_stat(CPULM32State *env, target_ulong addr,
  89         struct stat *s)
  90 {
  91     struct newlib_stat *p;
  92
  93     p = lock_user(VERIFY_WRITE, addr, sizeof(struct newlib_stat), 0);
  94     if (!p) {
  95         return 0;
  96     }
  97     p->newlib_st_dev = cpu_to_be16(s->st_dev);
  98     p->newlib_st_ino = cpu_to_be16(s->st_ino);
  99     p->newlib_st_mode = cpu_to_be16(s->st_mode);
 100     p->newlib_st_nlink = cpu_to_be16(s->st_nlink);
 101     p->newlib_st_uid = cpu_to_be16(s->st_uid);
 102     p->newlib_st_gid = cpu_to_be16(s->st_gid);
 103     p->newlib_st_rdev = cpu_to_be16(s->st_rdev);
 104     p->newlib_st_size = cpu_to_be32(s->st_size);
 105     p->newlib_st_atime = cpu_to_be32(s->st_atime);
 106     p->newlib_st_mtime = cpu_to_be32(s->st_mtime);
 107     p->newlib_st_ctime = cpu_to_be32(s->st_ctime);
 108     unlock_user(p, addr, sizeof(struct newlib_stat));
 109
 110     return 1;
 111 }
 112
 113 bool lm32_cpu_do_semihosting(CPUState *cs)
 114 {
 115     LM32CPU *cpu = LM32_CPU(cs);
 116     CPULM32State *env = &cpu->env;
 117
 118     int ret = -1;
 119     target_ulong nr, arg0, arg1, arg2;
 120     void *p;
 121     struct stat s;
 122
 123     nr = env->regs[R_R8];
 124     arg0 = env->regs[R_R1];
 125     arg1 = env->regs[R_R2];
 126     arg2 = env->regs[R_R3];
 127
 128     switch (nr) {
 129     case TARGET_SYS_exit:
 130         /* void _exit(int rc) */
 131         exit(arg0);
 132
 133     case TARGET_SYS_open:
 134         /* int open(const char *pathname, int flags) */
 135         p = lock_user_string(arg0);
 136         if (!p) {
 137             ret = -1;
 138         } else {
 139             ret = open(p, translate_openflags(arg2));
 140             unlock_user(p, arg0, 0);
 141         }
 142         break;
 143
 144     case TARGET_SYS_read:
 145         /* ssize_t read(int fd, const void *buf, size_t count) */
 146         p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
 147         if (!p) {
 148             ret = -1;
 149         } else {
 150             ret = read(arg0, p, arg2);
 151             unlock_user(p, arg1, arg2);
 152         }
 153         break;
 154
 155     case TARGET_SYS_write:
 156         /* ssize_t write(int fd, const void *buf, size_t count) */
 157         p = lock_user(VERIFY_READ, arg1, arg2, 1);
 158         if (!p) {
 159             ret = -1;
 160         } else {
 161             ret = write(arg0, p, arg2);
 162             unlock_user(p, arg1, 0);
 163         }
 164         break;
 165
 166     case TARGET_SYS_close:
 167         /* int close(int fd) */
 168         /* don't close stdin/stdout/stderr */
 169         if (arg0 > 2) {
 170             ret = close(arg0);
 171         } else {
 172             ret = 0;
 173         }
 174         break;
 175
 176     case TARGET_SYS_lseek:
 177         /* off_t lseek(int fd, off_t offset, int whence */
 178         ret = lseek(arg0, arg1, arg2);
 179         break;
 180
 181     case TARGET_SYS_stat:
 182         /* int stat(const char *path, struct stat *buf) */
 183         p = lock_user_string(arg0);
 184         if (!p) {
 185             ret = -1;
 186         } else {
 187             ret = stat(p, &s);
 188             unlock_user(p, arg0, 0);
 189             if (translate_stat(env, arg1, &s) == 0) {
 190                 ret = -1;
 191             }
 192         }
 193         break;
 194
 195     case TARGET_SYS_fstat:
 196         /* int stat(int fd, struct stat *buf) */
 197         ret = fstat(arg0, &s);
 198         if (ret == 0) {
 199             if (translate_stat(env, arg1, &s) == 0) {
 200                 ret = -1;
 201             }
 202         }
 203         break;
 204
 205     default:
 206         /* unhandled */
 207         return false;
 208     }
 209
 210     env->regs[R_R1] = ret;
 211     return true;
 212 }