target-arm/arm-semi.c

   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, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <time.h>
  28
  29 #include "cpu.h"
  30 #ifdef CONFIG_USER_ONLY
  31 #include "qemu.h"
  32
  33 #define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024)
  34 #else
  35 #include "qemu-common.h"
  36 #include "exec/gdbstub.h"
  37 #include "hw/arm/arm.h"
  38 #endif
  39
  40 #define TARGET_SYS_OPEN        0x01
  41 #define TARGET_SYS_CLOSE       0x02
  42 #define TARGET_SYS_WRITEC      0x03
  43 #define TARGET_SYS_WRITE0      0x04
  44 #define TARGET_SYS_WRITE       0x05
  45 #define TARGET_SYS_READ        0x06
  46 #define TARGET_SYS_READC       0x07
  47 #define TARGET_SYS_ISTTY       0x09
  48 #define TARGET_SYS_SEEK        0x0a
  49 #define TARGET_SYS_FLEN        0x0c
  50 #define TARGET_SYS_TMPNAM      0x0d
  51 #define TARGET_SYS_REMOVE      0x0e
  52 #define TARGET_SYS_RENAME      0x0f
  53 #define TARGET_SYS_CLOCK       0x10
  54 #define TARGET_SYS_TIME        0x11
  55 #define TARGET_SYS_SYSTEM      0x12
  56 #define TARGET_SYS_ERRNO       0x13
  57 #define TARGET_SYS_GET_CMDLINE 0x15
  58 #define TARGET_SYS_HEAPINFO    0x16
  59 #define TARGET_SYS_EXIT        0x18
  60
  61 #ifndef O_BINARY
  62 #define O_BINARY 0
  63 #endif
  64
  65 #define GDB_O_RDONLY  0x000
  66 #define GDB_O_WRONLY  0x001
  67 #define GDB_O_RDWR    0x002
  68 #define GDB_O_APPEND  0x008
  69 #define GDB_O_CREAT   0x200
  70 #define GDB_O_TRUNC   0x400
  71 #define GDB_O_BINARY  0
  72
  73 static int gdb_open_modeflags[12] = {
  74     GDB_O_RDONLY,
  75     GDB_O_RDONLY | GDB_O_BINARY,
  76     GDB_O_RDWR,
  77     GDB_O_RDWR | GDB_O_BINARY,
  78     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC,
  79     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
  80     GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC,
  81     GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
  82     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND,
  83     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY,
  84     GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND,
  85     GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY
  86 };
  87
  88 static int open_modeflags[12] = {
  89     O_RDONLY,
  90     O_RDONLY | O_BINARY,
  91     O_RDWR,
  92     O_RDWR | O_BINARY,
  93     O_WRONLY | O_CREAT | O_TRUNC,
  94     O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
  95     O_RDWR | O_CREAT | O_TRUNC,
  96     O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
  97     O_WRONLY | O_CREAT | O_APPEND,
  98     O_WRONLY | O_CREAT | O_APPEND | O_BINARY,
  99     O_RDWR | O_CREAT | O_APPEND,
 100     O_RDWR | O_CREAT | O_APPEND | O_BINARY
 101 };
 102
 103 #ifdef CONFIG_USER_ONLY
 104 static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
 105 {
 106     if (code == (uint32_t)-1)
 107         ts->swi_errno = errno;
 108     return code;
 109 }
 110 #else
 111 static inline uint32_t set_swi_errno(CPUARMState *env, uint32_t code)
 112 {
 113     return code;
 114 }
 115
 116 #include "exec/softmmu-semi.h"
 117 #endif
 118
 119 static target_ulong arm_semi_syscall_len;
 120
 121 #if !defined(CONFIG_USER_ONLY)
 122 static target_ulong syscall_err;
 123 #endif
 124
 125 static void arm_semi_cb(CPUState *cs, target_ulong ret, target_ulong err)
 126 {
 127     ARMCPU *cpu = ARM_CPU(cs);
 128     CPUARMState *env = &cpu->env;
 129 #ifdef CONFIG_USER_ONLY
 130     TaskState *ts = cs->opaque;
 131 #endif
 132
 133     if (ret == (target_ulong)-1) {
 134 #ifdef CONFIG_USER_ONLY
 135         ts->swi_errno = err;
 136 #else
 137         syscall_err = err;
 138 #endif
 139         env->regs[0] = ret;
 140     } else {
 141         /* Fixup syscalls that use nonstardard return conventions.  */
 142         switch (env->regs[0]) {
 143         case TARGET_SYS_WRITE:
 144         case TARGET_SYS_READ:
 145             env->regs[0] = arm_semi_syscall_len - ret;
 146             break;
 147         case TARGET_SYS_SEEK:
 148             env->regs[0] = 0;
 149             break;
 150         default:
 151             env->regs[0] = ret;
 152             break;
 153         }
 154     }
 155 }
 156
 157 static void arm_semi_flen_cb(CPUState *cs, target_ulong ret, target_ulong err)
 158 {
 159     ARMCPU *cpu = ARM_CPU(cs);
 160     CPUARMState *env = &cpu->env;
 161     /* The size is always stored in big-endian order, extract
 162        the value. We assume the size always fit in 32 bits.  */
 163     uint32_t size;
 164     cpu_memory_rw_debug(cs, env->regs[13]-64+32, (uint8_t *)&size, 4, 0);
 165     env->regs[0] = be32_to_cpu(size);
 166 #ifdef CONFIG_USER_ONLY
 167     ((TaskState *)cs->opaque)->swi_errno = err;
 168 #else
 169     syscall_err = err;
 170 #endif
 171 }
 172
 173 /* Read the input value from the argument block; fail the semihosting
 174  * call if the memory read fails.
 175  */
 176 #define GET_ARG(n) do {                                 \
 177     if (get_user_ual(arg ## n, args + (n) * 4)) {       \
 178         return (uint32_t)-1;                            \
 179     }                                                   \
 180 } while (0)
 181
 182 #define SET_ARG(n, val) put_user_ual(val, args + (n) * 4)
 183 uint32_t do_arm_semihosting(CPUARMState *env)
 184 {
 185     ARMCPU *cpu = arm_env_get_cpu(env);
 186     CPUState *cs = CPU(cpu);
 187     target_ulong args;
 188     target_ulong arg0, arg1, arg2, arg3;
 189     char * s;
 190     int nr;
 191     uint32_t ret;
 192     uint32_t len;
 193 #ifdef CONFIG_USER_ONLY
 194     TaskState *ts = cs->opaque;
 195 #else
 196     CPUARMState *ts = env;
 197 #endif
 198
 199     nr = env->regs[0];
 200     args = env->regs[1];
 201     switch (nr) {
 202     case TARGET_SYS_OPEN:
 203         GET_ARG(0);
 204         GET_ARG(1);
 205         GET_ARG(2);
 206         s = lock_user_string(arg0);
 207         if (!s) {
 208             /* FIXME - should this error code be -TARGET_EFAULT ? */
 209             return (uint32_t)-1;
 210         }
 211         if (arg1 >= 12) {
 212             unlock_user(s, arg0, 0);
 213             return (uint32_t)-1;
 214         }
 215         if (strcmp(s, ":tt") == 0) {
 216             int result_fileno = arg1 < 4 ? STDIN_FILENO : STDOUT_FILENO;
 217             unlock_user(s, arg0, 0);
 218             return result_fileno;
 219         }
 220         if (use_gdb_syscalls()) {
 221             gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", arg0,
 222                            (int)arg2+1, gdb_open_modeflags[arg1]);
 223             ret = env->regs[0];
 224         } else {
 225             ret = set_swi_errno(ts, open(s, open_modeflags[arg1], 0644));
 226         }
 227         unlock_user(s, arg0, 0);
 228         return ret;
 229     case TARGET_SYS_CLOSE:
 230         GET_ARG(0);
 231         if (use_gdb_syscalls()) {
 232             gdb_do_syscall(arm_semi_cb, "close,%x", arg0);
 233             return env->regs[0];
 234         } else {
 235             return set_swi_errno(ts, close(arg0));
 236         }
 237     case TARGET_SYS_WRITEC:
 238         {
 239           char c;
 240
 241           if (get_user_u8(c, args))
 242               /* FIXME - should this error code be -TARGET_EFAULT ? */
 243               return (uint32_t)-1;
 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 TARGET_SYS_WRITE0:
 253         if (!(s = lock_user_string(args)))
 254             /* FIXME - should this error code be -TARGET_EFAULT ? */
 255             return (uint32_t)-1;
 256         len = strlen(s);
 257         if (use_gdb_syscalls()) {
 258             gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len);
 259             ret = env->regs[0];
 260         } else {
 261             ret = write(STDERR_FILENO, s, len);
 262         }
 263         unlock_user(s, args, 0);
 264         return ret;
 265     case TARGET_SYS_WRITE:
 266         GET_ARG(0);
 267         GET_ARG(1);
 268         GET_ARG(2);
 269         len = arg2;
 270         if (use_gdb_syscalls()) {
 271             arm_semi_syscall_len = len;
 272             gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", arg0, arg1, len);
 273             return env->regs[0];
 274         } else {
 275             s = lock_user(VERIFY_READ, arg1, len, 1);
 276             if (!s) {
 277                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 278                 return (uint32_t)-1;
 279             }
 280             ret = set_swi_errno(ts, write(arg0, s, len));
 281             unlock_user(s, arg1, 0);
 282             if (ret == (uint32_t)-1)
 283                 return -1;
 284             return len - ret;
 285         }
 286     case TARGET_SYS_READ:
 287         GET_ARG(0);
 288         GET_ARG(1);
 289         GET_ARG(2);
 290         len = arg2;
 291         if (use_gdb_syscalls()) {
 292             arm_semi_syscall_len = len;
 293             gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", arg0, arg1, len);
 294             return env->regs[0];
 295         } else {
 296             s = lock_user(VERIFY_WRITE, arg1, len, 0);
 297             if (!s) {
 298                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 299                 return (uint32_t)-1;
 300             }
 301             do {
 302                 ret = set_swi_errno(ts, read(arg0, s, len));
 303             } while (ret == -1 && errno == EINTR);
 304             unlock_user(s, arg1, len);
 305             if (ret == (uint32_t)-1)
 306                 return -1;
 307             return len - ret;
 308         }
 309     case TARGET_SYS_READC:
 310        /* XXX: Read from debug console. Not implemented.  */
 311         return 0;
 312     case TARGET_SYS_ISTTY:
 313         GET_ARG(0);
 314         if (use_gdb_syscalls()) {
 315             gdb_do_syscall(arm_semi_cb, "isatty,%x", arg0);
 316             return env->regs[0];
 317         } else {
 318             return isatty(arg0);
 319         }
 320     case TARGET_SYS_SEEK:
 321         GET_ARG(0);
 322         GET_ARG(1);
 323         if (use_gdb_syscalls()) {
 324             gdb_do_syscall(arm_semi_cb, "lseek,%x,%x,0", arg0, arg1);
 325             return env->regs[0];
 326         } else {
 327             ret = set_swi_errno(ts, lseek(arg0, arg1, SEEK_SET));
 328             if (ret == (uint32_t)-1)
 329               return -1;
 330             return 0;
 331         }
 332     case TARGET_SYS_FLEN:
 333         GET_ARG(0);
 334         if (use_gdb_syscalls()) {
 335             gdb_do_syscall(arm_semi_flen_cb, "fstat,%x,%x",
 336                            arg0, env->regs[13]-64);
 337             return env->regs[0];
 338         } else {
 339             struct stat buf;
 340             ret = set_swi_errno(ts, fstat(arg0, &buf));
 341             if (ret == (uint32_t)-1)
 342                 return -1;
 343             return buf.st_size;
 344         }
 345     case TARGET_SYS_TMPNAM:
 346         /* XXX: Not implemented.  */
 347         return -1;
 348     case TARGET_SYS_REMOVE:
 349         GET_ARG(0);
 350         GET_ARG(1);
 351         if (use_gdb_syscalls()) {
 352             gdb_do_syscall(arm_semi_cb, "unlink,%s", arg0, (int)arg1+1);
 353             ret = env->regs[0];
 354         } else {
 355             s = lock_user_string(arg0);
 356             if (!s) {
 357                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 358                 return (uint32_t)-1;
 359             }
 360             ret =  set_swi_errno(ts, remove(s));
 361             unlock_user(s, arg0, 0);
 362         }
 363         return ret;
 364     case TARGET_SYS_RENAME:
 365         GET_ARG(0);
 366         GET_ARG(1);
 367         GET_ARG(2);
 368         GET_ARG(3);
 369         if (use_gdb_syscalls()) {
 370             gdb_do_syscall(arm_semi_cb, "rename,%s,%s",
 371                            arg0, (int)arg1+1, arg2, (int)arg3+1);
 372             return env->regs[0];
 373         } else {
 374             char *s2;
 375             s = lock_user_string(arg0);
 376             s2 = lock_user_string(arg2);
 377             if (!s || !s2)
 378                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 379                 ret = (uint32_t)-1;
 380             else
 381                 ret = set_swi_errno(ts, rename(s, s2));
 382             if (s2)
 383                 unlock_user(s2, arg2, 0);
 384             if (s)
 385                 unlock_user(s, arg0, 0);
 386             return ret;
 387         }
 388     case TARGET_SYS_CLOCK:
 389         return clock() / (CLOCKS_PER_SEC / 100);
 390     case TARGET_SYS_TIME:
 391         return set_swi_errno(ts, time(NULL));
 392     case TARGET_SYS_SYSTEM:
 393         GET_ARG(0);
 394         GET_ARG(1);
 395         if (use_gdb_syscalls()) {
 396             gdb_do_syscall(arm_semi_cb, "system,%s", arg0, (int)arg1+1);
 397             return env->regs[0];
 398         } else {
 399             s = lock_user_string(arg0);
 400             if (!s) {
 401                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 402                 return (uint32_t)-1;
 403             }
 404             ret = set_swi_errno(ts, system(s));
 405             unlock_user(s, arg0, 0);
 406             return ret;
 407         }
 408     case TARGET_SYS_ERRNO:
 409 #ifdef CONFIG_USER_ONLY
 410         return ts->swi_errno;
 411 #else
 412         return syscall_err;
 413 #endif
 414     case TARGET_SYS_GET_CMDLINE:
 415         {
 416             /* Build a command-line from the original argv.
 417              *
 418              * The inputs are:
 419              *     * arg0, pointer to a buffer of at least the size
 420              *               specified in arg1.
 421              *     * arg1, size of the buffer pointed to by arg0 in
 422              *               bytes.
 423              *
 424              * The outputs are:
 425              *     * arg0, pointer to null-terminated string of the
 426              *               command line.
 427              *     * arg1, length of the string pointed to by arg0.
 428              */
 429
 430             char *output_buffer;
 431             size_t input_size;
 432             size_t output_size;
 433             int status = 0;
 434             GET_ARG(0);
 435             GET_ARG(1);
 436             input_size = arg1;
 437             /* Compute the size of the output string.  */
 438 #if !defined(CONFIG_USER_ONLY)
 439             output_size = strlen(ts->boot_info->kernel_filename)
 440                         + 1  /* Separating space.  */
 441                         + strlen(ts->boot_info->kernel_cmdline)
 442                         + 1; /* Terminating null byte.  */
 443 #else
 444             unsigned int i;
 445
 446             output_size = ts->info->arg_end - ts->info->arg_start;
 447             if (!output_size) {
 448                 /* We special-case the "empty command line" case (argc==0).
 449                    Just provide the terminating 0. */
 450                 output_size = 1;
 451             }
 452 #endif
 453
 454             if (output_size > input_size) {
 455                  /* Not enough space to store command-line arguments.  */
 456                 return -1;
 457             }
 458
 459             /* Adjust the command-line length.  */
 460             if (SET_ARG(1, output_size - 1)) {
 461                 /* Couldn't write back to argument block */
 462                 return -1;
 463             }
 464
 465             /* Lock the buffer on the ARM side.  */
 466             output_buffer = lock_user(VERIFY_WRITE, arg0, output_size, 0);
 467             if (!output_buffer) {
 468                 return -1;
 469             }
 470
 471             /* Copy the command-line arguments.  */
 472 #if !defined(CONFIG_USER_ONLY)
 473             pstrcpy(output_buffer, output_size, ts->boot_info->kernel_filename);
 474             pstrcat(output_buffer, output_size, " ");
 475             pstrcat(output_buffer, output_size, ts->boot_info->kernel_cmdline);
 476 #else
 477             if (output_size == 1) {
 478                 /* Empty command-line.  */
 479                 output_buffer[0] = '\0';
 480                 goto out;
 481             }
 482
 483             if (copy_from_user(output_buffer, ts->info->arg_start,
 484                                output_size)) {
 485                 status = -1;
 486                 goto out;
 487             }
 488
 489             /* Separate arguments by white spaces.  */
 490             for (i = 0; i < output_size - 1; i++) {
 491                 if (output_buffer[i] == 0) {
 492                     output_buffer[i] = ' ';
 493                 }
 494             }
 495         out:
 496 #endif
 497             /* Unlock the buffer on the ARM side.  */
 498             unlock_user(output_buffer, arg0, output_size);
 499
 500             return status;
 501         }
 502     case TARGET_SYS_HEAPINFO:
 503         {
 504             uint32_t *ptr;
 505             uint32_t limit;
 506             GET_ARG(0);
 507
 508 #ifdef CONFIG_USER_ONLY
 509             /* Some C libraries assume the heap immediately follows .bss, so
 510                allocate it using sbrk.  */
 511             if (!ts->heap_limit) {
 512                 abi_ulong ret;
 513
 514                 ts->heap_base = do_brk(0);
 515                 limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
 516                 /* Try a big heap, and reduce the size if that fails.  */
 517                 for (;;) {
 518                     ret = do_brk(limit);
 519                     if (ret >= limit) {
 520                         break;
 521                     }
 522                     limit = (ts->heap_base >> 1) + (limit >> 1);
 523                 }
 524                 ts->heap_limit = limit;
 525             }
 526
 527             ptr = lock_user(VERIFY_WRITE, arg0, 16, 0);
 528             if (!ptr) {
 529                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 530                 return (uint32_t)-1;
 531             }
 532             ptr[0] = tswap32(ts->heap_base);
 533             ptr[1] = tswap32(ts->heap_limit);
 534             ptr[2] = tswap32(ts->stack_base);
 535             ptr[3] = tswap32(0); /* Stack limit.  */
 536             unlock_user(ptr, arg0, 16);
 537 #else
 538             limit = ram_size;
 539             ptr = lock_user(VERIFY_WRITE, arg0, 16, 0);
 540             if (!ptr) {
 541                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 542                 return (uint32_t)-1;
 543             }
 544             /* TODO: Make this use the limit of the loaded application.  */
 545             ptr[0] = tswap32(limit / 2);
 546             ptr[1] = tswap32(limit);
 547             ptr[2] = tswap32(limit); /* Stack base */
 548             ptr[3] = tswap32(0); /* Stack limit.  */
 549             unlock_user(ptr, arg0, 16);
 550 #endif
 551             return 0;
 552         }
 553     case TARGET_SYS_EXIT:
 554         gdb_exit(env, 0);
 555         exit(0);
 556     default:
 557         fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
 558         cpu_dump_state(cs, stderr, fprintf, 0);
 559         abort();
 560     }
 561 }