Intercept certain system calls if semihosting is enabled. This should behave like the GDB simulator. Signed-off-by: Michael Walle <michael@walle.cc>
216 lines
5.4 KiB
C
216 lines
5.4 KiB
C
/*
|
|
* Lattice Mico32 semihosting syscall interface
|
|
*
|
|
* Copyright (c) 2014 Michael Walle <michael@walle.cc>
|
|
*
|
|
* Based on target-m68k/m68k-semi.c, which is
|
|
* Copyright (c) 2005-2007 CodeSourcery.
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stddef.h>
|
|
#include "cpu.h"
|
|
#include "helper.h"
|
|
#include "qemu/log.h"
|
|
#include "exec/softmmu-semi.h"
|
|
|
|
enum {
|
|
TARGET_SYS_exit = 1,
|
|
TARGET_SYS_open = 2,
|
|
TARGET_SYS_close = 3,
|
|
TARGET_SYS_read = 4,
|
|
TARGET_SYS_write = 5,
|
|
TARGET_SYS_lseek = 6,
|
|
TARGET_SYS_fstat = 10,
|
|
TARGET_SYS_stat = 15,
|
|
};
|
|
|
|
enum {
|
|
NEWLIB_O_RDONLY = 0x0,
|
|
NEWLIB_O_WRONLY = 0x1,
|
|
NEWLIB_O_RDWR = 0x2,
|
|
NEWLIB_O_APPEND = 0x8,
|
|
NEWLIB_O_CREAT = 0x200,
|
|
NEWLIB_O_TRUNC = 0x400,
|
|
NEWLIB_O_EXCL = 0x800,
|
|
};
|
|
|
|
static int translate_openflags(int flags)
|
|
{
|
|
int hf;
|
|
|
|
if (flags & NEWLIB_O_WRONLY) {
|
|
hf = O_WRONLY;
|
|
} else if (flags & NEWLIB_O_RDWR) {
|
|
hf = O_RDWR;
|
|
} else {
|
|
hf = O_RDONLY;
|
|
}
|
|
|
|
if (flags & NEWLIB_O_APPEND) {
|
|
hf |= O_APPEND;
|
|
}
|
|
|
|
if (flags & NEWLIB_O_CREAT) {
|
|
hf |= O_CREAT;
|
|
}
|
|
|
|
if (flags & NEWLIB_O_TRUNC) {
|
|
hf |= O_TRUNC;
|
|
}
|
|
|
|
if (flags & NEWLIB_O_EXCL) {
|
|
hf |= O_EXCL;
|
|
}
|
|
|
|
return hf;
|
|
}
|
|
|
|
struct newlib_stat {
|
|
int16_t newlib_st_dev; /* device */
|
|
uint16_t newlib_st_ino; /* inode */
|
|
uint16_t newlib_st_mode; /* protection */
|
|
uint16_t newlib_st_nlink; /* number of hard links */
|
|
uint16_t newlib_st_uid; /* user ID of owner */
|
|
uint16_t newlib_st_gid; /* group ID of owner */
|
|
int16_t newlib_st_rdev; /* device type (if inode device) */
|
|
int32_t newlib_st_size; /* total size, in bytes */
|
|
int32_t newlib_st_atime; /* time of last access */
|
|
uint32_t newlib_st_spare1;
|
|
int32_t newlib_st_mtime; /* time of last modification */
|
|
uint32_t newlib_st_spare2;
|
|
int32_t newlib_st_ctime; /* time of last change */
|
|
uint32_t newlib_st_spare3;
|
|
} QEMU_PACKED;
|
|
|
|
static int translate_stat(CPULM32State *env, target_ulong addr,
|
|
struct stat *s)
|
|
{
|
|
struct newlib_stat *p;
|
|
|
|
p = lock_user(VERIFY_WRITE, addr, sizeof(struct newlib_stat), 0);
|
|
if (!p) {
|
|
return 0;
|
|
}
|
|
p->newlib_st_dev = cpu_to_be16(s->st_dev);
|
|
p->newlib_st_ino = cpu_to_be16(s->st_ino);
|
|
p->newlib_st_mode = cpu_to_be16(s->st_mode);
|
|
p->newlib_st_nlink = cpu_to_be16(s->st_nlink);
|
|
p->newlib_st_uid = cpu_to_be16(s->st_uid);
|
|
p->newlib_st_gid = cpu_to_be16(s->st_gid);
|
|
p->newlib_st_rdev = cpu_to_be16(s->st_rdev);
|
|
p->newlib_st_size = cpu_to_be32(s->st_size);
|
|
p->newlib_st_atime = cpu_to_be32(s->st_atime);
|
|
p->newlib_st_mtime = cpu_to_be32(s->st_mtime);
|
|
p->newlib_st_ctime = cpu_to_be32(s->st_ctime);
|
|
unlock_user(p, addr, sizeof(struct newlib_stat));
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool lm32_cpu_do_semihosting(CPUState *cs)
|
|
{
|
|
LM32CPU *cpu = LM32_CPU(cs);
|
|
CPULM32State *env = &cpu->env;
|
|
|
|
int ret = -1;
|
|
target_ulong nr, arg0, arg1, arg2;
|
|
void *p;
|
|
struct stat s;
|
|
|
|
nr = env->regs[R_R8];
|
|
arg0 = env->regs[R_R1];
|
|
arg1 = env->regs[R_R2];
|
|
arg2 = env->regs[R_R3];
|
|
|
|
switch (nr) {
|
|
case TARGET_SYS_exit:
|
|
/* void _exit(int rc) */
|
|
exit(arg0);
|
|
|
|
case TARGET_SYS_open:
|
|
/* int open(const char *pathname, int flags) */
|
|
p = lock_user_string(arg0);
|
|
if (!p) {
|
|
ret = -1;
|
|
} else {
|
|
ret = open(p, translate_openflags(arg2));
|
|
unlock_user(p, arg0, 0);
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_read:
|
|
/* ssize_t read(int fd, const void *buf, size_t count) */
|
|
p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
|
|
if (!p) {
|
|
ret = -1;
|
|
} else {
|
|
ret = read(arg0, p, arg2);
|
|
unlock_user(p, arg1, arg2);
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_write:
|
|
/* ssize_t write(int fd, const void *buf, size_t count) */
|
|
p = lock_user(VERIFY_READ, arg1, arg2, 1);
|
|
if (!p) {
|
|
ret = -1;
|
|
} else {
|
|
ret = write(arg0, p, arg2);
|
|
unlock_user(p, arg1, 0);
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_close:
|
|
/* int close(int fd) */
|
|
/* don't close stdin/stdout/stderr */
|
|
if (arg0 > 2) {
|
|
ret = close(arg0);
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_lseek:
|
|
/* off_t lseek(int fd, off_t offset, int whence */
|
|
ret = lseek(arg0, arg1, arg2);
|
|
break;
|
|
|
|
case TARGET_SYS_stat:
|
|
/* int stat(const char *path, struct stat *buf) */
|
|
p = lock_user_string(arg0);
|
|
if (!p) {
|
|
ret = -1;
|
|
} else {
|
|
ret = stat(p, &s);
|
|
unlock_user(p, arg0, 0);
|
|
if (translate_stat(env, arg1, &s) == 0) {
|
|
ret = -1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_fstat:
|
|
/* int stat(int fd, struct stat *buf) */
|
|
ret = fstat(arg0, &s);
|
|
if (ret == 0) {
|
|
if (translate_stat(env, arg1, &s) == 0) {
|
|
ret = -1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* unhandled */
|
|
return false;
|
|
}
|
|
|
|
env->regs[R_R1] = ret;
|
|
return true;
|
|
}
|