qemu/semihosting/syscalls.c
Philippe Mathieu-Daudé f14eced5ac semihosting: Rename softmmu_FOO_user() -> uaccess_FOO_user()
Add a check in 'softmmu-uaccess.h' that the header is only
include in system emulation, and rename it as 'uaccess.h'.

Rename the API methods:

  - softmmu_[un]lock_user*() -> uaccess_[un]lock_user*()
  - softmmu_strlen_user() -> uaccess_strlen_user().

Update a pair of comments.

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Message-ID: <20231004090629.37473-9-philmd@linaro.org>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2023-10-07 19:02:59 +02:00

984 lines
26 KiB
C

/*
* Syscall implementations for semihosting.
*
* Copyright (c) 2022 Linaro
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "qemu/osdep.h"
#include "cpu.h"
#include "gdbstub/syscalls.h"
#include "semihosting/guestfd.h"
#include "semihosting/syscalls.h"
#include "semihosting/console.h"
#ifdef CONFIG_USER_ONLY
#include "qemu.h"
#else
#include "semihosting/uaccess.h"
#endif
/*
* Validate or compute the length of the string (including terminator).
*/
static int validate_strlen(CPUState *cs, target_ulong str, target_ulong tlen)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char c;
if (tlen == 0) {
ssize_t slen = target_strlen(str);
if (slen < 0) {
return -EFAULT;
}
if (slen >= INT32_MAX) {
return -ENAMETOOLONG;
}
return slen + 1;
}
if (tlen > INT32_MAX) {
return -ENAMETOOLONG;
}
if (get_user_u8(c, str + tlen - 1)) {
return -EFAULT;
}
if (c != 0) {
return -EINVAL;
}
return tlen;
}
static int validate_lock_user_string(char **pstr, CPUState *cs,
target_ulong tstr, target_ulong tlen)
{
int ret = validate_strlen(cs, tstr, tlen);
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char *str = NULL;
if (ret > 0) {
str = lock_user(VERIFY_READ, tstr, ret, true);
ret = str ? 0 : -EFAULT;
}
*pstr = str;
return ret;
}
/*
* TODO: Note that gdb always stores the stat structure big-endian.
* So far, that's ok, as the only two targets using this are also
* big-endian. Until we do something with gdb, also produce the
* same big-endian result from the host.
*/
static int copy_stat_to_user(CPUState *cs, target_ulong addr,
const struct stat *s)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
struct gdb_stat *p;
if (s->st_dev != (uint32_t)s->st_dev ||
s->st_ino != (uint32_t)s->st_ino) {
return -EOVERFLOW;
}
p = lock_user(VERIFY_WRITE, addr, sizeof(struct gdb_stat), 0);
if (!p) {
return -EFAULT;
}
p->gdb_st_dev = cpu_to_be32(s->st_dev);
p->gdb_st_ino = cpu_to_be32(s->st_ino);
p->gdb_st_mode = cpu_to_be32(s->st_mode);
p->gdb_st_nlink = cpu_to_be32(s->st_nlink);
p->gdb_st_uid = cpu_to_be32(s->st_uid);
p->gdb_st_gid = cpu_to_be32(s->st_gid);
p->gdb_st_rdev = cpu_to_be32(s->st_rdev);
p->gdb_st_size = cpu_to_be64(s->st_size);
#ifdef _WIN32
/* Windows stat is missing some fields. */
p->gdb_st_blksize = 0;
p->gdb_st_blocks = 0;
#else
p->gdb_st_blksize = cpu_to_be64(s->st_blksize);
p->gdb_st_blocks = cpu_to_be64(s->st_blocks);
#endif
p->gdb_st_atime = cpu_to_be32(s->st_atime);
p->gdb_st_mtime = cpu_to_be32(s->st_mtime);
p->gdb_st_ctime = cpu_to_be32(s->st_ctime);
unlock_user(p, addr, sizeof(struct gdb_stat));
return 0;
}
/*
* GDB semihosting syscall implementations.
*/
static gdb_syscall_complete_cb gdb_open_complete;
static void gdb_open_cb(CPUState *cs, uint64_t ret, int err)
{
if (!err) {
int guestfd = alloc_guestfd();
associate_guestfd(guestfd, ret);
ret = guestfd;
}
gdb_open_complete(cs, ret, err);
}
static void gdb_open(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len,
int gdb_flags, int mode)
{
int len = validate_strlen(cs, fname, fname_len);
if (len < 0) {
complete(cs, -1, -len);
return;
}
gdb_open_complete = complete;
gdb_do_syscall(gdb_open_cb, "open,%s,%x,%x",
(uint64_t)fname, (uint32_t)len,
(uint32_t)gdb_flags, (uint32_t)mode);
}
static void gdb_close(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf)
{
gdb_do_syscall(complete, "close,%x", (uint32_t)gf->hostfd);
}
static void gdb_read(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
gdb_do_syscall(complete, "read,%x,%lx,%lx",
(uint32_t)gf->hostfd, (uint64_t)buf, (uint64_t)len);
}
static void gdb_write(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
gdb_do_syscall(complete, "write,%x,%lx,%lx",
(uint32_t)gf->hostfd, (uint64_t)buf, (uint64_t)len);
}
static void gdb_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, int64_t off, int gdb_whence)
{
gdb_do_syscall(complete, "lseek,%x,%lx,%x",
(uint32_t)gf->hostfd, off, (uint32_t)gdb_whence);
}
static void gdb_isatty(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf)
{
gdb_do_syscall(complete, "isatty,%x", (uint32_t)gf->hostfd);
}
static void gdb_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong addr)
{
gdb_do_syscall(complete, "fstat,%x,%lx",
(uint32_t)gf->hostfd, (uint64_t)addr);
}
static void gdb_stat(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len,
target_ulong addr)
{
int len = validate_strlen(cs, fname, fname_len);
if (len < 0) {
complete(cs, -1, -len);
return;
}
gdb_do_syscall(complete, "stat,%s,%lx",
(uint64_t)fname, (uint32_t)len, (uint64_t)addr);
}
static void gdb_remove(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len)
{
int len = validate_strlen(cs, fname, fname_len);
if (len < 0) {
complete(cs, -1, -len);
return;
}
gdb_do_syscall(complete, "unlink,%s", (uint64_t)fname, (uint32_t)len);
}
static void gdb_rename(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong oname, target_ulong oname_len,
target_ulong nname, target_ulong nname_len)
{
int olen, nlen;
olen = validate_strlen(cs, oname, oname_len);
if (olen < 0) {
complete(cs, -1, -olen);
return;
}
nlen = validate_strlen(cs, nname, nname_len);
if (nlen < 0) {
complete(cs, -1, -nlen);
return;
}
gdb_do_syscall(complete, "rename,%s,%s",
(uint64_t)oname, (uint32_t)olen,
(uint64_t)nname, (uint32_t)nlen);
}
static void gdb_system(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong cmd, target_ulong cmd_len)
{
int len = validate_strlen(cs, cmd, cmd_len);
if (len < 0) {
complete(cs, -1, -len);
return;
}
gdb_do_syscall(complete, "system,%s", (uint64_t)cmd, (uint32_t)len);
}
static void gdb_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong tv_addr, target_ulong tz_addr)
{
gdb_do_syscall(complete, "gettimeofday,%lx,%lx",
(uint64_t)tv_addr, (uint64_t)tz_addr);
}
/*
* Host semihosting syscall implementations.
*/
static void host_open(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len,
int gdb_flags, int mode)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char *p;
int ret, host_flags = O_BINARY;
ret = validate_lock_user_string(&p, cs, fname, fname_len);
if (ret < 0) {
complete(cs, -1, -ret);
return;
}
if (gdb_flags & GDB_O_WRONLY) {
host_flags |= O_WRONLY;
} else if (gdb_flags & GDB_O_RDWR) {
host_flags |= O_RDWR;
} else {
host_flags |= O_RDONLY;
}
if (gdb_flags & GDB_O_CREAT) {
host_flags |= O_CREAT;
}
if (gdb_flags & GDB_O_TRUNC) {
host_flags |= O_TRUNC;
}
if (gdb_flags & GDB_O_EXCL) {
host_flags |= O_EXCL;
}
ret = open(p, host_flags, mode);
if (ret < 0) {
complete(cs, -1, errno);
} else {
int guestfd = alloc_guestfd();
associate_guestfd(guestfd, ret);
complete(cs, guestfd, 0);
}
unlock_user(p, fname, 0);
}
static void host_close(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf)
{
/*
* Only close the underlying host fd if it's one we opened on behalf
* of the guest in SYS_OPEN.
*/
if (gf->hostfd != STDIN_FILENO &&
gf->hostfd != STDOUT_FILENO &&
gf->hostfd != STDERR_FILENO &&
close(gf->hostfd) < 0) {
complete(cs, -1, errno);
} else {
complete(cs, 0, 0);
}
}
static void host_read(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
void *ptr = lock_user(VERIFY_WRITE, buf, len, 0);
ssize_t ret;
if (!ptr) {
complete(cs, -1, EFAULT);
return;
}
ret = RETRY_ON_EINTR(read(gf->hostfd, ptr, len));
if (ret == -1) {
unlock_user(ptr, buf, 0);
complete(cs, -1, errno);
} else {
unlock_user(ptr, buf, ret);
complete(cs, ret, 0);
}
}
static void host_write(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
void *ptr = lock_user(VERIFY_READ, buf, len, 1);
ssize_t ret;
if (!ptr) {
complete(cs, -1, EFAULT);
return;
}
ret = write(gf->hostfd, ptr, len);
unlock_user(ptr, buf, 0);
complete(cs, ret, ret == -1 ? errno : 0);
}
static void host_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, int64_t off, int whence)
{
/* So far, all hosts use the same values. */
QEMU_BUILD_BUG_ON(GDB_SEEK_SET != SEEK_SET);
QEMU_BUILD_BUG_ON(GDB_SEEK_CUR != SEEK_CUR);
QEMU_BUILD_BUG_ON(GDB_SEEK_END != SEEK_END);
off_t ret = off;
int err = 0;
if (ret == off) {
ret = lseek(gf->hostfd, ret, whence);
if (ret == -1) {
err = errno;
}
} else {
ret = -1;
err = EINVAL;
}
complete(cs, ret, err);
}
static void host_isatty(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf)
{
int ret = isatty(gf->hostfd);
complete(cs, ret, ret ? 0 : errno);
}
static void host_flen(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf)
{
struct stat buf;
if (fstat(gf->hostfd, &buf) < 0) {
complete(cs, -1, errno);
} else {
complete(cs, buf.st_size, 0);
}
}
static void host_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong addr)
{
struct stat buf;
int ret;
ret = fstat(gf->hostfd, &buf);
if (ret) {
complete(cs, -1, errno);
return;
}
ret = copy_stat_to_user(cs, addr, &buf);
complete(cs, ret ? -1 : 0, ret ? -ret : 0);
}
static void host_stat(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len,
target_ulong addr)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
struct stat buf;
char *name;
int ret, err;
ret = validate_lock_user_string(&name, cs, fname, fname_len);
if (ret < 0) {
complete(cs, -1, -ret);
return;
}
ret = stat(name, &buf);
if (ret) {
err = errno;
} else {
ret = copy_stat_to_user(cs, addr, &buf);
err = 0;
if (ret < 0) {
err = -ret;
ret = -1;
}
}
unlock_user(name, fname, 0);
complete(cs, ret, err);
}
static void host_remove(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char *p;
int ret;
ret = validate_lock_user_string(&p, cs, fname, fname_len);
if (ret < 0) {
complete(cs, -1, -ret);
return;
}
ret = remove(p);
unlock_user(p, fname, 0);
complete(cs, ret, ret ? errno : 0);
}
static void host_rename(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong oname, target_ulong oname_len,
target_ulong nname, target_ulong nname_len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char *ostr, *nstr;
int ret;
ret = validate_lock_user_string(&ostr, cs, oname, oname_len);
if (ret < 0) {
complete(cs, -1, -ret);
return;
}
ret = validate_lock_user_string(&nstr, cs, nname, nname_len);
if (ret < 0) {
unlock_user(ostr, oname, 0);
complete(cs, -1, -ret);
return;
}
ret = rename(ostr, nstr);
unlock_user(ostr, oname, 0);
unlock_user(nstr, nname, 0);
complete(cs, ret, ret ? errno : 0);
}
static void host_system(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong cmd, target_ulong cmd_len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char *p;
int ret;
ret = validate_lock_user_string(&p, cs, cmd, cmd_len);
if (ret < 0) {
complete(cs, -1, -ret);
return;
}
ret = system(p);
unlock_user(p, cmd, 0);
complete(cs, ret, ret == -1 ? errno : 0);
}
static void host_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong tv_addr, target_ulong tz_addr)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
struct gdb_timeval *p;
int64_t rt;
/* GDB fails on non-null TZ, so be consistent. */
if (tz_addr != 0) {
complete(cs, -1, EINVAL);
return;
}
p = lock_user(VERIFY_WRITE, tv_addr, sizeof(struct gdb_timeval), 0);
if (!p) {
complete(cs, -1, EFAULT);
return;
}
/* TODO: Like stat, gdb always produces big-endian results; match it. */
rt = g_get_real_time();
p->tv_sec = cpu_to_be32(rt / G_USEC_PER_SEC);
p->tv_usec = cpu_to_be64(rt % G_USEC_PER_SEC);
unlock_user(p, tv_addr, sizeof(struct gdb_timeval));
}
#ifndef CONFIG_USER_ONLY
static void host_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, GIOCondition cond, int timeout)
{
/*
* Since this is only used by xtensa in system mode, and stdio is
* handled through GuestFDConsole, and there are no semihosting
* system calls for sockets and the like, that means this descriptor
* must be a normal file. Normal files never block and are thus
* always ready.
*/
complete(cs, cond & (G_IO_IN | G_IO_OUT), 0);
}
#endif
/*
* Static file semihosting syscall implementations.
*/
static void staticfile_read(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
target_ulong rest = gf->staticfile.len - gf->staticfile.off;
void *ptr;
if (len > rest) {
len = rest;
}
ptr = lock_user(VERIFY_WRITE, buf, len, 0);
if (!ptr) {
complete(cs, -1, EFAULT);
return;
}
memcpy(ptr, gf->staticfile.data + gf->staticfile.off, len);
gf->staticfile.off += len;
unlock_user(ptr, buf, len);
complete(cs, len, 0);
}
static void staticfile_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, int64_t off, int gdb_whence)
{
int64_t ret;
switch (gdb_whence) {
case GDB_SEEK_SET:
ret = off;
break;
case GDB_SEEK_CUR:
ret = gf->staticfile.off + off;
break;
case GDB_SEEK_END:
ret = gf->staticfile.len + off;
break;
default:
ret = -1;
break;
}
if (ret >= 0 && ret <= gf->staticfile.len) {
gf->staticfile.off = ret;
complete(cs, ret, 0);
} else {
complete(cs, -1, EINVAL);
}
}
static void staticfile_flen(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf)
{
complete(cs, gf->staticfile.len, 0);
}
/*
* Console semihosting syscall implementations.
*/
static void console_read(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char *ptr;
int ret;
ptr = lock_user(VERIFY_WRITE, buf, len, 0);
if (!ptr) {
complete(cs, -1, EFAULT);
return;
}
ret = qemu_semihosting_console_read(cs, ptr, len);
unlock_user(ptr, buf, ret);
complete(cs, ret, 0);
}
static void console_write(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
CPUArchState *env G_GNUC_UNUSED = cpu_env(cs);
char *ptr = lock_user(VERIFY_READ, buf, len, 1);
int ret;
if (!ptr) {
complete(cs, -1, EFAULT);
return;
}
ret = qemu_semihosting_console_write(ptr, len);
unlock_user(ptr, buf, 0);
complete(cs, ret ? ret : -1, ret ? 0 : EIO);
}
static void console_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong addr)
{
static const struct stat tty_buf = {
.st_mode = 020666, /* S_IFCHR, ugo+rw */
.st_rdev = 5, /* makedev(5, 0) -- linux /dev/tty */
};
int ret;
ret = copy_stat_to_user(cs, addr, &tty_buf);
complete(cs, ret ? -1 : 0, ret ? -ret : 0);
}
#ifndef CONFIG_USER_ONLY
static void console_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, GIOCondition cond, int timeout)
{
/* The semihosting console does not support urgent data or errors. */
cond &= G_IO_IN | G_IO_OUT;
/*
* Since qemu_semihosting_console_write never blocks, we can
* consider output always ready -- leave G_IO_OUT alone.
* All that remains is to conditionally signal input ready.
* Since output ready causes an immediate return, only block
* for G_IO_IN alone.
*
* TODO: Implement proper timeout. For now, only support
* indefinite wait or immediate poll.
*/
if (cond == G_IO_IN && timeout < 0) {
qemu_semihosting_console_block_until_ready(cs);
/* We returned -- input must be ready. */
} else if ((cond & G_IO_IN) && !qemu_semihosting_console_ready()) {
cond &= ~G_IO_IN;
}
complete(cs, cond, 0);
}
#endif
/*
* Syscall entry points.
*/
void semihost_sys_open(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len,
int gdb_flags, int mode)
{
if (use_gdb_syscalls()) {
gdb_open(cs, complete, fname, fname_len, gdb_flags, mode);
} else {
host_open(cs, complete, fname, fname_len, gdb_flags, mode);
}
}
void semihost_sys_close(CPUState *cs, gdb_syscall_complete_cb complete, int fd)
{
GuestFD *gf = get_guestfd(fd);
if (!gf) {
complete(cs, -1, EBADF);
return;
}
switch (gf->type) {
case GuestFDGDB:
gdb_close(cs, complete, gf);
break;
case GuestFDHost:
host_close(cs, complete, gf);
break;
case GuestFDStatic:
case GuestFDConsole:
complete(cs, 0, 0);
break;
default:
g_assert_not_reached();
}
dealloc_guestfd(fd);
}
void semihost_sys_read_gf(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
/*
* Bound length for 64-bit guests on 32-bit hosts, not overflowing ssize_t.
* Note the Linux kernel does this with MAX_RW_COUNT, so it's not a bad
* idea to do this unconditionally.
*/
if (len > INT32_MAX) {
len = INT32_MAX;
}
switch (gf->type) {
case GuestFDGDB:
gdb_read(cs, complete, gf, buf, len);
break;
case GuestFDHost:
host_read(cs, complete, gf, buf, len);
break;
case GuestFDStatic:
staticfile_read(cs, complete, gf, buf, len);
break;
case GuestFDConsole:
console_read(cs, complete, gf, buf, len);
break;
default:
g_assert_not_reached();
}
}
void semihost_sys_read(CPUState *cs, gdb_syscall_complete_cb complete,
int fd, target_ulong buf, target_ulong len)
{
GuestFD *gf = get_guestfd(fd);
if (gf) {
semihost_sys_read_gf(cs, complete, gf, buf, len);
} else {
complete(cs, -1, EBADF);
}
}
void semihost_sys_write_gf(CPUState *cs, gdb_syscall_complete_cb complete,
GuestFD *gf, target_ulong buf, target_ulong len)
{
/*
* Bound length for 64-bit guests on 32-bit hosts, not overflowing ssize_t.
* Note the Linux kernel does this with MAX_RW_COUNT, so it's not a bad
* idea to do this unconditionally.
*/
if (len > INT32_MAX) {
len = INT32_MAX;
}
switch (gf->type) {
case GuestFDGDB:
gdb_write(cs, complete, gf, buf, len);
break;
case GuestFDHost:
host_write(cs, complete, gf, buf, len);
break;
case GuestFDConsole:
console_write(cs, complete, gf, buf, len);
break;
case GuestFDStatic:
/* Static files are never open for writing: EBADF. */
complete(cs, -1, EBADF);
break;
default:
g_assert_not_reached();
}
}
void semihost_sys_write(CPUState *cs, gdb_syscall_complete_cb complete,
int fd, target_ulong buf, target_ulong len)
{
GuestFD *gf = get_guestfd(fd);
if (gf) {
semihost_sys_write_gf(cs, complete, gf, buf, len);
} else {
complete(cs, -1, EBADF);
}
}
void semihost_sys_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
int fd, int64_t off, int gdb_whence)
{
GuestFD *gf = get_guestfd(fd);
if (!gf) {
complete(cs, -1, EBADF);
return;
}
switch (gf->type) {
case GuestFDGDB:
gdb_lseek(cs, complete, gf, off, gdb_whence);
return;
case GuestFDHost:
host_lseek(cs, complete, gf, off, gdb_whence);
break;
case GuestFDStatic:
staticfile_lseek(cs, complete, gf, off, gdb_whence);
break;
case GuestFDConsole:
complete(cs, -1, ESPIPE);
break;
default:
g_assert_not_reached();
}
}
void semihost_sys_isatty(CPUState *cs, gdb_syscall_complete_cb complete, int fd)
{
GuestFD *gf = get_guestfd(fd);
if (!gf) {
complete(cs, 0, EBADF);
return;
}
switch (gf->type) {
case GuestFDGDB:
gdb_isatty(cs, complete, gf);
break;
case GuestFDHost:
host_isatty(cs, complete, gf);
break;
case GuestFDStatic:
complete(cs, 0, ENOTTY);
break;
case GuestFDConsole:
complete(cs, 1, 0);
break;
default:
g_assert_not_reached();
}
}
void semihost_sys_flen(CPUState *cs, gdb_syscall_complete_cb fstat_cb,
gdb_syscall_complete_cb flen_cb, int fd,
target_ulong fstat_addr)
{
GuestFD *gf = get_guestfd(fd);
if (!gf) {
flen_cb(cs, -1, EBADF);
return;
}
switch (gf->type) {
case GuestFDGDB:
gdb_fstat(cs, fstat_cb, gf, fstat_addr);
break;
case GuestFDHost:
host_flen(cs, flen_cb, gf);
break;
case GuestFDStatic:
staticfile_flen(cs, flen_cb, gf);
break;
case GuestFDConsole:
default:
g_assert_not_reached();
}
}
void semihost_sys_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
int fd, target_ulong addr)
{
GuestFD *gf = get_guestfd(fd);
if (!gf) {
complete(cs, -1, EBADF);
return;
}
switch (gf->type) {
case GuestFDGDB:
gdb_fstat(cs, complete, gf, addr);
break;
case GuestFDHost:
host_fstat(cs, complete, gf, addr);
break;
case GuestFDConsole:
console_fstat(cs, complete, gf, addr);
break;
case GuestFDStatic:
default:
g_assert_not_reached();
}
}
void semihost_sys_stat(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len,
target_ulong addr)
{
if (use_gdb_syscalls()) {
gdb_stat(cs, complete, fname, fname_len, addr);
} else {
host_stat(cs, complete, fname, fname_len, addr);
}
}
void semihost_sys_remove(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len)
{
if (use_gdb_syscalls()) {
gdb_remove(cs, complete, fname, fname_len);
} else {
host_remove(cs, complete, fname, fname_len);
}
}
void semihost_sys_rename(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong oname, target_ulong oname_len,
target_ulong nname, target_ulong nname_len)
{
if (use_gdb_syscalls()) {
gdb_rename(cs, complete, oname, oname_len, nname, nname_len);
} else {
host_rename(cs, complete, oname, oname_len, nname, nname_len);
}
}
void semihost_sys_system(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong cmd, target_ulong cmd_len)
{
if (use_gdb_syscalls()) {
gdb_system(cs, complete, cmd, cmd_len);
} else {
host_system(cs, complete, cmd, cmd_len);
}
}
void semihost_sys_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong tv_addr, target_ulong tz_addr)
{
if (use_gdb_syscalls()) {
gdb_gettimeofday(cs, complete, tv_addr, tz_addr);
} else {
host_gettimeofday(cs, complete, tv_addr, tz_addr);
}
}
#ifndef CONFIG_USER_ONLY
void semihost_sys_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
int fd, GIOCondition cond, int timeout)
{
GuestFD *gf = get_guestfd(fd);
if (!gf) {
complete(cs, G_IO_NVAL, 1);
return;
}
switch (gf->type) {
case GuestFDGDB:
complete(cs, G_IO_NVAL, 1);
break;
case GuestFDHost:
host_poll_one(cs, complete, gf, cond, timeout);
break;
case GuestFDConsole:
console_poll_one(cs, complete, gf, cond, timeout);
break;
case GuestFDStatic:
default:
g_assert_not_reached();
}
}
#endif