m68k-semi.c

   1 /*
   2  *  m68k/ColdFire Semihosting syscall interface
   3  *
   4  *  Copyright (c) 2005-2007 CodeSourcery.
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <sys/time.h>
  29 #include <time.h>
  30
  31 #include "cpu.h"
  32 #if defined(CONFIG_USER_ONLY)
  33 #include "qemu.h"
  34 #define SEMIHOSTING_HEAP_SIZE (128 * 1024 * 1024)
  35 #else
  36 #include "qemu-common.h"
  37 #include "sysemu.h"
  38 #include "gdbstub.h"
  39 #include "softmmu-semi.h"
  40 #endif
  41
  42 #define HOSTED_EXIT  0
  43 #define HOSTED_INIT_SIM 1
  44 #define HOSTED_OPEN 2
  45 #define HOSTED_CLOSE 3
  46 #define HOSTED_READ 4
  47 #define HOSTED_WRITE 5
  48 #define HOSTED_LSEEK 6
  49 #define HOSTED_RENAME 7
  50 #define HOSTED_UNLINK 8
  51 #define HOSTED_STAT 9
  52 #define HOSTED_FSTAT 10
  53 #define HOSTED_GETTIMEOFDAY 11
  54 #define HOSTED_ISATTY 12
  55 #define HOSTED_SYSTEM 13
  56
  57 typedef uint32_t gdb_mode_t;
  58 typedef uint32_t gdb_time_t;
  59
  60 struct m68k_gdb_stat {
  61   uint32_t    gdb_st_dev;     /* device */
  62   uint32_t    gdb_st_ino;     /* inode */
  63   gdb_mode_t  gdb_st_mode;    /* protection */
  64   uint32_t    gdb_st_nlink;   /* number of hard links */
  65   uint32_t    gdb_st_uid;     /* user ID of owner */
  66   uint32_t    gdb_st_gid;     /* group ID of owner */
  67   uint32_t    gdb_st_rdev;    /* device type (if inode device) */
  68   uint64_t    gdb_st_size;    /* total size, in bytes */
  69   uint64_t    gdb_st_blksize; /* blocksize for filesystem I/O */
  70   uint64_t    gdb_st_blocks;  /* number of blocks allocated */
  71   gdb_time_t  gdb_st_atime;   /* time of last access */
  72   gdb_time_t  gdb_st_mtime;   /* time of last modification */
  73   gdb_time_t  gdb_st_ctime;   /* time of last change */
  74 } __attribute__((packed));
  75
  76 struct gdb_timeval {
  77   gdb_time_t tv_sec;  /* second */
  78   uint64_t tv_usec;   /* microsecond */
  79 } __attribute__((packed));
  80
  81 #define GDB_O_RDONLY   0x0
  82 #define GDB_O_WRONLY   0x1
  83 #define GDB_O_RDWR     0x2
  84 #define GDB_O_APPEND   0x8
  85 #define GDB_O_CREAT  0x200
  86 #define GDB_O_TRUNC  0x400
  87 #define GDB_O_EXCL   0x800
  88
  89 static int translate_openflags(int flags)
  90 {
  91     int hf;
  92
  93     if (flags & GDB_O_WRONLY)
  94         hf = O_WRONLY;
  95     else if (flags & GDB_O_RDWR)
  96         hf = O_RDWR;
  97     else
  98         hf = O_RDONLY;
  99
 100     if (flags & GDB_O_APPEND) hf |= O_APPEND;
 101     if (flags & GDB_O_CREAT) hf |= O_CREAT;
 102     if (flags & GDB_O_TRUNC) hf |= O_TRUNC;
 103     if (flags & GDB_O_EXCL) hf |= O_EXCL;
 104
 105     return hf;
 106 }
 107
 108 static void translate_stat(CPUState *env, target_ulong addr, struct stat *s)
 109 {
 110     struct m68k_gdb_stat *p;
 111
 112     if (!(p = lock_user(VERIFY_WRITE, addr, sizeof(struct m68k_gdb_stat), 0)))
 113         /* FIXME - should this return an error code? */
 114         return;
 115     p->gdb_st_dev = cpu_to_be32(s->st_dev);
 116     p->gdb_st_ino = cpu_to_be32(s->st_ino);
 117     p->gdb_st_mode = cpu_to_be32(s->st_mode);
 118     p->gdb_st_nlink = cpu_to_be32(s->st_nlink);
 119     p->gdb_st_uid = cpu_to_be32(s->st_uid);
 120     p->gdb_st_gid = cpu_to_be32(s->st_gid);
 121     p->gdb_st_rdev = cpu_to_be32(s->st_rdev);
 122     p->gdb_st_size = cpu_to_be64(s->st_size);
 123 #ifdef _WIN32
 124     /* Windows stat is missing some fields.  */
 125     p->gdb_st_blksize = 0;
 126     p->gdb_st_blocks = 0;
 127 #else
 128     p->gdb_st_blksize = cpu_to_be64(s->st_blksize);
 129     p->gdb_st_blocks = cpu_to_be64(s->st_blocks);
 130 #endif
 131     p->gdb_st_atime = cpu_to_be32(s->st_atime);
 132     p->gdb_st_mtime = cpu_to_be32(s->st_mtime);
 133     p->gdb_st_ctime = cpu_to_be32(s->st_ctime);
 134     unlock_user(p, addr, sizeof(struct m68k_gdb_stat));
 135 }
 136
 137 static int m68k_semi_is_fseek;
 138
 139 static void m68k_semi_cb(CPUState *env, target_ulong ret, target_ulong err)
 140 {
 141     target_ulong args;
 142
 143     args = env->dregs[1];
 144     if (m68k_semi_is_fseek) {
 145         /* FIXME: We've already lost the high bits of the fseek
 146            return value.  */
 147         /* FIXME - handle put_user() failure */
 148         put_user_u32(0, args);
 149         args += 4;
 150         m68k_semi_is_fseek = 0;
 151     }
 152     /* FIXME - handle put_user() failure */
 153     put_user_u32(ret, args);
 154     put_user_u32(errno, args + 4);
 155 }
 156
 157 #define ARG(n)                                  \
 158 ({                                              \
 159     target_ulong __arg;                         \
 160     /* FIXME - handle get_user() failure */     \
 161     get_user_ual(__arg, args + (n) * 4);        \
 162     __arg;                                      \
 163 })
 164 #define PARG(x) ((unsigned long)ARG(x))
 165 void do_m68k_semihosting(CPUM68KState *env, int nr)
 166 {
 167     uint32_t args;
 168     void *p;
 169     void *q;
 170     uint32_t len;
 171     uint32_t result;
 172
 173     args = env->dregs[1];
 174     switch (nr) {
 175     case HOSTED_EXIT:
 176         exit(env->dregs[0]);
 177     case HOSTED_OPEN:
 178         if (use_gdb_syscalls()) {
 179             gdb_do_syscall(m68k_semi_cb, "open,%s,%x,%x", ARG(0), (int)ARG(1),
 180                            ARG(2), ARG(3));
 181             return;
 182         } else {
 183             if (!(p = lock_user_string(ARG(0)))) {
 184                 /* FIXME - check error code? */
 185                 result = -1;
 186             } else {
 187                 result = open(p, translate_openflags(ARG(2)), ARG(3));
 188                 unlock_user(p, ARG(0), 0);
 189             }
 190         }
 191         break;
 192     case HOSTED_CLOSE:
 193         {
 194             /* Ignore attempts to close stdin/out/err.  */
 195             int fd = ARG(0);
 196             if (fd > 2) {
 197                 if (use_gdb_syscalls()) {
 198                     gdb_do_syscall(m68k_semi_cb, "close,%x", ARG(0));
 199                     return;
 200                 } else {
 201                     result = close(fd);
 202                 }
 203             } else {
 204                 result = 0;
 205             }
 206             break;
 207         }
 208     case HOSTED_READ:
 209         len = ARG(2);
 210         if (use_gdb_syscalls()) {
 211             gdb_do_syscall(m68k_semi_cb, "read,%x,%x,%x",
 212                            ARG(0), ARG(1), len);
 213             return;
 214         } else {
 215             if (!(p = lock_user(VERIFY_WRITE, ARG(1), len, 0))) {
 216                 /* FIXME - check error code? */
 217                 result = -1;
 218             } else {
 219                 result = read(ARG(0), p, len);
 220                 unlock_user(p, ARG(1), len);
 221             }
 222         }
 223         break;
 224     case HOSTED_WRITE:
 225         len = ARG(2);
 226         if (use_gdb_syscalls()) {
 227             gdb_do_syscall(m68k_semi_cb, "write,%x,%x,%x",
 228                            ARG(0), ARG(1), len);
 229             return;
 230         } else {
 231             if (!(p = lock_user(VERIFY_READ, ARG(1), len, 1))) {
 232                 /* FIXME - check error code? */
 233                 result = -1;
 234             } else {
 235                 result = write(ARG(0), p, len);
 236                 unlock_user(p, ARG(0), 0);
 237             }
 238         }
 239         break;
 240     case HOSTED_LSEEK:
 241         {
 242             uint64_t off;
 243             off = (uint32_t)ARG(2) | ((uint64_t)ARG(1) << 32);
 244             if (use_gdb_syscalls()) {
 245                 m68k_semi_is_fseek = 1;
 246                 gdb_do_syscall(m68k_semi_cb, "fseek,%x,%lx,%x",
 247                                ARG(0), off, ARG(3));
 248             } else {
 249                 off = lseek(ARG(0), off, ARG(3));
 250                 /* FIXME - handle put_user() failure */
 251                 put_user_u32(off >> 32, args);
 252                 put_user_u32(off, args + 4);
 253                 put_user_u32(errno, args + 8);
 254             }
 255             return;
 256         }
 257     case HOSTED_RENAME:
 258         if (use_gdb_syscalls()) {
 259             gdb_do_syscall(m68k_semi_cb, "rename,%s,%s",
 260                            ARG(0), (int)ARG(1), ARG(2), (int)ARG(3));
 261             return;
 262         } else {
 263             p = lock_user_string(ARG(0));
 264             q = lock_user_string(ARG(2));
 265             if (!p || !q) {
 266                 /* FIXME - check error code? */
 267                 result = -1;
 268             } else {
 269                 result = rename(p, q);
 270             }
 271             unlock_user(p, ARG(0), 0);
 272             unlock_user(q, ARG(2), 0);
 273         }
 274         break;
 275     case HOSTED_UNLINK:
 276         if (use_gdb_syscalls()) {
 277             gdb_do_syscall(m68k_semi_cb, "unlink,%s",
 278                            ARG(0), (int)ARG(1));
 279             return;
 280         } else {
 281             if (!(p = lock_user_string(ARG(0)))) {
 282                 /* FIXME - check error code? */
 283                 result = -1;
 284             } else {
 285                 result = unlink(p);
 286                 unlock_user(p, ARG(0), 0);
 287             }
 288         }
 289         break;
 290     case HOSTED_STAT:
 291         if (use_gdb_syscalls()) {
 292             gdb_do_syscall(m68k_semi_cb, "stat,%s,%x",
 293                            ARG(0), (int)ARG(1), ARG(2));
 294             return;
 295         } else {
 296             struct stat s;
 297             if (!(p = lock_user_string(ARG(0)))) {
 298                 /* FIXME - check error code? */
 299                 result = -1;
 300             } else {
 301                 result = stat(p, &s);
 302                 unlock_user(p, ARG(0), 0);
 303             }
 304             if (result == 0) {
 305                 translate_stat(env, ARG(2), &s);
 306             }
 307         }
 308         break;
 309     case HOSTED_FSTAT:
 310         if (use_gdb_syscalls()) {
 311             gdb_do_syscall(m68k_semi_cb, "fstat,%x,%x",
 312                            ARG(0), ARG(1));
 313             return;
 314         } else {
 315             struct stat s;
 316             result = fstat(ARG(0), &s);
 317             if (result == 0) {
 318                 translate_stat(env, ARG(1), &s);
 319             }
 320         }
 321         break;
 322     case HOSTED_GETTIMEOFDAY:
 323         if (use_gdb_syscalls()) {
 324             gdb_do_syscall(m68k_semi_cb, "gettimeofday,%x,%x",
 325                            ARG(0), ARG(1));
 326             return;
 327         } else {
 328             qemu_timeval tv;
 329             struct gdb_timeval *p;
 330             result = qemu_gettimeofday(&tv);
 331             if (result != 0) {
 332                 if (!(p = lock_user(VERIFY_WRITE,
 333                                     ARG(0), sizeof(struct gdb_timeval), 0))) {
 334                     /* FIXME - check error code? */
 335                     result = -1;
 336                 } else {
 337                     p->tv_sec = cpu_to_be32(tv.tv_sec);
 338                     p->tv_usec = cpu_to_be64(tv.tv_usec);
 339                     unlock_user(p, ARG(0), sizeof(struct gdb_timeval));
 340                 }
 341             }
 342         }
 343         break;
 344     case HOSTED_ISATTY:
 345         if (use_gdb_syscalls()) {
 346             gdb_do_syscall(m68k_semi_cb, "isatty,%x", ARG(0));
 347             return;
 348         } else {
 349             result = isatty(ARG(0));
 350         }
 351         break;
 352     case HOSTED_SYSTEM:
 353         if (use_gdb_syscalls()) {
 354             gdb_do_syscall(m68k_semi_cb, "system,%s",
 355                            ARG(0), (int)ARG(1));
 356             return;
 357         } else {
 358             if (!(p = lock_user_string(ARG(0)))) {
 359                 /* FIXME - check error code? */
 360                 result = -1;
 361             } else {
 362                 result = system(p);
 363                 unlock_user(p, ARG(0), 0);
 364             }
 365         }
 366         break;
 367     case HOSTED_INIT_SIM:
 368 #if defined(CONFIG_USER_ONLY)
 369         {
 370         TaskState *ts = env->opaque;
 371         /* Allocate the heap using sbrk.  */
 372         if (!ts->heap_limit) {
 373             long ret;
 374             uint32_t size;
 375             uint32_t base;
 376
 377             base = do_brk(0);
 378             size = SEMIHOSTING_HEAP_SIZE;
 379             /* Try a big heap, and reduce the size if that fails.  */
 380             for (;;) {
 381                 ret = do_brk(base + size);
 382                 if (ret != -1)
 383                     break;
 384                 size >>= 1;
 385             }
 386             ts->heap_limit = base + size;
 387         }
 388         /* This call may happen before we have writable memory, so return
 389            values directly in registers.  */
 390         env->dregs[1] = ts->heap_limit;
 391         env->aregs[7] = ts->stack_base;
 392         }
 393 #else
 394         /* FIXME: This is wrong for boards where RAM does not start at
 395            address zero.  */
 396         env->dregs[1] = ram_size;
 397         env->aregs[7] = ram_size;
 398 #endif
 399         return;
 400     default:
 401         cpu_abort(env, "Unsupported semihosting syscall %d\n", nr);
 402         result = 0;
 403     }
 404     /* FIXME - handle put_user() failure */
 405     put_user_u32(result, args);
 406     put_user_u32(errno, args + 4);
 407 }