MMIO access tests use the same test pattern. Let's share the code. Later, we will also reuse it for other tests.
Instead of EXPECT_EQUAL, provide macros that differ between the actual type (u8, u16, u32, u64). We can still use the same evaluation function if we first narrow down types, and later expand them again. Signed-off-by: Ralf Ramsauer <[email protected]> --- inmates/lib/include/test.h | 21 ++++++++ inmates/lib/test.c | 28 ++++++++++ inmates/lib/x86/Makefile | 2 +- inmates/tests/x86/mmio-access-32.c | 60 ++++++++------------- inmates/tests/x86/mmio-access.c | 84 +++++++++++++----------------- 5 files changed, 108 insertions(+), 87 deletions(-) create mode 100644 inmates/lib/include/test.h create mode 100644 inmates/lib/test.c diff --git a/inmates/lib/include/test.h b/inmates/lib/include/test.h new file mode 100644 index 00000000..4f4787ae --- /dev/null +++ b/inmates/lib/include/test.h @@ -0,0 +1,21 @@ +/* + * + * Jailhouse, a Linux-based partitioning hypervisor + * + * Copyright (c) Siemens AG, 2018 + * + * Authors: + * Jan Kiszka <[email protected]> + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + */ + +#define EXPECT_EQUAL_U8(a, b) __evaluate_u64((u8)(a), (u8)(b), __LINE__) +#define EXPECT_EQUAL_U16(a, b) __evaluate_u64((u16)(a), (u16)(b), __LINE__) +#define EXPECT_EQUAL_U32(a, b) __evaluate_u64((u32)(a), (u32)(b), __LINE__) +#define EXPECT_EQUAL_U64(a, b) __evaluate_u64((u64)(a), (u64)(b), __LINE__) + +extern bool all_passed; + +void __evaluate_u64(u64 a, u64 b, int line); diff --git a/inmates/lib/test.c b/inmates/lib/test.c new file mode 100644 index 00000000..bebfb56e --- /dev/null +++ b/inmates/lib/test.c @@ -0,0 +1,28 @@ +/* + * + * Jailhouse, a Linux-based partitioning hypervisor + * + * Copyright (c) Siemens AG, 2018 + * + * Authors: + * Jan Kiszka <[email protected]> + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + */ + +#include <inmate.h> +#include <test.h> + +bool all_passed = true; + +void __evaluate_u64(u64 a, u64 b, int line) +{ + bool passed = (a == b); + + printk("Test at line #%d %s\n", line, passed ? "passed" : "FAILED"); + if (!passed) { + printk(" %llx != %llx\n", (u64)a, (u64)b); + all_passed = false; + } +} diff --git a/inmates/lib/x86/Makefile b/inmates/lib/x86/Makefile index c75de452..527436ef 100644 --- a/inmates/lib/x86/Makefile +++ b/inmates/lib/x86/Makefile @@ -42,7 +42,7 @@ always := lib.a lib32.a TARGETS := cpu-features.o excp.o header-common.o int.o ioapic.o printk.o TARGETS += setup.o uart.o -TARGETS += ../alloc.o ../pci.o ../string.o ../cmdline.o ../setup.o +TARGETS += ../alloc.o ../pci.o ../string.o ../cmdline.o ../setup.o ../test.o TARGETS += ../uart-8250.o ../printk.o TARGETS_32_ONLY := header-32.o TARGETS_64_ONLY := mem.o pci.o smp.o timing.o header-64.o diff --git a/inmates/tests/x86/mmio-access-32.c b/inmates/tests/x86/mmio-access-32.c index db743410..3c619bdc 100644 --- a/inmates/tests/x86/mmio-access-32.c +++ b/inmates/tests/x86/mmio-access-32.c @@ -11,21 +11,7 @@ */ #include <inmate.h> - -#define EXPECT_EQUAL(a, b) evaluate(a, b, __LINE__) - -static bool all_passed = true; - -static void evaluate(u32 a, u32 b, int line) -{ - bool passed = (a == b); - - printk("Test at line #%d %s\n", line, passed ? "passed" : "FAILED"); - if (!passed) { - printk(" %x != %x\n", a, b); - all_passed = false; - } -} +#include <test.h> void inmate_main(void) { @@ -39,45 +25,45 @@ void inmate_main(void) pattern = 0x11223344; mmio_write32(mmio_reg, pattern); - EXPECT_EQUAL(*comm_page_reg, pattern); + EXPECT_EQUAL_U32(*comm_page_reg, pattern); /* MOV_FROM_MEM (8b), 16-bit data, 32-bit address, OP size prefix */ asm volatile("mov (%%eax), %%ax" : "=a" (reg32) : "a" (mmio_reg)); - EXPECT_EQUAL((u16)reg32, (u16)pattern); + EXPECT_EQUAL_U16(reg32, pattern); /* MOV_FROM_MEM (8b), 32-bit data, 32-bit address */ asm volatile("movl (%%ebx), %%eax" : "=a" (reg32) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg32, pattern); + EXPECT_EQUAL_U32(reg32, pattern); /* MOV_FROM_MEM (8a), 8-bit data */ asm volatile("movb (%%eax), %%al" : "=a" (reg32) : "a" (mmio_reg)); /* %al should contain 0x44, while higher bits still hold the rest of * mmio_reg. Test this. */ - EXPECT_EQUAL(reg32, + EXPECT_EQUAL_U32(reg32, ((unsigned long)mmio_reg & ~0xffUL) | (pattern & 0xff)); /* MOV_FROM_MEM (8a), 8-bit data, 32-bit address, OP size prefix */ asm volatile("data16 mov (%%eax), %%al" : "=a" (reg32) : "a" (mmio_reg)); - EXPECT_EQUAL(reg32, + EXPECT_EQUAL_U32(reg32, ((unsigned long)mmio_reg & ~0xffUL) | (pattern & 0xff)); /* MOVZXB (0f b6), 32-bit data, 32-bit address */ asm volatile("movzxb (%%ebx), %%eax" : "=a" (reg32) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg32, (u8)pattern); + EXPECT_EQUAL_U32(reg32, (u8)pattern); /* MOVZXW (0f b7) */ asm volatile("movzxw (%%ebx), %%eax" : "=a" (reg32) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg32, (u16)pattern); + EXPECT_EQUAL_U16(reg32, (u16)pattern); /* MEM_TO_AX (a1), 32-bit data, 32-bit address */ asm volatile("mov (0x101ff8), %%eax" : "=a" (reg32) : "a" (0)); - EXPECT_EQUAL(reg32, pattern); + EXPECT_EQUAL_U32(reg32, pattern); printk("MMIO read test %s\n\n", all_passed ? "passed" : "FAILED"); @@ -86,70 +72,70 @@ void inmate_main(void) all_passed = true; pattern = 0x8899aabb; mmio_write32(mmio_reg, ~pattern); - EXPECT_EQUAL(*comm_page_reg, ~pattern); + EXPECT_EQUAL_U32(*comm_page_reg, ~pattern); /* MOV_TO_MEM (89), 32-bit data, mod=0, reg=0, rm=4, SIB.base=5 (disp32) */ asm volatile("movl %%eax, (0x101ff8)" : : "a" (pattern)); - EXPECT_EQUAL(*comm_page_reg, pattern); + EXPECT_EQUAL_U32(*comm_page_reg, pattern); /* MOV_TO_MEM (88), 8-bit data */ asm volatile("movb %%al, (%%ebx)" : : "a" (0x42), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, (pattern & ~0xffUL) | 0x42); + EXPECT_EQUAL_U32(*comm_page_reg, (pattern & ~0xffUL) | 0x42); /* MOV_TO_MEM (88), 8-bit data, OP size prefix */ asm volatile("data16 mov %%al, (%%ebx)" : : "a" (0x23), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, (pattern & ~0xffUL) | 0x23); + EXPECT_EQUAL_U32(*comm_page_reg, (pattern & ~0xffUL) | 0x23); /* MOV_TO_MEM (89), 16-bit data, OP size prefix */ asm volatile("mov %%ax, (%%ebx)" : : "a" (0x2342), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, (pattern & ~0xffffUL) | 0x2342); + EXPECT_EQUAL_U32(*comm_page_reg, (pattern & ~0xffffUL) | 0x2342); /* IMMEDIATE_TO_MEM (c7), 32-bit data, mod=0, reg=0, rm=3 */ asm volatile("movl %0, (%%ebx)" : : "i" (0x12345678), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U32(*comm_page_reg, 0x12345678); /* IMMEDIATE_TO_MEM (c7), 32-bit data, mod=1 (disp8), reg=0, rm=3 */ asm volatile("movl %0, 0x10(%%ebx)" : : "i" (0x11223344), "b" (mmio_reg - 0x10)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344); + EXPECT_EQUAL_U32(*comm_page_reg, 0x11223344); /* IMMEDIATE_TO_MEM (c7), 32-bit data, mod=2 (disp32), reg=0, rm=3 */ asm volatile("movl %0, 0x10000000(%%ebx)" : : "i" (0xccddeeff), "b" (mmio_reg - 0x10000000)); - EXPECT_EQUAL(*comm_page_reg, 0xccddeeff); + EXPECT_EQUAL_U32(*comm_page_reg, 0xccddeeff); /* MOVB_TO_MEM (88), mod=0, reg=0, rm=3 */ asm volatile("mov %%al, (%%ebx)" : : "a" (0x99), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, 0xccddee99); + EXPECT_EQUAL_U32(*comm_page_reg, 0xccddee99); /* MOV_TO_MEM (89), 32-bit data, mod=1 (disp8), reg=0, rm=3 */ asm volatile("movl %%eax, 0x10(%%ebx)" : : "a" (0x12345678), "b" (mmio_reg - 0x10)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U32(*comm_page_reg, 0x12345678); /* MOV_TO_MEM (89), 32-bit data, mod=2 (disp32), reg=0, rm=3 */ asm volatile("movl %%eax, 0x10000000(%%ebx)" : : "a" (0x12345678), "b" (mmio_reg - 0x10000000)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U32(*comm_page_reg, 0x12345678); /* MOV_TO_MEM (89), 32-bit data, 32-bit address */ asm volatile("movl %%eax, 0x10000000(%%ebx)" : : "a" (0x87654321), "b" (mmio_reg - 0x10000000)); - EXPECT_EQUAL(*comm_page_reg, 0x87654321); + EXPECT_EQUAL_U32(*comm_page_reg, 0x87654321); /* MOV_TO_MEM (89), 32-bit data, mod=0, reg=0, rm=4 (SIB) */ asm volatile("movl %%eax, (%%ebx,%%ecx)" : : "a" (0x12345678), "b" (mmio_reg), "c" (0)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U32(*comm_page_reg, 0x12345678); /* MOV_TO_MEM (89), 32-bit data, mod=2 (disp32), reg=0, rm=4 (SIB) */ asm volatile("movl %%eax, 0x10000000(%%ebx,%%ecx)" : : "a" (0x87654321), "b" (mmio_reg - 0x10000000), "c" (0)); - EXPECT_EQUAL(*comm_page_reg, 0x87654321); + EXPECT_EQUAL_U32(*comm_page_reg, 0x87654321); printk("MMIO write test %s\n", all_passed ? "passed" : "FAILED"); } diff --git a/inmates/tests/x86/mmio-access.c b/inmates/tests/x86/mmio-access.c index a17455b0..973381cd 100644 --- a/inmates/tests/x86/mmio-access.c +++ b/inmates/tests/x86/mmio-access.c @@ -11,24 +11,10 @@ */ #include <inmate.h> - -#define EXPECT_EQUAL(a, b) evaluate(a, b, __LINE__) +#include <test.h> extern u8 __reset_entry[]; /* assumed to be at 0 */ -static bool all_passed = true; - -static void evaluate(u64 a, u64 b, int line) -{ - bool passed = (a == b); - - printk("Test at line #%d %s\n", line, passed ? "passed" : "FAILED"); - if (!passed) { - printk(" %llx != %llx\n", a, b); - all_passed = false; - } -} - /* * mmio-access tests different memory access strategies that are intercepted by * the hypervisor. Therefore, it maps a second page right behind the @@ -49,71 +35,71 @@ void inmate_main(void) pattern = 0x1122334455667788; mmio_write64(mmio_reg, pattern); - EXPECT_EQUAL(*comm_page_reg, pattern); + EXPECT_EQUAL_U64(*comm_page_reg, pattern); /* MOV_FROM_MEM (8b), 16-bit data, Ox66 OP size prefix */ asm volatile("mov (%%rax), %%ax" : "=a" (reg64) : "a" (mmio_reg)); - EXPECT_EQUAL((u16)reg64, (u16)pattern); + EXPECT_EQUAL_U16(reg64, pattern); /* MOV_FROM_MEM (8b), 64-bit data, mod=0, reg=0, rm=3 */ asm volatile("movq (%%rbx), %%rax" : "=a" (reg64) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg64, pattern); + EXPECT_EQUAL_U64(reg64, pattern); /* MOV_FROM_MEM (8b), 32-bit data */ asm volatile("movl (%%rbx), %%eax" : "=a" (reg64) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg64, (u32)pattern); + EXPECT_EQUAL_U32(reg64, pattern); /* MOV_FROM_MEM (8b), 32-bit data, 32-bit address */ asm volatile("movl (%%ebx), %%eax" : "=a" (reg64) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg64, (u32)pattern); + EXPECT_EQUAL_U32(reg64, pattern); /* MOV_FROM_MEM (8a), 8-bit data */ asm volatile("movb (%%rax), %%al" : "=a" (reg64) : "a" (mmio_reg)); /* %al should contain 0x88, while high bits should still hold the rest * of mmio_reg */ - EXPECT_EQUAL(reg64, + EXPECT_EQUAL_U64(reg64, ((unsigned long)mmio_reg & ~0xffUL) | (pattern & 0xff)); /* MOV_FROM_MEM (8a), 8-bit data, 0x66 OP size prefix (ignored) */ asm volatile("data16 mov (%%rax), %%al" : "=a" (reg64) : "a" (mmio_reg)); - EXPECT_EQUAL(reg64, + EXPECT_EQUAL_U64(reg64, ((unsigned long)mmio_reg & ~0xffUL) | (pattern & 0xff)); /* MOVZXB (0f b6), to 64-bit, mod=0, reg=0, rm=3 */ asm volatile("movzxb (%%rbx), %%rax" : "=a" (reg64) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg64, (u8)pattern); + EXPECT_EQUAL_U8(reg64, (u8)pattern); /* MOVZXB (0f b6), 32-bit data, 32-bit address */ asm volatile("movzxb (%%ebx), %%eax" : "=a" (reg64) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg64, (u8)pattern); + EXPECT_EQUAL_U8(reg64, (u8)pattern); /* MOVZXW (0f b7) */ asm volatile("movzxw (%%rbx), %%rax" : "=a" (reg64) : "a" (0), "b" (mmio_reg)); - EXPECT_EQUAL(reg64, (u16)pattern); + EXPECT_EQUAL_U16(reg64, (u16)pattern); /* MEM_TO_AX (a1), 64-bit data, 64-bit address */ asm volatile("movabs (0x101ff8), %%rax" : "=a" (reg64) : "a" (0)); - EXPECT_EQUAL(reg64, pattern); + EXPECT_EQUAL_U64(reg64, pattern); /* MEM_TO_AX (a1), 32-bit data, 64-bit address */ asm volatile("movabs (0x101ff8), %%eax" : "=a" (reg64) : "a" (0)); - EXPECT_EQUAL(reg64, (u32)pattern); + EXPECT_EQUAL_U64(reg64, (u32)pattern); reg64 = 0ULL; /* MEM_TO_AX (a1), 64-bit data, 32-bit address, AD SZ override prefix */ asm volatile("addr32 mov 0x101ff8, %%rax" : "=a" (reg64) : "a" (0)); - EXPECT_EQUAL(reg64, pattern); + EXPECT_EQUAL_U64(reg64, pattern); printk("MMIO read test %s\n\n", all_passed ? "passed" : "FAILED"); @@ -122,114 +108,114 @@ void inmate_main(void) all_passed = true; pattern = 0x8899aabbccddeeff; mmio_write64(mmio_reg, ~pattern); - EXPECT_EQUAL(*comm_page_reg, ~pattern); + EXPECT_EQUAL_U64(*comm_page_reg, ~pattern); /* MOV_TO_MEM (89), 64-bit data, mod=0, reg=0, rm=4, SIB.base=5 (disp32) */ asm volatile("movq %%rax, (0x101ff8)" : : "a" (pattern)); - EXPECT_EQUAL(*comm_page_reg, pattern); + EXPECT_EQUAL_U64(*comm_page_reg, pattern); pattern = ~pattern; /* MOV_TO_MEM (89), 64-bit data, mod=0, reg=0, rm=5 (rip+disp32) */ asm volatile("movq %%rax, __reset_entry+0x101ff8(%%rip)" : : "a" (pattern)); - EXPECT_EQUAL(*comm_page_reg, pattern); + EXPECT_EQUAL_U64(*comm_page_reg, pattern); /* MOV_TO_MEM (88), 8-bit data */ asm volatile("movb %%al, (%%rbx)" : : "a" (0x42), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, (pattern & ~0xffUL) | 0x42); + EXPECT_EQUAL_U64(*comm_page_reg, (pattern & ~0xffUL) | 0x42); /* MOV_TO_MEM (88), 8-bit data, OP size prefix */ asm volatile("data16 mov %%al, (%%rbx)" : : "a" (0x23), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, (pattern & ~0xffUL) | 0x23); + EXPECT_EQUAL_U64(*comm_page_reg, (pattern & ~0xffUL) | 0x23); /* MOV_TO_MEM (89), 16-bit data, OP size prefix */ asm volatile("mov %%ax, (%%rbx)" : : "a" (0x2342), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, (pattern & ~0xffffUL) | 0x2342); + EXPECT_EQUAL_U64(*comm_page_reg, (pattern & ~0xffffUL) | 0x2342); /* IMMEDIATE_TO_MEM (c7), 64-bit data, mod=0, reg=0, rm=3 */ asm volatile("movq %0, (%%rbx)" : : "i" (0x12345678), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U64(*comm_page_reg, 0x12345678); /* IMMEDIATE_TO_MEM (c7), 64-bit data, mod=0, reg=0, rm=3, sign-extend */ asm volatile("movq %0, (%%rbx)" : : "i" (0xccddeeff), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, 0xffffffffccddeeff); + EXPECT_EQUAL_U64(*comm_page_reg, 0xffffffffccddeeff); mmio_write64(mmio_reg, 0x1122334455667788); /* IMMEDIATE_TO_MEM (c7), 32-bit data */ asm volatile("movl %0, (%%rbx)" : : "i" (0xccddeeff), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344ccddeeff); + EXPECT_EQUAL_U32(*comm_page_reg, 0x11223344ccddeeff); mmio_write64(mmio_reg, 0x1122334455667788); /* IMMEDIATE_TO_MEM (c7), 32-bit data, 32-bit address */ asm volatile("movl %0, (%%ebx)" : : "i" (0xccddeeff), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344ccddeeff); + EXPECT_EQUAL_U64(*comm_page_reg, 0x11223344ccddeeff); mmio_write64(mmio_reg, 0x1122334455667788); /* IMMEDIATE_TO_MEM (c7), 32-bit data, mod=1 (disp8), reg=0, rm=3 */ asm volatile("movl %0, 0x10(%%rbx)" : : "i" (0xccddeeff), "b" (mmio_reg - 0x10)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344ccddeeff); + EXPECT_EQUAL_U64(*comm_page_reg, 0x11223344ccddeeff); mmio_write64(mmio_reg, 0x1122334455667788); /* IMMEDIATE_TO_MEM (c7), 32-bit data, 32-bit address */ asm volatile("movl %0, 0x10(%%ebx)" : : "i" (0xccddeeff), "b" (mmio_reg - 0x10)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344ccddeeff); + EXPECT_EQUAL_U64(*comm_page_reg, 0x11223344ccddeeff); mmio_write64(mmio_reg, 0x1122334455667788); /* IMMEDIATE_TO_MEM (c7), 32-bit data, mod=2 (disp32), reg=0, rm=3 */ asm volatile("movl %0, 0x10000000(%%rbx)" : : "i" (0xccddeeff), "b" (mmio_reg - 0x10000000)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344ccddeeff); + EXPECT_EQUAL_U64(*comm_page_reg, 0x11223344ccddeeff); mmio_write64(mmio_reg, 0x1122334455667788); /* IMMEDIATE_TO_MEM (c7), 32-bit data, 32-bit address */ asm volatile("movl %0, 0x10000000(%%ebx)" : : "i" (0xccddeeff), "b" (mmio_reg - 0x10000000)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344ccddeeff); + EXPECT_EQUAL_U64(*comm_page_reg, 0x11223344ccddeeff); /* MOVB_TO_MEM (88), mod=0, reg=0, rm=3 */ asm volatile("mov %%al, (%%rbx)" : : "a" (0x99), "b" (mmio_reg)); - EXPECT_EQUAL(*comm_page_reg, 0x11223344ccddee99); + EXPECT_EQUAL_U64(*comm_page_reg, 0x11223344ccddee99); /* MOV_TO_MEM (89), 64-bit data, mod=1 (disp8), reg=0, rm=3 */ asm volatile("movq %%rax, 0x10(%%rbx)" : : "a" (0x12345678), "b" (mmio_reg - 0x10)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U64(*comm_page_reg, 0x12345678); /* MOV_TO_MEM (89), 64-bit data, mod=2 (disp32), reg=0, rm=3 */ asm volatile("movq %%rax, 0x10000000(%%rbx)" : : "a" (0x12345678), "b" (mmio_reg - 0x10000000)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U64(*comm_page_reg, 0x12345678); mmio_write64(mmio_reg, 0x1122334455667788); /* MOV_TO_MEM (89), 64-bit data, 32-bit address */ asm volatile("movq %%rax, 0x10000000(%%ebx)" : : "a" (0x8765432112345678), "b" (mmio_reg - 0x10000000)); - EXPECT_EQUAL(*comm_page_reg, 0x8765432112345678); + EXPECT_EQUAL_U64(*comm_page_reg, 0x8765432112345678); /* MOV_TO_MEM (89), 64-bit data, mod=0, reg=0, rm=4 (SIB) */ asm volatile("movq %%rax, (%%rbx,%%rcx)" : : "a" (0x12345678), "b" (mmio_reg), "c" (0)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U64(*comm_page_reg, 0x12345678); /* MOV_TO_MEM (89), 64-bit data, mod=2 (disp32), reg=0, rm=4 (SIB) */ asm volatile("movq %%rax, 0x10000000(%%rbx,%%rcx)" : : "a" (0x12345678), "b" (mmio_reg - 0x10000000), "c" (0)); - EXPECT_EQUAL(*comm_page_reg, 0x12345678); + EXPECT_EQUAL_U64(*comm_page_reg, 0x12345678); pattern = 0xdeadbeef; /* AX_TO_MEM (a3), 32-bit data, 32-bit address */ asm volatile(".byte 0x67, 0x48, 0xa3, 0xf8, 0x1f, 0x10, 0x00" : : "a" (pattern)); - EXPECT_EQUAL(mmio_read32(mmio_reg), (u32)pattern); + EXPECT_EQUAL_U32(mmio_read32(mmio_reg), pattern); printk("MMIO write test %s\n", all_passed ? "passed" : "FAILED"); } -- 2.21.0 -- You received this message because you are subscribed to the Google Groups "Jailhouse" group. To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To view this discussion on the web visit https://groups.google.com/d/msgid/jailhouse-dev/20190610230330.21419-10-ralf.ramsauer%40oth-regensburg.de. For more options, visit https://groups.google.com/d/optout.
