arm-semi.c 14.1 KB
Newer Older
1 2
/*
 *  Arm "Angel" semihosting syscalls
3
 *
4 5
 *  Copyright (c) 2005, 2007 CodeSourcery.
 *  Written by Paul Brook.
6 7 8 9 10 11 12 13 14 15 16 17
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  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 22 23 24 25 26 27 28
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

29 30
#include "cpu.h"
#ifdef CONFIG_USER_ONLY
31 32 33
#include "qemu.h"

#define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024)
34
#else
pbrook's avatar
pbrook committed
35 36 37
#include "qemu-common.h"
#include "sysemu.h"
#include "gdbstub.h"
38
#endif
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

#define SYS_OPEN        0x01
#define SYS_CLOSE       0x02
#define SYS_WRITEC      0x03
#define SYS_WRITE0      0x04
#define SYS_WRITE       0x05
#define SYS_READ        0x06
#define SYS_READC       0x07
#define SYS_ISTTY       0x09
#define SYS_SEEK        0x0a
#define SYS_FLEN        0x0c
#define SYS_TMPNAM      0x0d
#define SYS_REMOVE      0x0e
#define SYS_RENAME      0x0f
#define SYS_CLOCK       0x10
#define SYS_TIME        0x11
#define SYS_SYSTEM      0x12
#define SYS_ERRNO       0x13
#define SYS_GET_CMDLINE 0x15
#define SYS_HEAPINFO    0x16
#define SYS_EXIT        0x18

#ifndef O_BINARY
#define O_BINARY 0
#endif

pbrook's avatar
pbrook committed
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
#define GDB_O_RDONLY  0x000
#define GDB_O_WRONLY  0x001
#define GDB_O_RDWR    0x002
#define GDB_O_APPEND  0x008
#define GDB_O_CREAT   0x200
#define GDB_O_TRUNC   0x400
#define GDB_O_BINARY  0

static int gdb_open_modeflags[12] = {
    GDB_O_RDONLY,
    GDB_O_RDONLY | GDB_O_BINARY,
    GDB_O_RDWR,
    GDB_O_RDWR | GDB_O_BINARY,
    GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC,
    GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
    GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC,
    GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
    GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND,
    GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY,
    GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND,
    GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY
};

static int open_modeflags[12] = {
89 90 91 92 93 94 95 96 97 98 99 100 101 102
    O_RDONLY,
    O_RDONLY | O_BINARY,
    O_RDWR,
    O_RDWR | O_BINARY,
    O_WRONLY | O_CREAT | O_TRUNC,
    O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
    O_RDWR | O_CREAT | O_TRUNC,
    O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
    O_WRONLY | O_CREAT | O_APPEND,
    O_WRONLY | O_CREAT | O_APPEND | O_BINARY,
    O_RDWR | O_CREAT | O_APPEND,
    O_RDWR | O_CREAT | O_APPEND | O_BINARY
};

103
#ifdef CONFIG_USER_ONLY
104 105
static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
{
106 107 108 109 110 111 112 113 114 115
    if (code == (uint32_t)-1)
        ts->swi_errno = errno;
    return code;
}
#else
static inline uint32_t set_swi_errno(CPUState *env, uint32_t code)
{
    return code;
}

pbrook's avatar
pbrook committed
116
#include "softmmu-semi.h"
117
#endif
118

pbrook's avatar
pbrook committed
119 120
static target_ulong arm_semi_syscall_len;

pbrook's avatar
pbrook committed
121 122 123 124
#if !defined(CONFIG_USER_ONLY)
static target_ulong syscall_err;
#endif

pbrook's avatar
pbrook committed
125 126 127 128 129
static void arm_semi_cb(CPUState *env, target_ulong ret, target_ulong err)
{
#ifdef CONFIG_USER_ONLY
    TaskState *ts = env->opaque;
#endif
pbrook's avatar
pbrook committed
130

pbrook's avatar
pbrook committed
131 132 133
    if (ret == (target_ulong)-1) {
#ifdef CONFIG_USER_ONLY
        ts->swi_errno = err;
pbrook's avatar
pbrook committed
134 135
#else
	syscall_err = err;
pbrook's avatar
pbrook committed
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
#endif
        env->regs[0] = ret;
    } else {
        /* Fixup syscalls that use nonstardard return conventions.  */
        switch (env->regs[0]) {
        case SYS_WRITE:
        case SYS_READ:
            env->regs[0] = arm_semi_syscall_len - ret;
            break;
        case SYS_SEEK:
            env->regs[0] = 0;
            break;
        default:
            env->regs[0] = ret;
            break;
        }
    }
}

pbrook's avatar
pbrook committed
155 156 157 158 159 160 161 162 163 164 165 166 167 168
static void arm_semi_flen_cb(CPUState *env, target_ulong ret, target_ulong err)
{
    /* The size is always stored in big-endian order, extract
       the value. We assume the size always fit in 32 bits.  */
    uint32_t size;
    cpu_memory_rw_debug(env, env->regs[13]-64+32, (uint8_t *)&size, 4, 0);
    env->regs[0] = be32_to_cpu(size);
#ifdef CONFIG_USER_ONLY
    ((TaskState *)env->opaque)->swi_errno = err;
#else
    syscall_err = err;
#endif
}

169 170 171 172 173 174 175 176
#define ARG(n)					\
({						\
    target_ulong __arg;				\
    /* FIXME - handle get_user() failure */	\
    get_user_ual(__arg, args + (n) * 4);	\
    __arg;					\
})
#define SET_ARG(n, val) put_user_ual(val, args + (n) * 4)
177 178
uint32_t do_arm_semihosting(CPUState *env)
{
179
    target_ulong args;
180 181 182
    char * s;
    int nr;
    uint32_t ret;
183 184
    uint32_t len;
#ifdef CONFIG_USER_ONLY
185
    TaskState *ts = env->opaque;
186 187 188
#else
    CPUState *ts = env;
#endif
189 190

    nr = env->regs[0];
191
    args = env->regs[1];
192 193
    switch (nr) {
    case SYS_OPEN:
194 195 196
        if (!(s = lock_user_string(ARG(0))))
            /* FIXME - should this error code be -TARGET_EFAULT ? */
            return (uint32_t)-1;
197
        if (ARG(1) >= 12)
198
            return (uint32_t)-1;
199 200 201 202 203 204
        if (strcmp(s, ":tt") == 0) {
            if (ARG(1) < 4)
                return STDIN_FILENO;
            else
                return STDOUT_FILENO;
        }
pbrook's avatar
pbrook committed
205
        if (use_gdb_syscalls()) {
206
            gdb_do_syscall(arm_semi_cb, "open,%s,%x,1a4", ARG(0),
pbrook's avatar
pbrook committed
207
			   (int)ARG(2)+1, gdb_open_modeflags[ARG(1)]);
pbrook's avatar
pbrook committed
208 209 210 211
            return env->regs[0];
        } else {
            ret = set_swi_errno(ts, open(s, open_modeflags[ARG(1)], 0644));
        }
212 213
        unlock_user(s, ARG(0), 0);
        return ret;
214
    case SYS_CLOSE:
pbrook's avatar
pbrook committed
215 216 217 218 219 220
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "close,%x", ARG(0));
            return env->regs[0];
        } else {
            return set_swi_errno(ts, close(ARG(0)));
        }
221
    case SYS_WRITEC:
222
        {
223 224 225 226 227
          char c;

          if (get_user_u8(c, args))
              /* FIXME - should this error code be -TARGET_EFAULT ? */
              return (uint32_t)-1;
228
          /* Write to debug console.  stderr is near enough.  */
pbrook's avatar
pbrook committed
229 230 231 232 233 234
          if (use_gdb_syscalls()) {
                gdb_do_syscall(arm_semi_cb, "write,2,%x,1", args);
                return env->regs[0];
          } else {
                return write(STDERR_FILENO, &c, 1);
          }
235
        }
236
    case SYS_WRITE0:
237 238 239
        if (!(s = lock_user_string(args)))
            /* FIXME - should this error code be -TARGET_EFAULT ? */
            return (uint32_t)-1;
pbrook's avatar
pbrook committed
240 241 242 243 244 245 246
        len = strlen(s);
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "write,2,%x,%x\n", args, len);
            ret = env->regs[0];
        } else {
            ret = write(STDERR_FILENO, s, len);
        }
247 248
        unlock_user(s, args, 0);
        return ret;
249
    case SYS_WRITE:
250
        len = ARG(2);
pbrook's avatar
pbrook committed
251 252 253 254 255
        if (use_gdb_syscalls()) {
            arm_semi_syscall_len = len;
            gdb_do_syscall(arm_semi_cb, "write,%x,%x,%x", ARG(0), ARG(1), len);
            return env->regs[0];
        } else {
256 257 258
            if (!(s = lock_user(VERIFY_READ, ARG(1), len, 1)))
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                return (uint32_t)-1;
pbrook's avatar
pbrook committed
259 260 261 262 263 264
            ret = set_swi_errno(ts, write(ARG(0), s, len));
            unlock_user(s, ARG(1), 0);
            if (ret == (uint32_t)-1)
                return -1;
            return len - ret;
        }
265
    case SYS_READ:
266
        len = ARG(2);
pbrook's avatar
pbrook committed
267 268 269 270 271
        if (use_gdb_syscalls()) {
            arm_semi_syscall_len = len;
            gdb_do_syscall(arm_semi_cb, "read,%x,%x,%x", ARG(0), ARG(1), len);
            return env->regs[0];
        } else {
272 273 274
            if (!(s = lock_user(VERIFY_WRITE, ARG(1), len, 0)))
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                return (uint32_t)-1;
pbrook's avatar
pbrook committed
275 276 277 278 279 280 281 282
            do
              ret = set_swi_errno(ts, read(ARG(0), s, len));
            while (ret == -1 && errno == EINTR);
            unlock_user(s, ARG(1), len);
            if (ret == (uint32_t)-1)
                return -1;
            return len - ret;
        }
283 284 285 286
    case SYS_READC:
       /* XXX: Read from debug cosole. Not implemented.  */
        return 0;
    case SYS_ISTTY:
pbrook's avatar
pbrook committed
287 288 289 290 291 292
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "isatty,%x", ARG(0));
            return env->regs[0];
        } else {
            return isatty(ARG(0));
        }
293
    case SYS_SEEK:
pbrook's avatar
pbrook committed
294
        if (use_gdb_syscalls()) {
pbrook's avatar
pbrook committed
295
            gdb_do_syscall(arm_semi_cb, "lseek,%x,%x,0", ARG(0), ARG(1));
pbrook's avatar
pbrook committed
296 297 298 299 300 301 302
            return env->regs[0];
        } else {
            ret = set_swi_errno(ts, lseek(ARG(0), ARG(1), SEEK_SET));
            if (ret == (uint32_t)-1)
              return -1;
            return 0;
        }
303
    case SYS_FLEN:
pbrook's avatar
pbrook committed
304
        if (use_gdb_syscalls()) {
305
            gdb_do_syscall(arm_semi_flen_cb, "fstat,%x,%x",
pbrook's avatar
pbrook committed
306 307
			   ARG(0), env->regs[13]-64);
            return env->regs[0];
pbrook's avatar
pbrook committed
308
        } else {
309 310 311 312 313 314 315 316 317 318
            struct stat buf;
            ret = set_swi_errno(ts, fstat(ARG(0), &buf));
            if (ret == (uint32_t)-1)
                return -1;
            return buf.st_size;
        }
    case SYS_TMPNAM:
        /* XXX: Not implemented.  */
        return -1;
    case SYS_REMOVE:
pbrook's avatar
pbrook committed
319
        if (use_gdb_syscalls()) {
pbrook's avatar
pbrook committed
320
            gdb_do_syscall(arm_semi_cb, "unlink,%s", ARG(0), (int)ARG(1)+1);
pbrook's avatar
pbrook committed
321 322
            ret = env->regs[0];
        } else {
323 324 325
            if (!(s = lock_user_string(ARG(0))))
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                return (uint32_t)-1;
pbrook's avatar
pbrook committed
326 327 328
            ret =  set_swi_errno(ts, remove(s));
            unlock_user(s, ARG(0), 0);
        }
329
        return ret;
330
    case SYS_RENAME:
pbrook's avatar
pbrook committed
331 332
        if (use_gdb_syscalls()) {
            gdb_do_syscall(arm_semi_cb, "rename,%s,%s",
pbrook's avatar
pbrook committed
333
                           ARG(0), (int)ARG(1)+1, ARG(2), (int)ARG(3)+1);
pbrook's avatar
pbrook committed
334 335
            return env->regs[0];
        } else {
336 337 338
            char *s2;
            s = lock_user_string(ARG(0));
            s2 = lock_user_string(ARG(2));
339 340 341 342 343 344 345 346 347
            if (!s || !s2)
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                ret = (uint32_t)-1;
            else
                ret = set_swi_errno(ts, rename(s, s2));
            if (s2)
                unlock_user(s2, ARG(2), 0);
            if (s)
                unlock_user(s, ARG(0), 0);
348 349
            return ret;
        }
350 351 352 353 354
    case SYS_CLOCK:
        return clock() / (CLOCKS_PER_SEC / 100);
    case SYS_TIME:
        return set_swi_errno(ts, time(NULL));
    case SYS_SYSTEM:
pbrook's avatar
pbrook committed
355
        if (use_gdb_syscalls()) {
pbrook's avatar
pbrook committed
356
            gdb_do_syscall(arm_semi_cb, "system,%s", ARG(0), (int)ARG(1)+1);
pbrook's avatar
pbrook committed
357 358
            return env->regs[0];
        } else {
359 360 361
            if (!(s = lock_user_string(ARG(0))))
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                return (uint32_t)-1;
pbrook's avatar
pbrook committed
362 363
            ret = set_swi_errno(ts, system(s));
            unlock_user(s, ARG(0), 0);
364
            return ret;
pbrook's avatar
pbrook committed
365
        }
366
    case SYS_ERRNO:
367
#ifdef CONFIG_USER_ONLY
368
        return ts->swi_errno;
369
#else
pbrook's avatar
pbrook committed
370
        return syscall_err;
371
#endif
372
    case SYS_GET_CMDLINE:
373
#ifdef CONFIG_USER_ONLY
374 375 376 377 378
        /* Build a commandline from the original argv.  */
        {
            char **arg = ts->info->host_argv;
            int len = ARG(1);
            /* lock the buffer on the ARM side */
379 380 381 382 383
            char *cmdline_buffer = (char*)lock_user(VERIFY_WRITE, ARG(0), len, 0);

            if (!cmdline_buffer)
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                return (uint32_t)-1;
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412

            s = cmdline_buffer;
            while (*arg && len > 2) {
                int n = strlen(*arg);

                if (s != cmdline_buffer) {
                    *(s++) = ' ';
                    len--;
                }
                if (n >= len)
                    n = len - 1;
                memcpy(s, *arg, n);
                s += n;
                len -= n;
                arg++;
            }
            /* Null terminate the string.  */
            *s = 0;
            len = s - cmdline_buffer;

            /* Unlock the buffer on the ARM side.  */
            unlock_user(cmdline_buffer, ARG(0), len);

            /* Adjust the commandline length argument.  */
            SET_ARG(1, len);

            /* Return success if commandline fit into buffer.  */
            return *arg ? -1 : 0;
        }
413 414 415
#else
      return -1;
#endif
416 417 418 419 420
    case SYS_HEAPINFO:
        {
            uint32_t *ptr;
            uint32_t limit;

421 422
#ifdef CONFIG_USER_ONLY
            /* Some C libraries assume the heap immediately follows .bss, so
423 424 425 426
               allocate it using sbrk.  */
            if (!ts->heap_limit) {
                long ret;

427
                ts->heap_base = do_brk(0);
428 429 430
                limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
                /* Try a big heap, and reduce the size if that fails.  */
                for (;;) {
431
                    ret = do_brk(limit);
432 433 434 435 436 437
                    if (ret != -1)
                        break;
                    limit = (ts->heap_base >> 1) + (limit >> 1);
                }
                ts->heap_limit = limit;
            }
438

439 440 441
            if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                return (uint32_t)-1;
442 443 444 445
            ptr[0] = tswap32(ts->heap_base);
            ptr[1] = tswap32(ts->heap_limit);
            ptr[2] = tswap32(ts->stack_base);
            ptr[3] = tswap32(0); /* Stack limit.  */
446 447 448
            unlock_user(ptr, ARG(0), 16);
#else
            limit = ram_size;
449 450 451
            if (!(ptr = lock_user(VERIFY_WRITE, ARG(0), 16, 0)))
                /* FIXME - should this error code be -TARGET_EFAULT ? */
                return (uint32_t)-1;
452 453 454 455 456 457 458
            /* TODO: Make this use the limit of the loaded application.  */
            ptr[0] = tswap32(limit / 2);
            ptr[1] = tswap32(limit);
            ptr[2] = tswap32(limit); /* Stack base */
            ptr[3] = tswap32(0); /* Stack limit.  */
            unlock_user(ptr, ARG(0), 16);
#endif
459 460 461
            return 0;
        }
    case SYS_EXIT:
Paul Brook's avatar
Paul Brook committed
462
        gdb_exit(env, 0);
463 464 465 466 467 468 469
        exit(0);
    default:
        fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
        cpu_dump_state(env, stderr, fprintf, 0);
        abort();
    }
}