/*
* PowerPC Semihosting syscall interface.
* Implements a subset of NetBSD syscalls.
*
* Copyright (c) 2007 CodeSourcery.
*
* 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
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include "cpu.h"
#include "qemu-common.h"
#include "sysemu.h"
#include "gdbstub.h"
#include "softmmu-semi.h"
#define HOSTED_EXIT 1
#define HOSTED_READ 3
#define HOSTED_WRITE 4
#define HOSTED_OPEN 5
#define HOSTED_CLOSE 6
#define HOSTED_UNLINK 10
#define HOSTED_BRK 17
#define HOSTED_ACCESS 33
#define HOSTED_DUP 41
/* This is not quite right: 54 is ioctl, but the only thing we use ioctl
for right now is to implement isatty. Their argument lists are
compatible as far as the first argument goes, so we just fake it and
declare ioctl's syscall number as isatty's. */
#define HOSTED_ISATTY 54
#define HOSTED_SYSTEM 77 /* obsolete vlimit */
#define HOSTED_GETTIMEOFDAY 116
#define HOSTED_RENAME 128
#define HOSTED_LSEEK 199
#define HOSTED_STAT 387
#define HOSTED_FSTAT 388
typedef uint32_t gdb_mode_t;
typedef uint32_t gdb_time_t;
struct ppc_gdb_stat {
uint32_t gdb_st_dev; /* device */
uint32_t gdb_st_ino; /* inode */
gdb_mode_t gdb_st_mode; /* protection */
uint32_t gdb_st_nlink; /* number of hard links */
uint32_t gdb_st_uid; /* user ID of owner */
uint32_t gdb_st_gid; /* group ID of owner */
uint32_t gdb_st_rdev; /* device type (if inode device) */
uint64_t gdb_st_size; /* total size, in bytes */
uint64_t gdb_st_blksize; /* blocksize for filesystem I/O */
uint64_t gdb_st_blocks; /* number of blocks allocated */
gdb_time_t gdb_st_atime; /* time of last access */
gdb_time_t gdb_st_mtime; /* time of last modification */
gdb_time_t gdb_st_ctime; /* time of last change */
} __attribute__((packed));
struct ppc_netbsd_stat {
uint32_t nbsd_st_dev; /* device */
uint32_t nbsd_st_mode; /* protection */
uint64_t nbsd_st_ino; /* inode */
uint32_t nbsd_st_nlink; /* number of hard links */
uint32_t nbsd_st_uid; /* user ID of owner */
uint32_t nbsd_st_gid; /* group ID of owner */
uint32_t nbsd_st_rdev; /* device type */
int32_t nbsd_st_atime; /* time of last access */
int32_t nbsd_st_atimensec;
int32_t nbsd_st_mtime; /* time of last modification */
int32_t nbsd_st_mtimensec;
int32_t nbsd_st_ctime; /* time of last change */
int32_t nbsd_st_ctimensec;
uint64_t nbsd_st_size; /* total size, in bytes */
int64_t nbsd_st_blocks; /* number of blocks allocated */
uint32_t nbsd_st_blksize; /* blocksize for filesystem I/O */
uint32_t nbsd_st_flags; /* user-defined flags */
uint32_t nbsd_st_gen; /* filesystem generation number */
uint32_t nbsd_st_spare[2];
};
struct gdb_timeval {
gdb_time_t tv_sec; /* second */
uint64_t tv_usec; /* microsecond */
} __attribute__((packed));
#define TARGET_O_RDONLY 0
#define TARGET_O_WRONLY 1
#define TARGET_O_RDWR 2
#define TARGET_O_ACCMODE 3
#define TARGET_O_APPEND 0x0008
#define TARGET_O_CREAT 0x0200
#define TARGET_O_TRUNC 0x0400
#define TARGET_O_EXCL 0x0800
#define GDB_O_RDONLY 0x0
#define GDB_O_WRONLY 0x1
#define GDB_O_RDWR 0x2
#define GDB_O_APPEND 0x8
#define GDB_O_CREAT 0x200
#define GDB_O_TRUNC 0x400
#define GDB_O_EXCL 0x800
static int translate_openflags_gdb(int flags)
{
int gf;
if ((flags & TARGET_O_ACCMODE) == TARGET_O_WRONLY)
gf = GDB_O_WRONLY;
else if ((flags & TARGET_O_ACCMODE) == TARGET_O_RDWR)
gf = GDB_O_RDWR;
else
gf = GDB_O_RDONLY;
if (flags & TARGET_O_APPEND) gf |= GDB_O_APPEND;
if (flags & TARGET_O_CREAT) gf |= GDB_O_CREAT;
if (flags & TARGET_O_TRUNC) gf |= GDB_O_TRUNC;
if (flags & TARGET_O_EXCL) gf |= GDB_O_EXCL;
return gf;
}
static int translate_openflags_host(int flags)
{
int hf;
if ((flags & TARGET_O_ACCMODE) == TARGET_O_WRONLY)
hf = O_WRONLY;
else if ((flags & TARGET_O_ACCMODE) == TARGET_O_RDWR)
hf = O_RDWR;
else
hf = O_RDONLY;
if (flags & TARGET_O_APPEND) hf |= O_APPEND;
if (flags & TARGET_O_CREAT) hf |= O_CREAT;
if (flags & TARGET_O_TRUNC) hf |= O_TRUNC;
if (flags & TARGET_O_EXCL) hf |= O_EXCL;
return hf;
}
static void translate_to_netbsd_stat(CPUState *env, target_ulong addr,
struct stat *s, target_ulong saddr)
{
struct ppc_netbsd_stat *p;
if (!(p = lock_user(VERIFY_WRITE, addr, sizeof(*p), 0)))
/* FIXME - should this return an error code? */
return;
if (s) {
p->nbsd_st_dev = cpu_to_be32(s->st_dev);
p->nbsd_st_ino = cpu_to_be64(s->st_ino);
p->nbsd_st_mode = cpu_to_be32(s->st_mode);
p->nbsd_st_nlink = cpu_to_be32(s->st_nlink);
p->nbsd_st_uid = cpu_to_be32(s->st_uid);
p->nbsd_st_gid = cpu_to_be32(s->st_gid);
p->nbsd_st_rdev = cpu_to_be32(s->st_rdev);
p->nbsd_st_size = cpu_to_be64(s->st_size);
#ifdef _WIN32
/* Windows stat is missing some fields. */
p->nbsd_st_blksize = 0;
p->nbsd_st_blocks = 0;
#else
p->nbsd_st_blksize = cpu_to_be32(s->st_blksize);
p->nbsd_st_blocks = cpu_to_be64(s->st_blocks);
#endif
p->nbsd_st_atime = cpu_to_be32(s->st_atime);
p->nbsd_st_mtime = cpu_to_be32(s->st_mtime);
p->nbsd_st_ctime = cpu_to_be32(s->st_ctime);
} else {
struct ppc_gdb_stat *g;
if (g = lock_user (VERIFY_READ, saddr, sizeof(*g), 1)) {
p->nbsd_st_dev = cpu_to_be32(g->gdb_st_dev);
p->nbsd_st_ino = cpu_to_be64(g->gdb_st_ino);
p->nbsd_st_mode = cpu_to_be32(g->gdb_st_mode);
p->nbsd_st_nlink = cpu_to_be32(g->gdb_st_nlink);
p->nbsd_st_uid = cpu_to_be32(g->gdb_st_uid);
p->nbsd_st_gid = cpu_to_be32(g->gdb_st_gid);
p->nbsd_st_rdev = cpu_to_be32(g->gdb_st_rdev);
p->nbsd_st_size = cpu_to_be64(g->gdb_st_size);
p->nbsd_st_blksize = cpu_to_be32(g->gdb_st_blksize);
p->nbsd_st_blocks = cpu_to_be64(g->gdb_st_blocks);
p->nbsd_st_atime = cpu_to_be32(g->gdb_st_atime);
p->nbsd_st_mtime = cpu_to_be32(g->gdb_st_mtime);
p->nbsd_st_ctime = cpu_to_be32(g->gdb_st_ctime);
unlock_user (g, saddr, 0);
}
}
unlock_user(p, addr, sizeof(*p));
}
#define ARG(n) env->gpr[3 + (n)]
static void ppc_semi_cb(CPUState *env, target_ulong ret, target_ulong err)
{
if (ret == -1) {
env->gpr[3] = errno;
env->crf[0] |= 1;
} else {
env->gpr[3] = ret;
env->crf[0] &= ~1;
}
}
static void ppc_stat_cb(CPUState *env, target_ulong ret, target_ulong err)
{
/* Do this before we overwrite r3 with the return value. */
if (ret != -1) {
target_ulong buffer = env->gpr[1] - sizeof(struct ppc_gdb_stat);
translate_to_netbsd_stat (env, ARG(1), NULL, buffer);
}
ppc_semi_cb(env, ret, err);
}
static void ppc_isatty_cb(CPUState *env, target_ulong ret, target_ulong err)
{
/* isatty returns 0 or 1; translate that to system call-ish conventions.
Don't bother propagating errno. */
env->gpr[3] = ret ? 0 : -1;
}
void do_ppc_semihosting(CPUPPCState *env)
{
int nr;
void *p, *q;
uint32_t len;
uint32_t result;
nr = env->gpr[0];
switch (nr) {
case HOSTED_EXIT:
/* FIXME: ideally we want to inform gdb about program
exit whenever gdb is connected, even if syscalls
are not handled by gdb. */
if (use_gdb_syscalls())
gdb_exit(env, ARG(0));
exit(ARG(0));
case HOSTED_OPEN:
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "open,%s,%x,%x",
ARG(0), target_strlen(ARG(0)),
translate_openflags_gdb(ARG(1)), ARG(2));
return;
} else {
if (!(p = lock_user_string(ARG(0)))) {
/* FIXME - check error code? */
result = -1;
} else {
result = uninterrupted_open(p, translate_openflags_host(ARG(1)), ARG(2));
unlock_user(p, ARG(0), 0);
}
}
break;
case HOSTED_CLOSE:
{
/* Ignore attempts to close stdin/out/err. */
int fd = ARG(0);
if (fd > 2) {
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "close,%x", ARG(0));
return;
} else {
result = uninterrupted_close(fd);
}
} else {
result = 0;
}
break;
}
case HOSTED_READ:
len = ARG(2);
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "read,%x,%x,%x",
ARG(0), ARG(1), len);
return;
} else {
if (!(p = lock_user(VERIFY_WRITE, ARG(1), len, 0))) {
/* FIXME - check error code? */
result = -1;
} else {
result = uninterrupted_read(ARG(0), p, len);
unlock_user(p, ARG(1), len);
}
}
break;
case HOSTED_WRITE:
len = ARG(2);
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "write,%x,%x,%x",
ARG(0), ARG(1), len);
return;
} else {
if (!(p = lock_user(VERIFY_READ, ARG(1), len, 1))) {
/* FIXME - check error code? */
result = -1;
} else {
result = uninterrupted_write(ARG(0), p, len);
unlock_user(p, ARG(0), 0);
}
}
break;
case HOSTED_UNLINK:
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "unlink,%s",
ARG(0), (int)ARG(1));
return;
} else {
if (!(p = lock_user_string(ARG(0)))) {
/* FIXME - check error code? */
result = -1;
} else {
result = unlink(p);
unlock_user(p, ARG(0), 0);
}
}
break;
case HOSTED_BRK:
/* Nasty hack: use sp -1M as heap limit. */
if (ARG(0) < env->gpr[1] - 0x100000) {
result = 0;
} else {
result = -1;
errno = ENOMEM;
}
break;
case HOSTED_LSEEK:
{
uint64_t off;
off = (uint32_t)ARG(2) | ((uint64_t)ARG(1) << 32);
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "lseek,%x,%lx,%x",
ARG(0), off, ARG(3));
return;
} else {
off = lseek(ARG(0), off, ARG(3));
if (off == (uint64_t) -1) {
result = -1;
} else {
env->gpr[3] = off >> 32;
env->gpr[4] = (uint32_t) off;
env->crf[0] &= ~1;
return;
}
}
}
break;
case HOSTED_STAT:
if (use_gdb_syscalls()) {
target_ulong buffer = env->gpr[1] - sizeof (struct ppc_gdb_stat);
gdb_do_syscall(ppc_stat_cb, "stat,%s,%x", ARG(0), buffer);
return;
} else {
struct stat s;
if (!(p = lock_user_string(ARG(0)))) {
/* FIXME - check error code? */
result = -1;
} else {
result = stat(p, &s);
unlock_user(p, ARG(0), 0);
}
if (result == 0) {
translate_to_netbsd_stat(env, ARG(1), &s, 0);
}
}
break;
case HOSTED_FSTAT:
if (use_gdb_syscalls()) {
target_ulong buffer = env->gpr[1] - sizeof (struct ppc_gdb_stat);
gdb_do_syscall(ppc_stat_cb, "fstat,%x,%x", ARG(0), buffer);
return;
} else {
struct stat s;
result = fstat(ARG(0), &s);
if (result == 0) {
translate_to_netbsd_stat(env, ARG(1), &s, 0);
}
}
break;
case HOSTED_RENAME:
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "rename,%s,%s",
ARG(0), (int)ARG(1), ARG(2), (int)ARG(3));
return;
} else {
p = lock_user_string(ARG(0));
q = lock_user_string(ARG(2));
if (!p || !q) {
/* FIXME - check error code? */
result = -1;
} else {
result = rename(p, q);
}
unlock_user(p, ARG(0), 0);
unlock_user(q, ARG(2), 0);
}
break;
case HOSTED_ISATTY:
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_isatty_cb, "isatty,%x", ARG(0));
return;
} else {
/* Don't bother propagating errno. */
env->gpr[3] = isatty(ARG(0)) ? 0 : -1;
return;
}
break;
case HOSTED_SYSTEM:
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "system,%s",
ARG(0), (int)ARG(1));
return;
} else {
if (!(p = lock_user_string(ARG(0)))) {
/* FIXME - check error code? */
result = -1;
} else {
result = system(p);
unlock_user(p, ARG(0), 0);
}
}
break;
case HOSTED_GETTIMEOFDAY:
result = -1;
errno = ENOSYS;
#ifdef FIXME
if (use_gdb_syscalls()) {
gdb_do_syscall(ppc_semi_cb, "gettimeofday,%x,%x",
ARG(0), ARG(1));
return;
} else {
qemu_timeval tv;
struct gdb_timeval *p;
result = qemu_gettimeofday(&tv);
if (result != 0) {
if (!(p = lock_user(VERIFY_WRITE,
ARG(0), sizeof(struct gdb_timeval), 0))) {
/* FIXME - check error code? */
result = -1;
} else {
p->tv_sec = cpu_to_be32(tv.tv_sec);
p->tv_usec = cpu_to_be64(tv.tv_usec);
unlock_user(p, ARG(0), sizeof(struct gdb_timeval));
}
}
}
#endif
break;
default:
cpu_abort(env, "Unsupported semihosting syscall %d\n", nr);
result = 0;
}
if (result == -1) {
env->gpr[3] = errno;
env->crf[0] |= 1;
} else {
env->gpr[3] = result;
env->crf[0] &= ~1;
}
}