In preparation for having some more common semihosting code let's excise the current config magic from vl.c into its own file. We shall later add more conditionals to the build configurations so we can avoid building this if we don't need it. Signed-off-by: Alex Bennée <alex.bennee@linaro.org> Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com> Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
445 lines
14 KiB
C
445 lines
14 KiB
C
/*
|
|
* Copyright (c) 2011, Max Filippov, Open Source and Linux Lab.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the Open Source and Linux Lab nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "cpu.h"
|
|
#include "chardev/char-fe.h"
|
|
#include "exec/helper-proto.h"
|
|
#include "hw/semihosting/semihost.h"
|
|
#include "qapi/error.h"
|
|
#include "qemu/log.h"
|
|
#include "sysemu/sysemu.h"
|
|
|
|
enum {
|
|
TARGET_SYS_exit = 1,
|
|
TARGET_SYS_read = 3,
|
|
TARGET_SYS_write = 4,
|
|
TARGET_SYS_open = 5,
|
|
TARGET_SYS_close = 6,
|
|
TARGET_SYS_lseek = 19,
|
|
TARGET_SYS_select_one = 29,
|
|
|
|
TARGET_SYS_argc = 1000,
|
|
TARGET_SYS_argv_sz = 1001,
|
|
TARGET_SYS_argv = 1002,
|
|
TARGET_SYS_memset = 1004,
|
|
};
|
|
|
|
enum {
|
|
SELECT_ONE_READ = 1,
|
|
SELECT_ONE_WRITE = 2,
|
|
SELECT_ONE_EXCEPT = 3,
|
|
};
|
|
|
|
enum {
|
|
TARGET_EPERM = 1,
|
|
TARGET_ENOENT = 2,
|
|
TARGET_ESRCH = 3,
|
|
TARGET_EINTR = 4,
|
|
TARGET_EIO = 5,
|
|
TARGET_ENXIO = 6,
|
|
TARGET_E2BIG = 7,
|
|
TARGET_ENOEXEC = 8,
|
|
TARGET_EBADF = 9,
|
|
TARGET_ECHILD = 10,
|
|
TARGET_EAGAIN = 11,
|
|
TARGET_ENOMEM = 12,
|
|
TARGET_EACCES = 13,
|
|
TARGET_EFAULT = 14,
|
|
TARGET_ENOTBLK = 15,
|
|
TARGET_EBUSY = 16,
|
|
TARGET_EEXIST = 17,
|
|
TARGET_EXDEV = 18,
|
|
TARGET_ENODEV = 19,
|
|
TARGET_ENOTDIR = 20,
|
|
TARGET_EISDIR = 21,
|
|
TARGET_EINVAL = 22,
|
|
TARGET_ENFILE = 23,
|
|
TARGET_EMFILE = 24,
|
|
TARGET_ENOTTY = 25,
|
|
TARGET_ETXTBSY = 26,
|
|
TARGET_EFBIG = 27,
|
|
TARGET_ENOSPC = 28,
|
|
TARGET_ESPIPE = 29,
|
|
TARGET_EROFS = 30,
|
|
TARGET_EMLINK = 31,
|
|
TARGET_EPIPE = 32,
|
|
TARGET_EDOM = 33,
|
|
TARGET_ERANGE = 34,
|
|
TARGET_ENOSYS = 88,
|
|
TARGET_ELOOP = 92,
|
|
};
|
|
|
|
static uint32_t errno_h2g(int host_errno)
|
|
{
|
|
static const uint32_t guest_errno[] = {
|
|
[EPERM] = TARGET_EPERM,
|
|
[ENOENT] = TARGET_ENOENT,
|
|
[ESRCH] = TARGET_ESRCH,
|
|
[EINTR] = TARGET_EINTR,
|
|
[EIO] = TARGET_EIO,
|
|
[ENXIO] = TARGET_ENXIO,
|
|
[E2BIG] = TARGET_E2BIG,
|
|
[ENOEXEC] = TARGET_ENOEXEC,
|
|
[EBADF] = TARGET_EBADF,
|
|
[ECHILD] = TARGET_ECHILD,
|
|
[EAGAIN] = TARGET_EAGAIN,
|
|
[ENOMEM] = TARGET_ENOMEM,
|
|
[EACCES] = TARGET_EACCES,
|
|
[EFAULT] = TARGET_EFAULT,
|
|
#ifdef ENOTBLK
|
|
[ENOTBLK] = TARGET_ENOTBLK,
|
|
#endif
|
|
[EBUSY] = TARGET_EBUSY,
|
|
[EEXIST] = TARGET_EEXIST,
|
|
[EXDEV] = TARGET_EXDEV,
|
|
[ENODEV] = TARGET_ENODEV,
|
|
[ENOTDIR] = TARGET_ENOTDIR,
|
|
[EISDIR] = TARGET_EISDIR,
|
|
[EINVAL] = TARGET_EINVAL,
|
|
[ENFILE] = TARGET_ENFILE,
|
|
[EMFILE] = TARGET_EMFILE,
|
|
[ENOTTY] = TARGET_ENOTTY,
|
|
#ifdef ETXTBSY
|
|
[ETXTBSY] = TARGET_ETXTBSY,
|
|
#endif
|
|
[EFBIG] = TARGET_EFBIG,
|
|
[ENOSPC] = TARGET_ENOSPC,
|
|
[ESPIPE] = TARGET_ESPIPE,
|
|
[EROFS] = TARGET_EROFS,
|
|
[EMLINK] = TARGET_EMLINK,
|
|
[EPIPE] = TARGET_EPIPE,
|
|
[EDOM] = TARGET_EDOM,
|
|
[ERANGE] = TARGET_ERANGE,
|
|
[ENOSYS] = TARGET_ENOSYS,
|
|
#ifdef ELOOP
|
|
[ELOOP] = TARGET_ELOOP,
|
|
#endif
|
|
};
|
|
|
|
if (host_errno == 0) {
|
|
return 0;
|
|
} else if (host_errno > 0 && host_errno < ARRAY_SIZE(guest_errno) &&
|
|
guest_errno[host_errno]) {
|
|
return guest_errno[host_errno];
|
|
} else {
|
|
return TARGET_EINVAL;
|
|
}
|
|
}
|
|
|
|
typedef struct XtensaSimConsole {
|
|
CharBackend be;
|
|
struct {
|
|
char buffer[16];
|
|
size_t offset;
|
|
} input;
|
|
} XtensaSimConsole;
|
|
|
|
static XtensaSimConsole *sim_console;
|
|
|
|
static IOCanReadHandler sim_console_can_read;
|
|
static int sim_console_can_read(void *opaque)
|
|
{
|
|
XtensaSimConsole *p = opaque;
|
|
|
|
return sizeof(p->input.buffer) - p->input.offset;
|
|
}
|
|
|
|
static IOReadHandler sim_console_read;
|
|
static void sim_console_read(void *opaque, const uint8_t *buf, int size)
|
|
{
|
|
XtensaSimConsole *p = opaque;
|
|
size_t copy = sizeof(p->input.buffer) - p->input.offset;
|
|
|
|
if (size < copy) {
|
|
copy = size;
|
|
}
|
|
memcpy(p->input.buffer + p->input.offset, buf, copy);
|
|
p->input.offset += copy;
|
|
}
|
|
|
|
void xtensa_sim_open_console(Chardev *chr)
|
|
{
|
|
static XtensaSimConsole console;
|
|
|
|
qemu_chr_fe_init(&console.be, chr, &error_abort);
|
|
qemu_chr_fe_set_handlers(&console.be,
|
|
sim_console_can_read,
|
|
sim_console_read,
|
|
NULL, NULL, &console,
|
|
NULL, true);
|
|
sim_console = &console;
|
|
}
|
|
|
|
void HELPER(simcall)(CPUXtensaState *env)
|
|
{
|
|
CPUState *cs = CPU(xtensa_env_get_cpu(env));
|
|
uint32_t *regs = env->regs;
|
|
|
|
switch (regs[2]) {
|
|
case TARGET_SYS_exit:
|
|
exit(regs[3]);
|
|
break;
|
|
|
|
case TARGET_SYS_read:
|
|
case TARGET_SYS_write:
|
|
{
|
|
bool is_write = regs[2] == TARGET_SYS_write;
|
|
uint32_t fd = regs[3];
|
|
uint32_t vaddr = regs[4];
|
|
uint32_t len = regs[5];
|
|
uint32_t len_done = 0;
|
|
|
|
while (len > 0) {
|
|
hwaddr paddr = cpu_get_phys_page_debug(cs, vaddr);
|
|
uint32_t page_left =
|
|
TARGET_PAGE_SIZE - (vaddr & (TARGET_PAGE_SIZE - 1));
|
|
uint32_t io_sz = page_left < len ? page_left : len;
|
|
hwaddr sz = io_sz;
|
|
void *buf = cpu_physical_memory_map(paddr, &sz, !is_write);
|
|
uint32_t io_done;
|
|
bool error = false;
|
|
|
|
if (buf) {
|
|
vaddr += io_sz;
|
|
len -= io_sz;
|
|
if (fd < 3 && sim_console) {
|
|
if (is_write && (fd == 1 || fd == 2)) {
|
|
io_done = qemu_chr_fe_write_all(&sim_console->be,
|
|
buf, io_sz);
|
|
regs[3] = errno_h2g(errno);
|
|
} else if (!is_write && fd == 0) {
|
|
if (sim_console->input.offset) {
|
|
io_done = sim_console->input.offset;
|
|
if (io_sz < io_done) {
|
|
io_done = io_sz;
|
|
}
|
|
memcpy(buf, sim_console->input.buffer, io_done);
|
|
memmove(sim_console->input.buffer,
|
|
sim_console->input.buffer + io_done,
|
|
sim_console->input.offset - io_done);
|
|
sim_console->input.offset -= io_done;
|
|
qemu_chr_fe_accept_input(&sim_console->be);
|
|
} else {
|
|
io_done = -1;
|
|
regs[3] = TARGET_EAGAIN;
|
|
}
|
|
} else {
|
|
qemu_log_mask(LOG_GUEST_ERROR,
|
|
"%s fd %d is not supported with chardev console\n",
|
|
is_write ?
|
|
"writing to" : "reading from", fd);
|
|
io_done = -1;
|
|
regs[3] = TARGET_EBADF;
|
|
}
|
|
} else {
|
|
io_done = is_write ?
|
|
write(fd, buf, io_sz) :
|
|
read(fd, buf, io_sz);
|
|
regs[3] = errno_h2g(errno);
|
|
}
|
|
if (io_done == -1) {
|
|
error = true;
|
|
io_done = 0;
|
|
}
|
|
cpu_physical_memory_unmap(buf, sz, !is_write, io_done);
|
|
} else {
|
|
error = true;
|
|
regs[3] = TARGET_EINVAL;
|
|
break;
|
|
}
|
|
if (error) {
|
|
if (!len_done) {
|
|
len_done = -1;
|
|
}
|
|
break;
|
|
}
|
|
len_done += io_done;
|
|
if (io_done < io_sz) {
|
|
break;
|
|
}
|
|
}
|
|
regs[2] = len_done;
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_open:
|
|
{
|
|
char name[1024];
|
|
int rc;
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(name); ++i) {
|
|
rc = cpu_memory_rw_debug(cs, regs[3] + i,
|
|
(uint8_t *)name + i, 1, 0);
|
|
if (rc != 0 || name[i] == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (rc == 0 && i < ARRAY_SIZE(name)) {
|
|
regs[2] = open(name, regs[4], regs[5]);
|
|
regs[3] = errno_h2g(errno);
|
|
} else {
|
|
regs[2] = -1;
|
|
regs[3] = TARGET_EINVAL;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_close:
|
|
if (regs[3] < 3) {
|
|
regs[2] = regs[3] = 0;
|
|
} else {
|
|
regs[2] = close(regs[3]);
|
|
regs[3] = errno_h2g(errno);
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_lseek:
|
|
regs[2] = lseek(regs[3], (off_t)(int32_t)regs[4], regs[5]);
|
|
regs[3] = errno_h2g(errno);
|
|
break;
|
|
|
|
case TARGET_SYS_select_one:
|
|
{
|
|
uint32_t fd = regs[3];
|
|
uint32_t rq = regs[4];
|
|
uint32_t target_tv = regs[5];
|
|
uint32_t target_tvv[2];
|
|
|
|
struct timeval tv = {0};
|
|
|
|
if (target_tv) {
|
|
cpu_memory_rw_debug(cs, target_tv,
|
|
(uint8_t *)target_tvv, sizeof(target_tvv), 0);
|
|
tv.tv_sec = (int32_t)tswap32(target_tvv[0]);
|
|
tv.tv_usec = (int32_t)tswap32(target_tvv[1]);
|
|
}
|
|
if (fd < 3 && sim_console) {
|
|
if ((fd == 1 || fd == 2) && rq == SELECT_ONE_WRITE) {
|
|
regs[2] = 1;
|
|
} else if (fd == 0 && rq == SELECT_ONE_READ) {
|
|
regs[2] = sim_console->input.offset > 0;
|
|
} else {
|
|
regs[2] = 0;
|
|
}
|
|
regs[3] = 0;
|
|
} else {
|
|
fd_set fdset;
|
|
|
|
FD_ZERO(&fdset);
|
|
FD_SET(fd, &fdset);
|
|
regs[2] = select(fd + 1,
|
|
rq == SELECT_ONE_READ ? &fdset : NULL,
|
|
rq == SELECT_ONE_WRITE ? &fdset : NULL,
|
|
rq == SELECT_ONE_EXCEPT ? &fdset : NULL,
|
|
target_tv ? &tv : NULL);
|
|
regs[3] = errno_h2g(errno);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_argc:
|
|
regs[2] = semihosting_get_argc();
|
|
regs[3] = 0;
|
|
break;
|
|
|
|
case TARGET_SYS_argv_sz:
|
|
{
|
|
int argc = semihosting_get_argc();
|
|
int sz = (argc + 1) * sizeof(uint32_t);
|
|
int i;
|
|
|
|
for (i = 0; i < argc; ++i) {
|
|
sz += 1 + strlen(semihosting_get_arg(i));
|
|
}
|
|
regs[2] = sz;
|
|
regs[3] = 0;
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_argv:
|
|
{
|
|
int argc = semihosting_get_argc();
|
|
int str_offset = (argc + 1) * sizeof(uint32_t);
|
|
int i;
|
|
uint32_t argptr;
|
|
|
|
for (i = 0; i < argc; ++i) {
|
|
const char *str = semihosting_get_arg(i);
|
|
int str_size = strlen(str) + 1;
|
|
|
|
argptr = tswap32(regs[3] + str_offset);
|
|
|
|
cpu_memory_rw_debug(cs,
|
|
regs[3] + i * sizeof(uint32_t),
|
|
(uint8_t *)&argptr, sizeof(argptr), 1);
|
|
cpu_memory_rw_debug(cs,
|
|
regs[3] + str_offset,
|
|
(uint8_t *)str, str_size, 1);
|
|
str_offset += str_size;
|
|
}
|
|
argptr = 0;
|
|
cpu_memory_rw_debug(cs,
|
|
regs[3] + i * sizeof(uint32_t),
|
|
(uint8_t *)&argptr, sizeof(argptr), 1);
|
|
regs[3] = 0;
|
|
}
|
|
break;
|
|
|
|
case TARGET_SYS_memset:
|
|
{
|
|
uint32_t base = regs[3];
|
|
uint32_t sz = regs[5];
|
|
|
|
while (sz) {
|
|
hwaddr len = sz;
|
|
void *buf = cpu_physical_memory_map(base, &len, 1);
|
|
|
|
if (buf && len) {
|
|
memset(buf, regs[4], len);
|
|
cpu_physical_memory_unmap(buf, len, 1, len);
|
|
} else {
|
|
len = 1;
|
|
}
|
|
base += len;
|
|
sz -= len;
|
|
}
|
|
regs[2] = regs[3];
|
|
regs[3] = 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
qemu_log_mask(LOG_GUEST_ERROR, "%s(%d): not implemented\n", __func__, regs[2]);
|
|
regs[2] = -1;
|
|
regs[3] = TARGET_ENOSYS;
|
|
break;
|
|
}
|
|
}
|