From: Richard Henderson <richard.henderson@linaro.org>
To: qemu-devel@nongnu.org
Cc: alex.bennee@linaro.org
Subject: [PATCH v3 09/25] Unify i/o functions and use RisuResult
Date: Thu, 21 May 2020 19:34:24 -0700 [thread overview]
Message-ID: <20200522023440.26261-10-richard.henderson@linaro.org> (raw)
In-Reply-To: <20200522023440.26261-1-richard.henderson@linaro.org>
Push the trace check down from the function calling the reginfo
function down into the i/o function. This means we don't have
to pass a function pointer.
Return a RisuResult from the i/o functions. This fixes a minor bug
in send_register_info (even before the conversion to RisuResult),
which returned the write_fn result directly.
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
risu.h | 32 +++++++++-------------
comms.c | 8 +++---
reginfo.c | 60 ++++++++++++++++++++--------------------
risu.c | 82 ++++++++++++++++++++++---------------------------------
4 files changed, 81 insertions(+), 101 deletions(-)
diff --git a/risu.h b/risu.h
index e6d07eb..c83b803 100644
--- a/risu.h
+++ b/risu.h
@@ -34,13 +34,6 @@ void process_arch_opt(int opt, const char *arg);
#include REGINFO_HEADER(ARCH)
-/* Socket related routines */
-int master_connect(int port);
-int apprentice_connect(const char *hostname, int port);
-int send_data_pkt(int sock, void *pkt, int pktlen);
-int recv_data_pkt(int sock, void *pkt, int pktlen);
-void send_response_byte(int sock, int resp);
-
extern uintptr_t image_start_address;
extern void *memblock;
@@ -80,31 +73,32 @@ typedef struct {
uint32_t risu_op;
} trace_header_t;
+/* Socket related routines */
+int master_connect(int port);
+int apprentice_connect(const char *hostname, int port);
+RisuResult send_data_pkt(int sock, void *pkt, int pktlen);
+RisuResult recv_data_pkt(int sock, void *pkt, int pktlen);
+void send_response_byte(int sock, int resp);
+
/* Functions operating on reginfo */
-/* Function prototypes for read/write helper functions.
- *
- * We pass the helper function to send_register_info and
- * recv_and_compare_register_info which can either be backed by the
- * traditional network socket or a trace file.
- */
-typedef int (*write_fn) (void *ptr, size_t bytes);
-typedef int (*read_fn) (void *ptr, size_t bytes);
-typedef void (*respond_fn) (RisuResult response);
+/* Function prototypes for read/write helper functions. */
+RisuResult write_buffer(void *ptr, size_t bytes);
+RisuResult read_buffer(void *ptr, size_t bytes);
+void respond(RisuResult response);
/*
* Send the register information from the struct ucontext down the socket.
* NB: called from a signal handler.
*/
-RisuResult send_register_info(write_fn write_fn, void *uc);
+RisuResult send_register_info(void *uc);
/*
* Read register info from the socket and compare it with that from the
* ucontext.
* NB: called from a signal handler.
*/
-RisuResult recv_and_compare_register_info(read_fn read_fn,
- respond_fn respond, void *uc);
+RisuResult recv_and_compare_register_info(void *uc);
/* Print a useful report on the status of the last comparison
* done in recv_and_compare_register_info(). This is called on
diff --git a/comms.c b/comms.c
index 861e845..21968da 100644
--- a/comms.c
+++ b/comms.c
@@ -168,7 +168,7 @@ ssize_t safe_writev(int fd, struct iovec *iov_in, int iovcnt)
* Note that both ends must agree on the length of the
* block of data.
*/
-int send_data_pkt(int sock, void *pkt, int pktlen)
+RisuResult send_data_pkt(int sock, void *pkt, int pktlen)
{
unsigned char resp;
/* First we send the packet length as a network-order 32 bit value.
@@ -196,7 +196,7 @@ int send_data_pkt(int sock, void *pkt, int pktlen)
return resp;
}
-int recv_data_pkt(int sock, void *pkt, int pktlen)
+RisuResult recv_data_pkt(int sock, void *pkt, int pktlen)
{
uint32_t net_pktlen;
recv_bytes(sock, &net_pktlen, sizeof(net_pktlen));
@@ -206,10 +206,10 @@ int recv_data_pkt(int sock, void *pkt, int pktlen)
* a response back.
*/
recv_and_discard_bytes(sock, net_pktlen);
- return 1;
+ return RES_BAD_IO;
}
recv_bytes(sock, pkt, pktlen);
- return 0;
+ return RES_OK;
}
void send_response_byte(int sock, int resp)
diff --git a/reginfo.c b/reginfo.c
index b909a1f..fee025e 100644
--- a/reginfo.c
+++ b/reginfo.c
@@ -21,10 +21,11 @@ uint8_t apprentice_memblock[MEMBLOCKLEN];
static int mem_used;
static int packet_mismatch;
-RisuResult send_register_info(write_fn write_fn, void *uc)
+RisuResult send_register_info(void *uc)
{
struct reginfo ri;
trace_header_t header;
+ RisuResult res;
RisuOp op;
reginfo_init(&ri, uc);
@@ -33,8 +34,9 @@ RisuResult send_register_info(write_fn write_fn, void *uc)
/* Write a header with PC/op to keep in sync */
header.pc = get_pc(&ri);
header.risu_op = op;
- if (write_fn(&header, sizeof(header)) != 0) {
- return RES_BAD_IO;
+ res = write_buffer(&header, sizeof(header));
+ if (res != RES_OK) {
+ return res;
}
switch (op) {
@@ -45,11 +47,12 @@ RisuResult send_register_info(write_fn write_fn, void *uc)
* Do a simple register compare on (a) explicit request
* (b) end of test (c) a non-risuop UNDEF
*/
- if (write_fn(&ri, reginfo_size()) != 0) {
- return RES_BAD_IO;
+ res = write_buffer(&ri, reginfo_size());
+ /* For OP_TEST_END, force exit. */
+ if (res == RES_OK && op == OP_TESTEND) {
+ res = RES_END;
}
- /* For OP_TEST_END, force return 1 to exit. */
- return op == OP_TESTEND ? RES_END : RES_OK;
+ break;
case OP_SETMEMBLOCK:
memblock = (void *)(uintptr_t)get_reginfo_paramreg(&ri);
break;
@@ -58,12 +61,11 @@ RisuResult send_register_info(write_fn write_fn, void *uc)
get_reginfo_paramreg(&ri) + (uintptr_t)memblock);
break;
case OP_COMPAREMEM:
- return write_fn(memblock, MEMBLOCKLEN);
- break;
+ return write_buffer(memblock, MEMBLOCKLEN);
default:
abort();
}
- return RES_OK;
+ return res;
}
/* Read register info from the socket and compare it with that from the
@@ -74,29 +76,29 @@ RisuResult send_register_info(write_fn write_fn, void *uc)
* that says whether it is register or memory data, so if the two
* sides get out of sync then we will fail obscurely.
*/
-RisuResult recv_and_compare_register_info(read_fn read_fn,
- respond_fn resp_fn, void *uc)
+RisuResult recv_and_compare_register_info(void *uc)
{
- RisuResult resp = RES_OK;
+ RisuResult res;
trace_header_t header;
RisuOp op;
reginfo_init(&master_ri, uc);
op = get_risuop(&master_ri);
- if (read_fn(&header, sizeof(header)) != 0) {
- return RES_BAD_IO;
+ res = read_buffer(&header, sizeof(header));
+ if (res != RES_OK) {
+ return res;
}
if (header.risu_op != op) {
/* We are out of sync */
- resp = RES_BAD_IO;
- resp_fn(resp);
- return resp;
+ res = RES_BAD_IO;
+ respond(res);
+ return res;
}
/* send OK for the header */
- resp_fn(RES_OK);
+ respond(RES_OK);
switch (op) {
case OP_COMPARE:
@@ -105,16 +107,16 @@ RisuResult recv_and_compare_register_info(read_fn read_fn,
/* Do a simple register compare on (a) explicit request
* (b) end of test (c) a non-risuop UNDEF
*/
- if (read_fn(&apprentice_ri, reginfo_size())) {
+ res = read_buffer(&apprentice_ri, reginfo_size());
+ if (res != RES_OK) {
packet_mismatch = 1;
- resp = RES_BAD_IO;
} else if (!reginfo_is_eq(&master_ri, &apprentice_ri)) {
/* register mismatch */
- resp = RES_MISMATCH;
+ res = RES_MISMATCH;
} else if (op == OP_TESTEND) {
- resp = RES_END;
+ res = RES_END;
}
- resp_fn(resp);
+ respond(res);
break;
case OP_SETMEMBLOCK:
memblock = (void *)(uintptr_t)get_reginfo_paramreg(&master_ri);
@@ -125,20 +127,20 @@ RisuResult recv_and_compare_register_info(read_fn read_fn,
break;
case OP_COMPAREMEM:
mem_used = 1;
- if (read_fn(apprentice_memblock, MEMBLOCKLEN)) {
+ res = read_buffer(apprentice_memblock, MEMBLOCKLEN);
+ if (res != RES_OK) {
packet_mismatch = 1;
- resp = RES_BAD_IO;
} else if (memcmp(memblock, apprentice_memblock, MEMBLOCKLEN) != 0) {
/* memory mismatch */
- resp = RES_MISMATCH;
+ res = RES_MISMATCH;
}
- resp_fn(resp);
+ respond(res);
break;
default:
abort();
}
- return resp;
+ return res;
}
/* Print a useful report on the status of the last comparison
diff --git a/risu.c b/risu.c
index 7b14f72..1917311 100644
--- a/risu.c
+++ b/risu.c
@@ -46,44 +46,15 @@ static sigjmp_buf jmpbuf;
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-/* Master functions */
+/* I/O functions */
-int read_sock(void *ptr, size_t bytes)
-{
- return recv_data_pkt(comm_fd, ptr, bytes);
-}
-
-int write_trace(void *ptr, size_t bytes)
+RisuResult read_buffer(void *ptr, size_t bytes)
{
size_t res;
-#ifdef HAVE_ZLIB
- if (comm_fd == STDOUT_FILENO) {
-#endif
- res = write(comm_fd, ptr, bytes);
-#ifdef HAVE_ZLIB
- } else {
- res = gzwrite(gz_trace_file, ptr, bytes);
+ if (!trace) {
+ return recv_data_pkt(comm_fd, ptr, bytes);
}
-#endif
- return (res == bytes) ? 0 : 1;
-}
-
-void respond_sock(RisuResult r)
-{
- send_response_byte(comm_fd, r);
-}
-
-/* Apprentice function */
-
-int write_sock(void *ptr, size_t bytes)
-{
- return send_data_pkt(comm_fd, ptr, bytes);
-}
-
-int read_trace(void *ptr, size_t bytes)
-{
- size_t res;
#ifdef HAVE_ZLIB
if (comm_fd == STDIN_FILENO) {
@@ -95,21 +66,34 @@ int read_trace(void *ptr, size_t bytes)
}
#endif
- return (res == bytes) ? 0 : 1;
+ return res == bytes ? RES_OK : RES_BAD_IO;
}
-void respond_trace(RisuResult r)
+RisuResult write_buffer(void *ptr, size_t bytes)
{
- switch (r) {
- case RES_OK:
- case RES_END:
- break;
- default:
- /* mismatch - if tracing we need to report, otherwise barf */
- if (!trace) {
- abort();
- }
- break;
+ size_t res;
+
+ if (!trace) {
+ return send_data_pkt(comm_fd, ptr, bytes);
+ }
+
+#ifdef HAVE_ZLIB
+ if (comm_fd == STDOUT_FILENO) {
+#endif
+ res = write(comm_fd, ptr, bytes);
+#ifdef HAVE_ZLIB
+ } else {
+ res = gzwrite(gz_trace_file, ptr, bytes);
+ }
+#endif
+
+ return res == bytes ? RES_OK : RES_BAD_IO;
+}
+
+void respond(RisuResult r)
+{
+ if (!trace) {
+ send_response_byte(comm_fd, r);
}
}
@@ -119,9 +103,9 @@ static void master_sigill(int sig, siginfo_t *si, void *uc)
signal_count++;
if (trace) {
- r = send_register_info(write_trace, uc);
+ r = send_register_info(uc);
} else {
- r = recv_and_compare_register_info(read_sock, respond_sock, uc);
+ r = recv_and_compare_register_info(uc);
}
switch (r) {
@@ -141,9 +125,9 @@ static void apprentice_sigill(int sig, siginfo_t *si, void *uc)
signal_count++;
if (trace) {
- r = recv_and_compare_register_info(read_trace, respond_trace, uc);
+ r = recv_and_compare_register_info(uc);
} else {
- r = send_register_info(write_sock, uc);
+ r = send_register_info(uc);
}
switch (r) {
--
2.20.1
next prev parent reply other threads:[~2020-05-22 2:41 UTC|newest]
Thread overview: 49+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-05-22 2:34 [PATCH v3 00/25] risu cleanups and improvements Richard Henderson
2020-05-22 2:34 ` [PATCH v3 01/25] Use bool for tracing variables Richard Henderson
2020-05-22 2:34 ` [PATCH v3 02/25] Unify master_fd and apprentice_fd to comm_fd Richard Henderson
2020-05-22 2:34 ` [PATCH v3 03/25] Hoist trace file and socket opening Richard Henderson
2020-05-22 2:34 ` [PATCH v3 04/25] Adjust tracefile open for write Richard Henderson
2020-05-22 2:34 ` [PATCH v3 05/25] Use EXIT_FAILURE, EXIT_SUCCESS Richard Henderson
2020-05-22 2:34 ` [PATCH v3 06/25] Make some risu.c symbols static Richard Henderson
2020-05-22 2:34 ` [PATCH v3 07/25] Add enum RisuOp Richard Henderson
2020-05-22 2:34 ` [PATCH v3 08/25] Add enum RisuResult Richard Henderson
2020-05-22 2:34 ` Richard Henderson [this message]
2020-05-22 2:34 ` [PATCH v3 10/25] Pass non-OK result back through siglongjmp Richard Henderson
2020-05-22 2:34 ` [PATCH v3 11/25] Always write for --master Richard Henderson
2020-05-22 2:34 ` [PATCH v3 12/25] Simplify syncing with master Richard Henderson
2020-05-22 2:34 ` [PATCH v3 13/25] Split RES_MISMATCH for registers and memory Richard Henderson
2020-05-22 2:34 ` [PATCH v3 14/25] Merge reginfo.c into risu.c Richard Henderson
2020-06-23 8:33 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 15/25] Rearrange reginfo and memblock buffers Richard Henderson
2020-06-23 8:47 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 16/25] Split out recv_register_info Richard Henderson
2020-06-23 10:38 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 17/25] Add magic and size to the trace header Richard Henderson
2020-06-23 14:52 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 18/25] Compute reginfo_size based on the reginfo Richard Henderson
2020-06-23 14:54 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 19/25] aarch64: Reorg sve reginfo to save space Richard Henderson
2020-06-23 16:32 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 20/25] aarch64: Use arch_init to configure sve Richard Henderson
2020-06-23 16:54 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 21/25] ppc64: Use uint64_t to represent double Richard Henderson
2020-06-23 16:58 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 22/25] Standardize reginfo_dump_mismatch printing Richard Henderson
2020-06-23 17:03 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 23/25] Add --fulldump and --diffdup options Richard Henderson
2020-05-22 2:34 ` [PATCH v3 24/25] Remove return value from reginfo_dump Richard Henderson
2020-06-23 17:38 ` Alex Bennée
2020-05-22 2:34 ` [PATCH v3 25/25] ppc64: Clean up reginfo handling Richard Henderson
2020-05-22 4:10 ` Richard Henderson
2020-06-23 17:45 ` Alex Bennée
2020-06-23 18:06 ` Richard Henderson
2020-06-22 19:17 ` [PATCH v3 00/25] risu cleanups and improvements Peter Maydell
2020-06-23 8:23 ` Alex Bennée
2020-06-23 9:00 ` Alex Bennée
2020-06-23 13:30 ` Alex Bennée
2020-06-23 20:26 ` Richard Henderson
2020-06-23 14:44 ` [PATCH] risu: don't do a full register compare for OP_SIGILL Alex Bennée
2020-06-23 15:23 ` Richard Henderson
2020-06-23 15:54 ` Peter Maydell
2020-06-23 16:17 ` Alex Bennée
2020-06-23 19:55 ` Richard Henderson
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20200522023440.26261-10-richard.henderson@linaro.org \
--to=richard.henderson@linaro.org \
--cc=alex.bennee@linaro.org \
--cc=qemu-devel@nongnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).