[Qemu-devel] [RISU PATCH 0/9] Record/playback patches

[Qemu-devel] [RISU PATCH 0/9] Record/playback patches

[Alex Bennée]

Hi Peter,

I've been cleaning things up so I thought I should re-post my current
state. These all apply to the current master.

I had to regenerate all the risu binaries as I'd used --no-fp for a
bunch of them originally which was causing failures. I'm not sure if
this is due to the FP registers not being cleared by the kernel if FP
isn't used - but we certainly don't do anything to them except when
set by the memory/context blocks (without --no-fp). This led me to
write the 3 noddy scripts included here.

The record/playback is still aarch64 only. I'm open to ideas to do
this more cleanly otherwise if anyone has access to some PPC hardware
I can port the record/playback code to the other architectures.

Feel free to cherry-pick any of the minor patches as you wish ;-)

Alex Bennée (9):
  risu: a bit more verbosity when running
  aarch64: add hand-coded risu skeleton for directed testing
  risu: add simple trace and replay support
  risu: add support compressed tracefiles
  risu_aarch64: it's -> it is
  risugen: remove grocer's apostrophe from REs
  new: generate_all.sh script
  new: record_traces.sh helper script
  new: run_risu.sh script

 Makefile                      |  10 +-
 aarch64_simd_handcoded.risu.S | 208 ++++++++++++++++++++++++++++++++++++++++++
 configure                     |  55 +++++++++++
 generate_all.sh               |  55 +++++++++++
 record_traces.sh              |  16 ++++
 risu.c                        | 116 ++++++++++++++++++-----
 risu.h                        |  15 +++
 risu_aarch64.c                |  89 +++++++++++++++++-
 risu_reginfo_aarch64.h        |   7 ++
 risugen                       |   2 +-
 run_risu.sh                   |  51 +++++++++++
 11 files changed, 598 insertions(+), 26 deletions(-)
 create mode 100644 aarch64_simd_handcoded.risu.S
 create mode 100755 generate_all.sh
 create mode 100755 record_traces.sh
 create mode 100755 run_risu.sh

-- 
2.10.2

[Qemu-devel] [RISU PATCH 1/9] risu: a bit more verbosity when running

[Alex Bennée]

Before this is could seem a little quite when running as you had no
indication stuff was happening (or how fast). I only dump on the master
side as I want to minimise the amount of qemu logs to sift through.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 risu.c         | 15 +++++++++++++--
 risu.h         |  3 +++
 risu_aarch64.c |  3 +++
 3 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/risu.c b/risu.c
index 7e42160..756ca46 100644
--- a/risu.c
+++ b/risu.c
@@ -37,6 +37,16 @@ sigjmp_buf jmpbuf;
 /* Should we test for FP exception status bits? */
 int test_fp_exc = 0;
 
+long executed_tests = 0;
+void report_test_status(void *pc)
+{
+   executed_tests += 1;
+   if (executed_tests % 100 == 0) {
+      fprintf(stderr,"Executed %ld test instructions (pc=%p)\r",
+              executed_tests, pc);
+   }
+}
+
 void master_sigill(int sig, siginfo_t *si, void *uc)
 {
    switch (recv_and_compare_register_info(master_socket, uc))
@@ -61,6 +71,7 @@ void apprentice_sigill(int sig, siginfo_t *si, void *uc)
          return;
       case 1:
          /* end of test */
+         fprintf(stderr, "\nend of test\n");
          exit(0);
       default:
          /* mismatch */
@@ -129,7 +140,7 @@ int master(int sock)
    }
    master_socket = sock;
    set_sigill_handler(&master_sigill);
-   fprintf(stderr, "starting image\n");
+   fprintf(stderr, "starting master image at 0x%lx\n", image_start_address);
    image_start();
    fprintf(stderr, "image returned unexpectedly\n");
    exit(1);
@@ -139,7 +150,7 @@ int apprentice(int sock)
 {
    apprentice_socket = sock;
    set_sigill_handler(&apprentice_sigill);
-   fprintf(stderr, "starting image\n");
+   fprintf(stderr, "starting apprentice image at 0x%lx\n", image_start_address);
    image_start();
    fprintf(stderr, "image returned unexpectedly\n");
    exit(1);
diff --git a/risu.h b/risu.h
index 26ed834..e4bb323 100644
--- a/risu.h
+++ b/risu.h
@@ -26,6 +26,7 @@ extern uintptr_t image_start_address;
 extern void *memblock;
 
 extern int test_fp_exc;
+extern int ismaster;
 
 /* Ops code under test can request from risu: */
 #define OP_COMPARE 0
@@ -59,6 +60,8 @@ int recv_and_compare_register_info(int sock, void *uc);
  */
 int report_match_status(void);
 
+void report_test_status(void *pc);
+
 /* Move the PC past this faulting insn by adjusting ucontext
  */
 void advance_pc(void *uc);
diff --git a/risu_aarch64.c b/risu_aarch64.c
index 547f987..1595604 100644
--- a/risu_aarch64.c
+++ b/risu_aarch64.c
@@ -28,6 +28,9 @@ void advance_pc(void *vuc)
 {
     ucontext_t *uc = vuc;
     uc->uc_mcontext.pc += 4;
+    if (ismaster) {
+      report_test_status((void *) uc->uc_mcontext.pc);
+    }
 }
 
 static void set_x0(void *vuc, uint64_t x0)
-- 
2.10.2

[Qemu-devel] [RISU PATCH 2/9] aarch64: add hand-coded risu skeleton for directed testing

[Alex Bennée]

Sometimes you want absolute control over your test set-up to feed
explicit values into the test. This started as an experiment but might
be useful for further developing tests.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 Makefile                      |   7 ++
 aarch64_simd_handcoded.risu.S | 208 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 215 insertions(+)
 create mode 100644 aarch64_simd_handcoded.risu.S

diff --git a/Makefile b/Makefile
index bfa8cac..4202c35 100644
--- a/Makefile
+++ b/Makefile
@@ -36,6 +36,13 @@ $(PROG): $(OBJS)
 %.risu.asm: %.risu.bin
 	${OBJDUMP} -b binary -m $(ARCH) -D $^ > $@
 
+# hand-coded tests
+%.risu.bin: %.risu.elf
+	$(OBJCOPY) -O binary $< $@
+
+%.risu.elf: %.risu.S
+	${AS} -o $@ $^
+
 %.o: %.c $(HDRS)
 	$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ -c $<
 
diff --git a/aarch64_simd_handcoded.risu.S b/aarch64_simd_handcoded.risu.S
new file mode 100644
index 0000000..61bd11a
--- /dev/null
+++ b/aarch64_simd_handcoded.risu.S
@@ -0,0 +1,208 @@
+/*
+    Hand coded RISU tests for aarch64
+
+    Sometimes you want slightly more than random instructions and you
+    want a specifically crafted test but within RISU's framework.
+
+    This file offers such a thing.
+        # So the last nibble indicates the desired operation:
+my $OP_COMPARE = 0;        # compare registers
+my $OP_TESTEND = 1;        # end of test, stop
+my $OP_SETMEMBLOCK = 2;    # r0 is address of memory block (8192 bytes)
+my $OP_GETMEMBLOCK = 3;    # add the address of memory block to r0
+my $OP_COMPAREMEM = 4;     # compare memory block
+
+        */
+
+.macro  risuop_comp
+        .word   0x00005af0
+.endm
+.macro  risuop_testend
+        .word   0x00005af1
+.endm
+
+        .org    0x0
+        
+//.globl	.data
+ 	mov	x0, #0x0                   	// #0
+ 	msr	fpsr, x0
+ 	mov	x0, #0x0                   	// #0
+ 	msr	fpcr, x0
+ 	mrs	x0, nzcv
+ 	eor	w0, w0, #0xf0000000
+ 	msr	nzcv, x0
+ 	adr	x0, _q0
+ 	eor	x0, x0, #0xf
+ 	b	reg_setup
+
+        /*
+
+        This is the of block of data used for ld/st and setting up vector regs
+        Each .word is 32bits of data
+
+        */
+        .align  16
+        
+_q0:    .word   0x70000000, 0xffffffff, 0x80000000, 0xffffffff
+_q1:    .word   0x90000000, 0x00000000, 0xa0000000, 0x00000000
+_q2:    .word   0xffff0000, 0x00000000, 0xeeee0000, 0x00000000
+_q3:    .word   0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
+_q4:    .word   0x80000000, 0x00000000, 0xf0000000, 0x00000000
+_q5:    .word   0xffff0000, 0x00000000, 0xeeee0000, 0x00000000
+_q6:    .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q7:    .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+_q8:    .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q9:    .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q10:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q11:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q12:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q13:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q14:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q15:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+_q16:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q17:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q18:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q19:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q20:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q21:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q22:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q23:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+
+_q24:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q25:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q26:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q27:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q28:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q29:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q30:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+_q31:   .word   0x00000000, 0x00000000, 0x00000000, 0x00000000
+        
+        .align  16
+
+        /* Setup the register state */
+reg_setup:
+ 	ldp	q0, q1, [x0],#32
+ 	ldp	q2, q3, [x0],#16
+ 	ldp	q4, q5, [x0],#16
+ 	ldp	q6, q7, [x0],#16
+ 	ldp	q8, q9, [x0],#16
+ 	ldp	q10, q11, [x0],#16
+ 	ldp	q12, q13, [x0],#16
+ 	ldp	q14, q15, [x0],#16
+ 	ldp	q16, q17, [x0],#16
+ 	ldp	q18, q19, [x0],#16
+ 	ldp	q20, q21, [x0],#16
+ 	ldp	q22, q23, [x0],#16
+ 	ldp	q24, q25, [x0],#16
+ 	ldp	q26, q27, [x0],#16
+ 	ldp	q28, q29, [x0],#16
+ 	ldp	q30, q31, [x0],#16
+
+        /* Set-up integer registers */
+        mov     x0, #0
+        mov     x1, #0
+        mov     x2, #0
+        mov     x3, #0
+        mov     x4, #0
+        mov     x5, #0
+        mov     x6, #0
+        mov     x7, #0
+        mov     x8, #0
+        mov     x9, #0
+        mov     x10, #0
+        mov     x11, #0
+        mov     x12, #0
+        mov     x13, #0
+        mov     x14, #0
+        mov     x15, #0
+        mov     x16, #0
+        mov     x17, #0
+        mov     x18, #0
+        mov     x19, #0
+        mov     x20, #0
+        mov     x21, #0
+        mov     x22, #0
+        mov     x23, #0
+        mov     x24, #0
+        mov     x25, #0
+        mov     x26, #0
+        mov     x26, #0
+        mov     x27, #0
+        mov     x28, #0
+        mov     x29, #0
+        mov     x30, #0
+
+        risuop_comp
+
+        /* Testing ursra */
+        
+ 	ursra	v16.2d, v0.2d, #64
+        risuop_comp
+ 	ursra	v17.2d, v1.2d, #64
+        risuop_comp
+ 	ursra	v18.2d, v2.2d, #64
+        risuop_comp
+ 	ursra	v19.2d, v3.2d, #64
+        risuop_comp
+ 	ursra	v20.2d, v4.2d, #64
+        risuop_comp
+ 	ursra	v21.2d, v5.2d, #64
+        risuop_comp
+ 	ursra	v22.2d, v6.2d, #64
+        risuop_comp
+ 	ursra	v23.2d, v7.2d, #64
+        risuop_comp
+ 	ursra	v24.2d, v8.2d, #64
+        risuop_comp
+ 	ursra	v25.2d, v9.2d, #64
+        risuop_comp
+ 	ursra	v26.2d, v10.2d, #64
+        risuop_comp
+ 	ursra	v27.2d, v11.2d, #64
+        risuop_comp
+ 	ursra	v28.2d, v12.2d, #64
+        risuop_comp
+ 	ursra	v29.2d, v13.2d, #64
+        risuop_comp
+ 	ursra	v30.2d, v14.2d, #64
+        risuop_comp
+ 	ursra	v31.2d, v15.2d, #64
+        risuop_comp
+
+        /* second pass */
+        ursra	v16.2d, v0.2d, #64
+        risuop_comp
+ 	ursra	v17.2d, v1.2d, #64
+        risuop_comp
+ 	ursra	v18.2d, v2.2d, #64
+        risuop_comp
+ 	ursra	v19.2d, v3.2d, #64
+        risuop_comp
+ 	ursra	v20.2d, v4.2d, #64
+        risuop_comp
+ 	ursra	v21.2d, v5.2d, #64
+        risuop_comp
+ 	ursra	v22.2d, v6.2d, #64
+        risuop_comp
+ 	ursra	v23.2d, v7.2d, #64
+        risuop_comp
+ 	ursra	v24.2d, v8.2d, #64
+        risuop_comp
+ 	ursra	v25.2d, v9.2d, #64
+        risuop_comp
+ 	ursra	v26.2d, v10.2d, #64
+        risuop_comp
+ 	ursra	v27.2d, v11.2d, #64
+        risuop_comp
+ 	ursra	v28.2d, v12.2d, #64
+        risuop_comp
+ 	ursra	v29.2d, v13.2d, #64
+        risuop_comp
+ 	ursra	v30.2d, v14.2d, #64
+        risuop_comp
+ 	ursra	v31.2d, v15.2d, #64
+        risuop_comp
+
+        risuop_testend       /* test end */
-- 
2.10.2

[Qemu-devel] [RISU PATCH 3/9] risu: add simple trace and replay support

[Alex Bennée]

This adds a very dumb and easily breakable trace and replay support to
the aarch64 build of risu. In --master mode the various risu ops trigger
a write of register/memory state into a binary file which can be played
back to an apprentice. Currently there is no validation of the image
source so feeding the wrong image will fail straight away.

The trace files will get very big for any appreciable sized test file
and this will be addressed in later patches.

There is an inevitable amount of copy&paste between the trace file and
socket based code. Ideally it would be nice to have as much of this as
common as possible and reduce the re-implementation between the various
backends.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>

---

v2
  - moved read/write functions into main risu.c
  - cleaned up formatting
  - report more in apprentice --trace mode
v3
  - fix options parsing
---
 risu.c                 | 104 +++++++++++++++++++++++++++++++++++++------------
 risu.h                 |  12 ++++++
 risu_aarch64.c         |  90 ++++++++++++++++++++++++++++++++++++++++--
 risu_reginfo_aarch64.h |   7 ++++
 4 files changed, 185 insertions(+), 28 deletions(-)

diff --git a/risu.c b/risu.c
index 756ca46..f36b4c6 100644
--- a/risu.c
+++ b/risu.c
@@ -31,6 +31,7 @@
 void *memblock = 0;
 
 int apprentice_socket, master_socket;
+int trace_file = 0;
 
 sigjmp_buf jmpbuf;
 
@@ -40,31 +41,57 @@ int test_fp_exc = 0;
 long executed_tests = 0;
 void report_test_status(void *pc)
 {
-   executed_tests += 1;
-   if (executed_tests % 100 == 0) {
-      fprintf(stderr,"Executed %ld test instructions (pc=%p)\r",
-              executed_tests, pc);
+   if (ismaster || trace_file) {
+      executed_tests += 1;
+      if (executed_tests % 100 == 0) {
+         fprintf(stderr,"Executed %ld test instructions (pc=%p)\r",
+                 executed_tests, pc);
+      }
    }
 }
 
+int write_trace(void *ptr, size_t bytes)
+{
+   size_t res = write(trace_file, ptr, bytes);
+   return res == bytes;
+}
+
+int read_trace(void *ptr, size_t bytes)
+{
+   size_t res = read(trace_file, ptr, bytes);
+   return res == bytes;
+}
+
 void master_sigill(int sig, siginfo_t *si, void *uc)
 {
-   switch (recv_and_compare_register_info(master_socket, uc))
-   {
-      case 0:
-         /* match OK */
-         advance_pc(uc);
-         return;
-      default:
-         /* mismatch, or end of test */
-         siglongjmp(jmpbuf, 1);
+   if (trace_file) {
+     if (write_to_tracefile(write_trace, uc)!=0) {
+       /* end of test */
+       siglongjmp(jmpbuf, 1);
+       /* never */
+       return;
+     }
+   } else {
+     if (recv_and_compare_register_info(master_socket, uc)!=0) {
+       /* mismatch, or end of test */
+       siglongjmp(jmpbuf, 1);
+       /* never */
+       return;
+     }
    }
+   advance_pc(uc);
 }
 
 void apprentice_sigill(int sig, siginfo_t *si, void *uc)
 {
-   switch (send_register_info(apprentice_socket, uc))
-   {
+  int resp;
+  if (trace_file) {
+    resp = read_tracefile_and_check(read_trace, uc);
+  } else {
+    resp = send_register_info(apprentice_socket, uc);
+  }
+  switch (resp)
+  {
       case 0:
          /* match OK */
          advance_pc(uc);
@@ -75,6 +102,9 @@ void apprentice_sigill(int sig, siginfo_t *si, void *uc)
          exit(0);
       default:
          /* mismatch */
+         if (trace_file) {
+            report_match_status();
+         }
          exit(1);
    }
 }
@@ -136,7 +166,13 @@ int master(int sock)
 {
    if (sigsetjmp(jmpbuf, 1))
    {
-      return report_match_status();
+      if (trace_file) {
+         close(trace_file);
+         fprintf(stderr,"Done...\n");
+         return 0;
+      } else {
+         return report_match_status();
+      }
    }
    master_socket = sock;
    set_sigill_handler(&master_sigill);
@@ -165,6 +201,7 @@ void usage (void)
    fprintf(stderr, "between master and apprentice risu processes.\n\n");
    fprintf(stderr, "Options:\n");
    fprintf(stderr, "  --master          Be the master (server)\n");
+   fprintf(stderr, "  -t, --trace=FILE  Record/playback trace file\n");
    fprintf(stderr, "  -h, --host=HOST   Specify master host machine (apprentice only)\n");
    fprintf(stderr, "  -p, --port=PORT   Specify the port to connect to/listen on (default 9191)\n");
 }
@@ -175,6 +212,7 @@ int main(int argc, char **argv)
    uint16_t port = 9191;
    char *hostname = "localhost";
    char *imgfile;
+   char *trace_fn = NULL;
    int sock;
 
    // TODO clean this up later
@@ -185,13 +223,14 @@ int main(int argc, char **argv)
          {
             { "help", no_argument, 0, '?'},
             { "master", no_argument, &ismaster, 1 },
+            { "trace", required_argument, 0, 't' },
             { "host", required_argument, 0, 'h' },
             { "port", required_argument, 0, 'p' },
             { "test-fp-exc", no_argument, &test_fp_exc, 1 },
             { 0,0,0,0 }
          };
       int optidx = 0;
-      int c = getopt_long(argc, argv, "h:p:", longopts, &optidx);
+      int c = getopt_long(argc, argv, "h:p:t:", longopts, &optidx);
       if (c == -1)
       {
          break;
@@ -204,6 +243,11 @@ int main(int argc, char **argv)
             /* flag set by getopt_long, do nothing */
             break;
          }
+         case 't':
+         {
+           trace_fn = optarg;
+           break;
+         }
          case 'h':
          {
             hostname = optarg;
@@ -234,18 +278,28 @@ int main(int argc, char **argv)
    }
 
    load_image(imgfile);
-   
+
    if (ismaster)
    {
-      fprintf(stderr, "master port %d\n", port);
-      sock = master_connect(port);
-      return master(sock);
+     if (trace_fn)
+       {
+         trace_file = open(trace_fn, O_WRONLY|O_CREAT, S_IRWXU);
+       } else {
+         fprintf(stderr, "master port %d\n", port);
+         sock = master_connect(port);
+       }
+     return master(sock);
    }
    else
-   {
-      fprintf(stderr, "apprentice host %s port %d\n", hostname, port);
-      sock = apprentice_connect(hostname, port);
-      return apprentice(sock);
+     {
+     if (trace_fn)
+       {
+         trace_file = open(trace_fn, O_RDONLY);
+       } else {
+         fprintf(stderr, "apprentice host %s port %d\n", hostname, port);
+         sock = apprentice_connect(hostname, port);
+       }
+     return apprentice(sock);
    }
 }
 
diff --git a/risu.h b/risu.h
index e4bb323..57161f2 100644
--- a/risu.h
+++ b/risu.h
@@ -52,6 +52,18 @@ int send_register_info(int sock, void *uc);
  */
 int recv_and_compare_register_info(int sock, void *uc);
 
+/* To keep the read/write logic from multiplying across all arches
+ * we wrap up the function here to keep all the changes in one place
+ */
+typedef int (*trace_write_fn) (void *ptr, size_t bytes);
+typedef int (*trace_read_fn) (void *ptr, size_t bytes);
+
+/* Write out to trace file */
+int write_to_tracefile(trace_write_fn write_fn, void *uc);
+
+/* Read from trace file and check */
+int read_tracefile_and_check(trace_read_fn read_fn, void * uc);
+
 /* Print a useful report on the status of the last comparison
  * done in recv_and_compare_register_info(). This is called on
  * exit, so need not restrict itself to signal-safe functions.
diff --git a/risu_aarch64.c b/risu_aarch64.c
index 1595604..9d538cb 100644
--- a/risu_aarch64.c
+++ b/risu_aarch64.c
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <ucontext.h>
 #include <string.h>
+#include <unistd.h>
 
 #include "risu.h"
 #include "risu_reginfo_aarch64.h"
@@ -28,9 +29,7 @@ void advance_pc(void *vuc)
 {
     ucontext_t *uc = vuc;
     uc->uc_mcontext.pc += 4;
-    if (ismaster) {
-      report_test_status((void *) uc->uc_mcontext.pc);
-    }
+    report_test_status((void *) uc->uc_mcontext.pc);
 }
 
 static void set_x0(void *vuc, uint64_t x0)
@@ -135,6 +134,91 @@ int recv_and_compare_register_info(int sock, void *uc)
     return resp;
 }
 
+int write_to_tracefile(trace_write_fn write_fn, void *uc)
+{
+   int resp = 0, op;
+   trace_header_t header;
+
+   reginfo_init(&master_ri, uc);
+   op = get_risuop(master_ri.faulting_insn);
+   header.pc = master_ri.pc;
+   header.risu_op = op;
+   write_fn(&header, sizeof(header));
+
+   switch (op) {
+      case OP_TESTEND:
+         resp = 1;
+      case OP_COMPARE:
+      default:
+         write_fn(&master_ri, sizeof(master_ri));
+         break;
+      case OP_SETMEMBLOCK:
+         memblock = (void *)master_ri.regs[0];
+         break;
+      case OP_GETMEMBLOCK:
+         set_x0(uc, master_ri.regs[0] + (uintptr_t)memblock);
+         break;
+      case OP_COMPAREMEM:
+         write_fn(memblock, MEMBLOCKLEN);
+         break;
+   }
+
+   return resp;
+}
+
+
+int read_tracefile_and_check(trace_read_fn read_fn, void * uc)
+{
+   int resp = 0, op;
+   trace_header_t header;
+
+   reginfo_init(&master_ri, uc);
+   op = get_risuop(master_ri.faulting_insn);
+
+   read_fn(&header, sizeof(header));
+   if ( header.pc == master_ri.pc &&
+        header.risu_op == op )
+   {
+      switch (op) {
+         case OP_COMPARE:
+         case OP_TESTEND:
+         default:
+            if (!read_fn(&apprentice_ri, sizeof(apprentice_ri))) {
+               packet_mismatch = 1;
+               resp = 2;
+            } else if (!reginfo_is_eq(&master_ri, &apprentice_ri)) {
+               /* register mismatch */
+               resp = 2;
+            } else if (op == OP_TESTEND) {
+               resp = 1;
+            }
+            break;
+         case OP_SETMEMBLOCK:
+            memblock = (void *)master_ri.regs[0];
+            break;
+         case OP_GETMEMBLOCK:
+            set_x0(uc, master_ri.regs[0] + (uintptr_t)memblock);
+            break;
+         case OP_COMPAREMEM:
+            mem_used = 1;
+            if (!read_fn(apprentice_memblock, MEMBLOCKLEN)) {
+               packet_mismatch = 1;
+               resp = 2;
+            } else if (memcmp(memblock, apprentice_memblock, MEMBLOCKLEN) != 0) {
+               /* memory mismatch */
+               resp = 2;
+            }
+            break;
+      }
+   } else {
+      fprintf(stderr, "out of sync %lx/%lx %d/%d\n",
+              master_ri.pc, header.pc,
+              op, header.risu_op);
+      resp = 2;
+   }
+   return resp;
+}
+
 /* Print a useful report on the status of the last comparison
  * done in recv_and_compare_register_info(). This is called on
  * exit, so need not restrict itself to signal-safe functions.
diff --git a/risu_reginfo_aarch64.h b/risu_reginfo_aarch64.h
index 166b76c..db51cb2 100644
--- a/risu_reginfo_aarch64.h
+++ b/risu_reginfo_aarch64.h
@@ -28,6 +28,13 @@ struct reginfo
     __uint128_t vregs[32];
 };
 
+typedef struct
+{
+    uint64_t pc;
+    uint32_t risu_op;
+} trace_header_t;
+
+
 /* initialize structure from a ucontext */
 void reginfo_init(struct reginfo *ri, ucontext_t *uc);
 
-- 
2.10.2

[Qemu-devel] [RISU PATCH 4/9] risu: add support compressed tracefiles

[Alex Bennée]

This uses the magic of zlib's gzread/write interface to wrap the
tracefile in compression. The code changes are tiny. I spent more time
messing about with the configure/linker stuff to auto-detect bits.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 Makefile  |  3 ++-
 configure | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 risu.c    | 13 +++++++++----
 3 files changed, 66 insertions(+), 5 deletions(-)

diff --git a/Makefile b/Makefile
index 4202c35..4a2ef02 100644
--- a/Makefile
+++ b/Makefile
@@ -14,6 +14,7 @@
 include Makefile.in
 
 CFLAGS ?= -g -Wall
+LDFLAGS += -lz
 
 PROG=risu
 SRCS=risu.c comms.c risu_$(ARCH).c risu_reginfo_$(ARCH).c
@@ -31,7 +32,7 @@ all: $(PROG) $(BINS)
 dump: $(RISU_ASMS)
 
 $(PROG): $(OBJS)
-	$(CC) $(STATIC) $(CFLAGS) -o $@ $^
+	$(CC) $(STATIC) $(CFLAGS) -o $@ $^ $(LDFLAGS) 
 
 %.risu.asm: %.risu.bin
 	${OBJDUMP} -b binary -m $(ARCH) -D $^ > $@
diff --git a/configure b/configure
index f81bdb5..d11680f 100755
--- a/configure
+++ b/configure
@@ -6,6 +6,10 @@ compile() {
     $CC $CFLAGS -c -o ${1}.o ${1}.c 2>/dev/null
 }
 
+link() {
+    $LD $LDFLAGS -l${2} -o ${1} ${1}.o 2>/dev/null
+}
+
 check_define() {
     c=${tmp_dir}/check_define_${1}
     cat > ${c}.c <<EOF
@@ -34,6 +38,50 @@ guess_arch() {
     fi
 }
 
+check_type() {
+    c=${tmp_dir}/check_type_${1}
+    cat > ${c}.c <<EOF
+#include <inttypes.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+int main(void) { $1 thisone; return 0; }
+EOF
+    compile $c
+}
+
+check_lib() {
+    c=${tmp_dir}/check_lib${1}
+    cat > ${c}.c <<EOF
+#include <stdint.h>
+#include <$2.h>
+
+int main(void) { $3; return 0; }
+EOF
+    compile $c && link $c $1
+}
+
+generate_config() {
+    cfg=config.h
+    echo "generating config.h..."
+
+    echo "/* config.h - generated by the 'configure' script */" > $cfg
+    echo "#ifndef CONFIG_H" >> $cfg
+    echo "#define CONFIG_H 1" >> $cfg
+
+    if check_type uintptr_t ; then
+        echo "#define HAVE_UINTPTR_T 1" >> $cfg
+    fi
+    if check_type socklen_t ; then
+        echo "#define HAVE_SOCKLEN_T 1" >> $cfg
+    fi
+
+    echo "#endif /* CONFIG_H */" >> $cfg
+
+    echo "...done"
+}
+
 generate_makefilein() {
     m=Makefile.in
     echo "generating Makefile.in..."
@@ -93,6 +141,7 @@ done
 
 CC="${CC-${CROSS_PREFIX}gcc}"
 AS="${AS-${CROSS_PREFIX}as}"
+LD="${LD-${CROSS_PREFIX}ld}"
 OBJCOPY="${OBJCOPY-${CROSS_PREFIX}objcopy}"
 OBJDUMP="${OBJDUMP-${CROSS_PREFIX}objdump}"
 
@@ -100,6 +149,12 @@ if test "x${ARCH}" = "x"; then
     guess_arch
 fi
 
+if ! check_lib z zlib "zlibVersion()"; then
+    echo "Cannot find libz compression library"
+    exit 1
+fi
+
+generate_config
 generate_makefilein
 
 echo "type 'make' to start the build"
diff --git a/risu.c b/risu.c
index f36b4c6..1d58d4f 100644
--- a/risu.c
+++ b/risu.c
@@ -25,6 +25,7 @@
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <string.h>
+#include <zlib.h>
 
 #include "risu.h"
 
@@ -32,6 +33,7 @@ void *memblock = 0;
 
 int apprentice_socket, master_socket;
 int trace_file = 0;
+gzFile gz_trace_file;
 
 sigjmp_buf jmpbuf;
 
@@ -52,13 +54,13 @@ void report_test_status(void *pc)
 
 int write_trace(void *ptr, size_t bytes)
 {
-   size_t res = write(trace_file, ptr, bytes);
+   size_t res = gzwrite(gz_trace_file, ptr, bytes);
    return res == bytes;
 }
 
 int read_trace(void *ptr, size_t bytes)
 {
-   size_t res = read(trace_file, ptr, bytes);
+   size_t res = gzread(gz_trace_file, ptr, bytes);
    return res == bytes;
 }
 
@@ -166,8 +168,9 @@ int master(int sock)
 {
    if (sigsetjmp(jmpbuf, 1))
    {
-      if (trace_file) {
-         close(trace_file);
+      if (trace_file)
+      {
+         gzclose(gz_trace_file);
          fprintf(stderr,"Done...\n");
          return 0;
       } else {
@@ -284,6 +287,7 @@ int main(int argc, char **argv)
      if (trace_fn)
        {
          trace_file = open(trace_fn, O_WRONLY|O_CREAT, S_IRWXU);
+         gz_trace_file = gzdopen(trace_file, "wb9");
        } else {
          fprintf(stderr, "master port %d\n", port);
          sock = master_connect(port);
@@ -295,6 +299,7 @@ int main(int argc, char **argv)
      if (trace_fn)
        {
          trace_file = open(trace_fn, O_RDONLY);
+         gz_trace_file = gzdopen(trace_file, "rb");
        } else {
          fprintf(stderr, "apprentice host %s port %d\n", hostname, port);
          sock = apprentice_connect(hostname, port);
-- 
2.10.2

[Qemu-devel] [RISU PATCH 5/9] risu_aarch64: it's -> it is

[Alex Bennée]

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 risu_aarch64.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/risu_aarch64.c b/risu_aarch64.c
index 9d538cb..77f9288 100644
--- a/risu_aarch64.c
+++ b/risu_aarch64.c
@@ -82,7 +82,7 @@ int send_register_info(int sock, void *uc)
  * NB: called from a signal handler.
  *
  * We don't have any kind of identifying info in the incoming data
- * that says whether it's register or memory data, so if the two
+ * that says whether it is register or memory data, so if the two
  * sides get out of sync then we will fail obscurely.
  */
 int recv_and_compare_register_info(int sock, void *uc)
-- 
2.10.2

[Qemu-devel] [RISU PATCH 6/9] risugen: remove grocer's apostrophe from REs

[Alex Bennée]

This also fixes perl-modes confusion about escaped strings.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 risugen | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/risugen b/risugen
index a604fe5..77a550b 100755
--- a/risugen
+++ b/risugen
@@ -288,7 +288,7 @@ Valid options:
                    'VMULL' will match 'VMULL A1' and 'VMULL A2' but not
                    'VMULL_scalar A1'. This is generally what you wanted.
     --not-pattern re[,re...] : exclude patterns matching regular expression.
-                   These RE's are applied after the matching pattern which
+                   These REs are applied after the matching pattern which
                    is useful if you want to exclude a specific instruction from
                    a general set you have excluded.
      --no-fp      : disable floating point: no fp init, randomization etc.
-- 
2.10.2

[Qemu-devel] [RISU PATCH 7/9] new: generate_all.sh script

[Alex Bennée]

A simple script to cut up a full .risu file and generate binaries for
the whole set. Call with risu file and instruction count and directory:

  ./generate_all.sh aarch64.risu 4 20000 testcases.aarch64

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 generate_all.sh | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100755 generate_all.sh

diff --git a/generate_all.sh b/generate_all.sh
new file mode 100755
index 0000000..4c490be
--- /dev/null
+++ b/generate_all.sh
@@ -0,0 +1,55 @@
+#!/bin/sh
+#
+# Generate All Patterns
+#
+# Work through a given .risu file and generate full coverage
+#
+
+BASE_SHELL_PARAMS="./risugen"
+
+risufile=$1
+divisor=$2
+insns=$3
+dir=$4
+
+if test -z "$risufile"; then
+    echo "Need to specify a risu defintiion file"
+    exit 1
+fi
+
+if test -z "$divisor"; then
+    divisor=4
+fi
+
+if test -n "$insns"; then
+    BASE_SHELL_PARAMS="${BASE_SHELL_PARAMS} --numinsns $insns"
+fi
+
+if test -n "dir"; then
+    mkdir -p $dir
+else
+    dir="./"
+fi
+
+ALL_INSNS=$(cat $risufile | ag "^\w" | cut -f 1 -d " " | sort)
+COUNT=$(cat $risufile | ag "^\w" | cut -f 1 -d " " | wc -l)
+set -- $ALL_INSNS
+
+GROUP=$((COUNT / $divisor))
+
+while test $# -gt 0 ; do
+    INSN_PATTERNS=""
+    I_FILE="$dir/insn_"
+    for i in `seq 1 $divisor`; do
+        I=$1
+        if test -n "${I}"; then
+            shift
+            INSN_PATTERNS="${INSN_PATTERNS} --pattern ${I}"
+            I_FILE="${I_FILE}${I}_"
+        fi
+    done
+    I_FILE="${I_FILE}_INC.risu.bin"
+    CMD="$BASE_SHELL_PARAMS ${INSN_PATTERNS} $risufile ${I_FILE}"
+    echo "Running: $CMD"
+    $CMD
+done
-- 
2.10.2

[Qemu-devel] [RISU PATCH 8/9] new: record_traces.sh helper script

[Alex Bennée]

A simple script to run through a bunch of binaries and generate their
trace files.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 record_traces.sh | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100755 record_traces.sh

diff --git a/record_traces.sh b/record_traces.sh
new file mode 100755
index 0000000..89c62d5
--- /dev/null
+++ b/record_traces.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+#
+# Record traces
+#
+# A risu helper script to batch process a bunch of binaries and record their outputs
+#
+set -e
+
+
+for f in $@; do
+    echo "Running risu against $f"
+    t="$f.trace"
+    ./risu --master $f -t $t
+    echo "Checking trace file OK"
+    ./risu $f -t $t
+done
-- 
2.10.2

[Qemu-devel] [RISU PATCH 9/9] new: run_risu.sh script

[Alex Bennée]

A simple script to work through running all of a bunch of files with
record/playback traces. Dumps a summary and the number of failed tests
at the end.

Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
---
 run_risu.sh | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100755 run_risu.sh

diff --git a/run_risu.sh b/run_risu.sh
new file mode 100755
index 0000000..8a91e1a
--- /dev/null
+++ b/run_risu.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+#
+# Run risu against a set of binaries + trace files
+#
+#
+#set -e
+
+passed=()
+failed=()
+missing=()
+
+script_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)
+risu_path=${script_dir}/risu
+
+for f in $@; do
+    t="$f.trace"
+    echo "Running $f against $t"
+    if [ -e $t ]; then
+        ${QEMU} ${risu_path} $f -t $t
+        if [ $? == 0 ]; then
+            passed=( "${passed[@]}" $f )
+        else
+            failed=( "${failed[@]}" $f )
+        fi
+    else
+        missing=( "${missing[@]}" $f )
+    fi
+done
+
+if test ${#missing[@]} -gt 0; then
+    echo "Tests missing ${#missing[@]} trace files:"
+    for m in "${missing[@]}"; do
+        echo "$m"
+    done
+fi
+
+if test ${#passed[@]} -gt 0; then
+    echo "Passed ${#passed[@]} tests:"
+    for p in "${passed[@]}"; do
+        echo "$p"
+    done
+fi
+
+if test ${#failed[@]} -gt 0; then
+    echo "Failed ${#failed[@]} tests:"
+    for f in "${failed[@]}"; do
+        echo "$f"
+    done
+fi
+
+exit ${#failed[@]}
-- 
2.10.2

Re: [Qemu-devel] [RISU PATCH 0/9] Record/playback patches

[joserz]

On Fri, Dec 02, 2016 at 03:59:26PM +0000, Alex Bennée wrote:
> Hi Peter,
> 
> I've been cleaning things up so I thought I should re-post my current
> state. These all apply to the current master.
> 
> I had to regenerate all the risu binaries as I'd used --no-fp for a
> bunch of them originally which was causing failures. I'm not sure if
> this is due to the FP registers not being cleared by the kernel if FP
> isn't used - but we certainly don't do anything to them except when
> set by the memory/context blocks (without --no-fp). This led me to
> write the 3 noddy scripts included here.
> 
> The record/playback is still aarch64 only. I'm open to ideas to do
> this more cleanly otherwise if anyone has access to some PPC hardware
> I can port the record/playback code to the other architectures.

Excellent job, Alex

I can make the PPC port here. I still have work to do in Risu for PPC so
I can include this in my task as well. I'm planning to start working on
it this week.

Thank you

> 
> Feel free to cherry-pick any of the minor patches as you wish ;-)
> 
> Alex Bennée (9):
>   risu: a bit more verbosity when running
>   aarch64: add hand-coded risu skeleton for directed testing
>   risu: add simple trace and replay support
>   risu: add support compressed tracefiles
>   risu_aarch64: it's -> it is
>   risugen: remove grocer's apostrophe from REs
>   new: generate_all.sh script
>   new: record_traces.sh helper script
>   new: run_risu.sh script
> 
>  Makefile                      |  10 +-
>  aarch64_simd_handcoded.risu.S | 208 ++++++++++++++++++++++++++++++++++++++++++
>  configure                     |  55 +++++++++++
>  generate_all.sh               |  55 +++++++++++
>  record_traces.sh              |  16 ++++
>  risu.c                        | 116 ++++++++++++++++++-----
>  risu.h                        |  15 +++
>  risu_aarch64.c                |  89 +++++++++++++++++-
>  risu_reginfo_aarch64.h        |   7 ++
>  risugen                       |   2 +-
>  run_risu.sh                   |  51 +++++++++++
>  11 files changed, 598 insertions(+), 26 deletions(-)
>  create mode 100644 aarch64_simd_handcoded.risu.S
>  create mode 100755 generate_all.sh
>  create mode 100755 record_traces.sh
>  create mode 100755 run_risu.sh
> 
> -- 
> 2.10.2
>