[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH v2 23/74] semihosting: Split out semihost_sys_read
From: |
Richard Henderson |
Subject: |
[PATCH v2 23/74] semihosting: Split out semihost_sys_read |
Date: |
Tue, 3 May 2022 12:47:52 -0700 |
Split out the non-ARM specific portions of SYS_READ to a
reusable function. This handles all GuestFD. Isolate the
curious ARM-specific return value processing to a new
callback, common_semi_rw_cb.
Note that gdb_do_syscall %x reads target_ulong, not int.
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
include/semihosting/syscalls.h | 8 ++++
semihosting/arm-compat-semi.c | 84 ++++++++-------------------------
semihosting/syscalls.c | 85 ++++++++++++++++++++++++++++++++++
3 files changed, 112 insertions(+), 65 deletions(-)
diff --git a/include/semihosting/syscalls.h b/include/semihosting/syscalls.h
index 00e718f11d..20da8138b0 100644
--- a/include/semihosting/syscalls.h
+++ b/include/semihosting/syscalls.h
@@ -18,6 +18,8 @@
* or non-zero (where it should include the terminating zero).
*/
+typedef struct GuestFD GuestFD;
+
void semihost_sys_open(CPUState *cs, gdb_syscall_complete_cb complete,
target_ulong fname, target_ulong fname_len,
int gdb_flags, int mode);
@@ -25,4 +27,10 @@ void semihost_sys_open(CPUState *cs, gdb_syscall_complete_cb
complete,
void semihost_sys_close(CPUState *cs, gdb_syscall_complete_cb complete,
int fd);
+void semihost_sys_read(CPUState *cs, gdb_syscall_complete_cb complete,
+ int fd, target_ulong buf, target_ulong len);
+
+void semihost_sys_read_gf(CPUState *cs, gdb_syscall_complete_cb complete,
+ GuestFD *gf, target_ulong buf, target_ulong len);
+
#endif /* SEMIHOSTING_SYSCALLS_H */
diff --git a/semihosting/arm-compat-semi.c b/semihosting/arm-compat-semi.c
index 8ebe3aad55..7b6df09f35 100644
--- a/semihosting/arm-compat-semi.c
+++ b/semihosting/arm-compat-semi.c
@@ -233,7 +233,6 @@ static void common_semi_cb(CPUState *cs, target_ulong ret,
target_ulong err)
target_ulong reg0 = common_semi_arg(cs, 0);
switch (reg0) {
case TARGET_SYS_WRITE:
- case TARGET_SYS_READ:
ret = common_semi_syscall_len - ret;
break;
case TARGET_SYS_SEEK:
@@ -246,6 +245,24 @@ static void common_semi_cb(CPUState *cs, target_ulong ret,
target_ulong err)
common_semi_set_ret(cs, ret);
}
+/*
+ * SYS_READ and SYS_WRITE always return the number of bytes not read/written.
+ * There is no error condition, other than returning the original length.
+ */
+static void common_semi_rw_cb(CPUState *cs, target_ulong ret, target_ulong err)
+{
+ /* Recover the original length from the third argument. */
+ CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
+ target_ulong args = common_semi_arg(cs, 1);
+ target_ulong arg2;
+ GET_ARG(2);
+
+ if (err) {
+ ret = 0; /* error: no bytes transmitted */
+ }
+ common_semi_set_ret(cs, arg2 - ret);
+}
+
/*
* Return an address in target memory of 64 bytes where the remote
* gdb should write its stat struct. (The format of this structure
@@ -279,8 +296,6 @@ common_semi_flen_cb(CPUState *cs, target_ulong ret,
target_ulong err)
*/
typedef void sys_writefn(CPUState *cs, GuestFD *gf,
target_ulong buf, uint32_t len);
-typedef void sys_readfn(CPUState *cs, GuestFD *gf,
- target_ulong buf, uint32_t len);
typedef void sys_isattyfn(CPUState *cs, GuestFD *gf);
typedef void sys_seekfn(CPUState *cs, GuestFD *gf, target_ulong offset);
typedef void sys_flenfn(CPUState *cs, GuestFD *gf);
@@ -303,26 +318,6 @@ static void host_writefn(CPUState *cs, GuestFD *gf,
common_semi_cb(cs, len - ret, 0);
}
-static void host_readfn(CPUState *cs, GuestFD *gf,
- target_ulong buf, uint32_t len)
-{
- CPUArchState *env = cs->env_ptr;
- uint32_t ret = 0;
- char *s = lock_user(VERIFY_WRITE, buf, len, 0);
- (void) env; /* Used in arm softmmu lock_user implicitly */
- if (s) {
- do {
- ret = read(gf->hostfd, s, len);
- } while (ret == -1 && errno == EINTR);
- unlock_user(s, buf, len);
- if (ret == (uint32_t)-1) {
- ret = 0;
- }
- }
- /* Return bytes not read, on error as well. */
- common_semi_cb(cs, len - ret, 0);
-}
-
static void host_isattyfn(CPUState *cs, GuestFD *gf)
{
common_semi_cb(cs, isatty(gf->hostfd), 0);
@@ -352,13 +347,6 @@ static void gdb_writefn(CPUState *cs, GuestFD *gf,
gdb_do_syscall(common_semi_cb, "write,%x,%x,%x", gf->hostfd, buf, len);
}
-static void gdb_readfn(CPUState *cs, GuestFD *gf,
- target_ulong buf, uint32_t len)
-{
- common_semi_syscall_len = len;
- gdb_do_syscall(common_semi_cb, "read,%x,%x,%x", gf->hostfd, buf, len);
-}
-
static void gdb_isattyfn(CPUState *cs, GuestFD *gf)
{
gdb_do_syscall(common_semi_cb, "isatty,%x", gf->hostfd);
@@ -399,30 +387,6 @@ static void staticfile_writefn(CPUState *cs, GuestFD *gf,
common_semi_cb(cs, -1, EBADF);
}
-static void staticfile_readfn(CPUState *cs, GuestFD *gf,
- target_ulong buf, uint32_t len)
-{
- CPUArchState *env = cs->env_ptr;
- uint32_t i = 0;
- char *s;
-
- (void) env; /* Used in arm softmmu lock_user implicitly */
- s = lock_user(VERIFY_WRITE, buf, len, 0);
- if (s) {
- for (i = 0; i < len; i++) {
- if (gf->staticfile.off >= gf->staticfile.len) {
- break;
- }
- s[i] = gf->staticfile.data[gf->staticfile.off];
- gf->staticfile.off++;
- }
- unlock_user(s, buf, len);
- }
-
- /* Return number of bytes not read */
- common_semi_cb(cs, len - i, 0);
-}
-
static void staticfile_isattyfn(CPUState *cs, GuestFD *gf)
{
common_semi_cb(cs, 0, 0);
@@ -441,7 +405,6 @@ static void staticfile_flenfn(CPUState *cs, GuestFD *gf)
typedef struct GuestFDFunctions {
sys_writefn *writefn;
- sys_readfn *readfn;
sys_isattyfn *isattyfn;
sys_seekfn *seekfn;
sys_flenfn *flenfn;
@@ -450,21 +413,18 @@ typedef struct GuestFDFunctions {
static const GuestFDFunctions guestfd_fns[] = {
[GuestFDHost] = {
.writefn = host_writefn,
- .readfn = host_readfn,
.isattyfn = host_isattyfn,
.seekfn = host_seekfn,
.flenfn = host_flenfn,
},
[GuestFDGDB] = {
.writefn = gdb_writefn,
- .readfn = gdb_readfn,
.isattyfn = gdb_isattyfn,
.seekfn = gdb_seekfn,
.flenfn = gdb_flenfn,
},
[GuestFDStatic] = {
.writefn = staticfile_writefn,
- .readfn = staticfile_readfn,
.isattyfn = staticfile_isattyfn,
.seekfn = staticfile_seekfn,
.flenfn = staticfile_flenfn,
@@ -583,13 +543,7 @@ void do_common_semihosting(CPUState *cs)
GET_ARG(0);
GET_ARG(1);
GET_ARG(2);
- len = arg2;
-
- gf = get_guestfd(arg0);
- if (!gf) {
- goto do_badf;
- }
- guestfd_fns[gf->type].readfn(cs, gf, arg1, len);
+ semihost_sys_read(cs, common_semi_rw_cb, arg0, arg1, arg2);
break;
case TARGET_SYS_READC:
diff --git a/semihosting/syscalls.c b/semihosting/syscalls.c
index 9c4b635317..7c18f77898 100644
--- a/semihosting/syscalls.c
+++ b/semihosting/syscalls.c
@@ -130,6 +130,13 @@ static void gdb_close(CPUState *cs,
gdb_syscall_complete_cb complete,
gdb_do_syscall(complete, "close,%x", (target_ulong)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,%x,%x",
+ (target_ulong)gf->hostfd, buf, len);
+}
+
/*
* Host semihosting syscall implementations.
*/
@@ -193,6 +200,54 @@ static void host_close(CPUState *cs,
gdb_syscall_complete_cb complete,
}
}
+static void host_read(CPUState *cs, gdb_syscall_complete_cb complete,
+ GuestFD *gf, target_ulong buf, target_ulong len)
+{
+ CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
+ void *ptr = lock_user(VERIFY_WRITE, buf, len, 0);
+ ssize_t ret;
+
+ if (!ptr) {
+ complete(cs, -1, GDB_EFAULT);
+ return;
+ }
+ do {
+ ret = read(gf->hostfd, ptr, len);
+ } while (ret == -1 && errno == EINTR);
+ if (ret == -1) {
+ complete(cs, -1, errno_for_gdb());
+ unlock_user(ptr, buf, 0);
+ } else {
+ complete(cs, ret, 0);
+ unlock_user(ptr, buf, ret);
+ }
+}
+
+/*
+ * 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 = cs->env_ptr;
+ 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, GDB_EFAULT);
+ return;
+ }
+ memcpy(ptr, gf->staticfile.data + gf->staticfile.off, len);
+ gf->staticfile.off += len;
+ complete(cs, len, 0);
+ unlock_user(ptr, buf, len);
+}
+
/*
* Syscall entry points.
*/
@@ -231,3 +286,33 @@ void semihost_sys_close(CPUState *cs,
gdb_syscall_complete_cb complete, int fd)
}
dealloc_guestfd(fd);
}
+
+void semihost_sys_read_gf(CPUState *cs, gdb_syscall_complete_cb complete,
+ GuestFD *gf, target_ulong buf, target_ulong len)
+{
+ 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;
+ 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, GDB_EBADF);
+ }
+}
--
2.34.1
- [PATCH v2 14/74] include/exec: Define errno values in gdbstub.h, (continued)
- [PATCH v2 14/74] include/exec: Define errno values in gdbstub.h, Richard Henderson, 2022/05/03
- [PATCH v2 15/74] semihosting: Use struct gdb_stat in common_semi_flen_cb, Richard Henderson, 2022/05/03
- [PATCH v2 17/74] semihosting: Split common_semi_flen_buf per target, Richard Henderson, 2022/05/03
- [PATCH v2 16/74] semihosting: Split is_64bit_semihosting per target, Richard Henderson, 2022/05/03
- [PATCH v2 19/74] semihosting: Use env more often in do_common_semihosting, Richard Henderson, 2022/05/03
- [PATCH v2 22/74] semihosting: Split out semihost_sys_close, Richard Henderson, 2022/05/03
- [PATCH v2 21/74] semihosting: Split out semihost_sys_open, Richard Henderson, 2022/05/03
- [PATCH v2 20/74] semihosting: Move GET_ARG/SET_ARG earlier in the file, Richard Henderson, 2022/05/03
- [PATCH v2 23/74] semihosting: Split out semihost_sys_read,
Richard Henderson <=
- [PATCH v2 27/74] semihosting: Split out semihost_sys_isatty, Richard Henderson, 2022/05/03
- [PATCH v2 18/74] semihosting: Split out common_semi_has_synccache, Richard Henderson, 2022/05/03
- [PATCH v2 11/74] semihosting: Move common-semi.h to include/semihosting/, Richard Henderson, 2022/05/03
- [PATCH v2 26/74] semihosting: Split out semihost_sys_lseek, Richard Henderson, 2022/05/03
- [PATCH v2 31/74] semihosting: Split out semihost_sys_system, Richard Henderson, 2022/05/03
- [PATCH v2 24/74] semihosting: Split out semihost_sys_write, Richard Henderson, 2022/05/03
- [PATCH v2 25/74] semihosting: Bound length for semihost_sys_{read, write}, Richard Henderson, 2022/05/03
- [PATCH v2 29/74] semihosting: Split out semihost_sys_remove, Richard Henderson, 2022/05/03
- [PATCH v2 30/74] semihosting: Split out semihost_sys_rename, Richard Henderson, 2022/05/03