linux-user: Allow gdbstub to ignore page protection
cover linux-user: Allow gdbstub to ignore page protection
RFC: https://lists.gnu.org/archive/html/qemu-devel/2023-12/msg02044.html
RFC -> v1: Use /proc/self/mem and accept that this will not work
without /proc.
Factor out a couple functions for gdbstub testing. Add a test.
Hi,
I've noticed that gdbstub behaves differently from gdbserver in that it doesn't allow reading non-readable pages. This series improves the situation by using the same mechanism as gdbserver: /proc/self/mem. If /proc is not mounted, we fall back to the today's implementation.
Best regards,
Ilya
Ilya Leoshkevich (3):
linux-user: Allow gdbstub to ignore page protection tests/tcg: Factor out gdbstub test functions tests/tcg: Add the PROT_NONE gdbstub test
cpu-target.c | 55 +++++++++++++----- tests/guest-debug/run-test.py | 7 ++- tests/guest-debug/test_gdbstub.py | 56 +++++++++++++++++++ tests/tcg/aarch64/gdbstub/test-sve-ioctl.py | 34 +---------- tests/tcg/aarch64/gdbstub/test-sve.py | 33 +---------- tests/tcg/multiarch/Makefile.target | 9 ++- tests/tcg/multiarch/gdbstub/interrupt.py | 47 ++-------------- tests/tcg/multiarch/gdbstub/memory.py | 41 +------------- tests/tcg/multiarch/gdbstub/prot-none.py | 22 ++++++++ tests/tcg/multiarch/gdbstub/registers.py | 41 ++------------ tests/tcg/multiarch/gdbstub/sha1.py | 40 ++----------- .../multiarch/gdbstub/test-proc-mappings.py | 39 +------------ .../multiarch/gdbstub/test-qxfer-auxv-read.py | 37 +----------- .../gdbstub/test-thread-breakpoint.py | 37 +----------- tests/tcg/multiarch/prot-none.c | 38 +++++++++++++ tests/tcg/s390x/gdbstub/test-signals-s390x.py | 42 +------------- tests/tcg/s390x/gdbstub/test-svc.py | 39 +------------ 17 files changed, 204 insertions(+), 413 deletions(-) create mode 100644 tests/guest-debug/test_gdbstub.py create mode 100644 tests/tcg/multiarch/gdbstub/prot-none.py create mode 100644 tests/tcg/multiarch/prot-none.c
Signature · 1 line
2.43.0
PATCH 1/3 linux-user: Allow gdbstub to ignore page protection
gdbserver ignores page protection by virtue of using /proc/$pid/mem. Teach qemu gdbstub to do this too. This will not work if /proc is not mounted; accept this limitation.
One alternative is to temporarily grant the missing PROT_* bit, but this is inherently racy. Another alternative is self-debugging with ptrace(POKE), which will break if QEMU itself is being debugged - a much more severe limitation.
--- cpu-target.c | 55 ++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 15 deletions(-)
cpu-target.c +40 -15
@@ -406,6 +406,15 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr,vaddr l, page;void * p;uint8_t *buf = ptr; +int ret =-1 ; +int mem_fd; + +/* +* Try ptrace first. If /proc is not mounted or if there is a different +* problem, fall back to the manual page access. Note that, unlike ptrace, +* it will not be able to ignore the protection bits. +*/ + mem_fd =open ("/proc/self/mem" , is_write ?O_WRONLY :O_RDONLY );while (len >0 ) { page = addr &TARGET_PAGE_MASK ;
@@ -413,22 +422,33 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr,if (l > len) l = len; flags =page_get_flags (page); -if (!(flags &PAGE_VALID )) -return -1 ; +if (!(flags &PAGE_VALID )) { + goto out_close; + }if (is_write) { -if (!(flags &PAGE_WRITE )) -return -1 ; +if (mem_fd ==-1 || +pwrite (mem_fd, ptr, len, (off_t )g2h_untagged (addr)) != len) { +if (!(flags &PAGE_WRITE )) { + goto out_close; + } +/* XXX: this code should not depend on lock_user */ + p =lock_user (VERIFY_WRITE , addr, l,0 ); +if (!p) { + goto out_close; + } +memcpy (p, buf, l); +unlock_user (p, addr, l); + } + }else if (mem_fd ==-1 || +pread (mem_fd, ptr, len, (off_t )g2h_untagged (addr)) != len) { +if (!(flags &PAGE_READ )) { + goto out_close; + }/* XXX: this code should not depend on lock_user */ -if (!(p =lock_user (VERIFY_WRITE , addr, l,0 ))) -return -1 ; -memcpy (p, buf, l); -unlock_user (p, addr, l); - }else { -if (!(flags &PAGE_READ )) -return -1 ; -/* XXX: this code should not depend on lock_user */ -if (!(p =lock_user (VERIFY_READ , addr, l,1 ))) -return -1 ; + p =lock_user (VERIFY_READ , addr, l,1 ); +if (!p) { + goto out_close; + }memcpy (buf, p, l);unlock_user (p, addr,0 ); }
@@ -436,7 +456,12 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr, buf += l; addr += l; } -return 0 ; + ret =0 ; +out_close: +if (mem_fd !=-1 ) { +close (mem_fd); + } +return ret; }#endif
Signature · 1 line
2.43.0
Quoted 21 lines · Ilya Leoshkevich
gdbserver ignores page protection by virtue of using
/proc/$pid/mem. Teach qemu gdbstub to do this too. This will not work if /proc is not mounted; accept this limitation.One alternative is to temporarily grant the missing PROT_* bit, but this is inherently racy. Another alternative is self-debugging with ptrace(POKE), which will break if QEMU itself is being debugged - a much more severe limitation.
Signed-off-by Ilya Leoshkevich <[email protected]>--- cpu-target.c | 55 ++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 15 deletions(-)cpu-target.c +0
-0@@ -406,6 +406,15 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr,vaddr l, page;void * p;
cpu-target.c int cpu_memory_rw_debug(CPUState *cpu, vaddr addr, · line 417
Quoted 10 lines
cpu-target.c +9
-0uint8_t *buf = ptr; +int ret =-1 ; +int mem_fd; + +/* +* Try ptrace first. If /proc is not mounted or if there is a different +* problem, fall back to the manual page access. Note that, unlike ptrace, +* it will not be able to ignore the protection bits. +*/ + mem_fd =open ("/proc/self/mem" , is_write ?O_WRONLY :O_RDONLY );
Surely this is the unlikely fallback, and you don't need to open unless the page is otherwise inaccessible.
I see no handling for writes to pages that contain TranslationBlocks.
r~
Quoted 65 lines
cpu-target.c +31
-15while (len >0 ) { page = addr &TARGET_PAGE_MASK ;@@ -413,22 +422,33 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr,if (l > len) l = len; flags =page_get_flags (page); -if (!(flags &PAGE_VALID )) -return -1 ; +if (!(flags &PAGE_VALID )) { + goto out_close; + }if (is_write) { -if (!(flags &PAGE_WRITE )) -return -1 ; +if (mem_fd ==-1 || +pwrite (mem_fd, ptr, len, (off_t )g2h_untagged (addr)) != len) { +if (!(flags &PAGE_WRITE )) { + goto out_close; + } +/* XXX: this code should not depend on lock_user */ + p =lock_user (VERIFY_WRITE , addr, l,0 ); +if (!p) { + goto out_close; + } +memcpy (p, buf, l); +unlock_user (p, addr, l); + } + }else if (mem_fd ==-1 || +pread (mem_fd, ptr, len, (off_t )g2h_untagged (addr)) != len) { +if (!(flags &PAGE_READ )) { + goto out_close; + }/* XXX: this code should not depend on lock_user */ -if (!(p =lock_user (VERIFY_WRITE , addr, l,0 ))) -return -1 ; -memcpy (p, buf, l); -unlock_user (p, addr, l); - }else { -if (!(flags &PAGE_READ )) -return -1 ; -/* XXX: this code should not depend on lock_user */ -if (!(p =lock_user (VERIFY_READ , addr, l,1 ))) -return -1 ; + p =lock_user (VERIFY_READ , addr, l,1 ); +if (!p) { + goto out_close; + }memcpy (buf, p, l);unlock_user (p, addr,0 ); }@@ -436,7 +456,12 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr, buf += l; addr += l; } -return 0 ; + ret =0 ; +out_close: +if (mem_fd !=-1 ) { +close (mem_fd); + } +return ret; }#endif
Quoted 35 lines · Richard Henderson
Quoted 34 lines · Ilya Leoshkevich
gdbserver ignores page protection by virtue of using
/proc/$pid/mem.
Teach qemu gdbstub to do this too. This will not work if /proc is not
mounted; accept this limitation.One alternative is to temporarily grant the missing PROT_* bit, but this is inherently racy. Another alternative is self-debugging with ptrace(POKE), which will break if QEMU itself is being debugged - a much more severe limitation.
Signed-off-by Ilya Leoshkevich <[email protected]>---
cpu-target.c| 55 ++++++++++++++++++++++++++++++++++++++---------
-----1 file changed, 40 insertions(+), 15 deletions(-)cpu-target.c +5
-0@@ -406,6 +406,15 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr, vaddr l, page; void * p; uint8_t *buf = ptr; + int ret = -1; + int mem_fd; + + /* +* Try ptrace first. If /proc is not mounted or if there is a different
+ * problem, fall back to the manual page access. Note that, unlike ptrace,
Quoted 8 lines
Quoted 4 lines
+ * it will not be able to ignore the protection bits. + */
+mem_fd= open("/proc/self/mem",is_write?O_WRONLY:O_RDONLY);Surely this is the unlikely fallback, and you don't need to open unless the page is
otherwise inaccessible.
Ok, I can move this under (flags & PAGE_*) checks.
Quoted 1 line
I see no handling for writes to pages that contain TranslationBlocks.
Sorry, I completely missed that. I'm currently experimenting with the following:
/* * If there is a TranslationBlock and we weren't bypassing host * page protection, the memcpy() above would SEGV, ultimately * leading to page_unprotect(). So invalidate the translations * manually. Both invalidation and pwrite() must be under * mmap_lock() in order to prevent the creation of another * TranslationBlock in between. */ mmap_lock(); tb_invalidate_phys_page(page); written = pwrite(fd, buf, l, (off_t)g2h_untagged(addr)); mmap_unlock();
Does that look okay?
[...]
Quoted 54 lines · Ilya Leoshkevich
Quoted 35 lines · Richard Henderson
Quoted 34 lines · Ilya Leoshkevich
gdbserver ignores page protection by virtue of using
/proc/$pid/mem.
Teach qemu gdbstub to do this too. This will not work if /proc is not
mounted; accept this limitation.One alternative is to temporarily grant the missing PROT_* bit, but this is inherently racy. Another alternative is self-debugging with ptrace(POKE), which will break if QEMU itself is being debugged - a much more severe limitation.
Signed-off-by Ilya Leoshkevich <[email protected]>--- cpu-target.c | 55 ++++++++++++++++++++++++++++++++++++++--------- ----- 1 file changed, 40 insertions(+), 15 deletions(-)cpu-target.c +5
-0@@ -406,6 +406,15 @@ int cpu_memory_rw_debug(CPUState *cpu, vaddr addr, vaddr l, page; void * p; uint8_t *buf = ptr; + int ret = -1; + int mem_fd; + + /* +* Try ptrace first. If /proc is not mounted or if there is a different
+ * problem, fall back to the manual page access. Note that, unlike ptrace,Quoted 8 lines
Quoted 4 lines
+ * it will not be able to ignore the protection bits. + */
+mem_fd= open("/proc/self/mem",is_write?O_WRONLY:O_RDONLY);Surely this is the unlikely fallback, and you don't need to open unless the page is
otherwise inaccessible.Ok, I can move this under (flags & PAGE_*) checks.
Quoted 1 line
I see no handling for writes to pages that contain TranslationBlocks.
Sorry, I completely missed that. I'm currently experimenting with the following:
/* * If there is a TranslationBlock and we weren't bypassing
Quoted 10 lines
host
* page protection, thememcpy()above would SEGV, ultimately
* leading topage_unprotect(). So invalidate the translations
* manually. Both invalidation andpwrite()must be under
*mmap_lock()in order to prevent the creation of another
* TranslationBlock in between.
*/
mmap_lock();
tb_invalidate_phys_page(page);
written =pwrite(fd, buf, l, (off_t)g2h_untagged(addr));
I would use here tb_invalidate_phys_range(addr, addr + l - 1), but otherwise, it looks good.
r~
Quoted 5 lines
mmap_unlock();Does that look okay?
[...]
PATCH 2/3 tests/tcg: Factor out gdbstub test functions
In reply to Ilya LeoshkevichBoth the report() function as well as the initial gdbstub test sequence are copy-pasted into ~10 files with slight modifications. This indicates that they are indeed generic, so factor them out. While at it, add a few newlines to make the formatting closer to PEP-8.
--- tests/guest-debug/run-test.py | 7 ++- tests/guest-debug/test_gdbstub.py | 56 +++++++++++++++++++ tests/tcg/aarch64/gdbstub/test-sve-ioctl.py | 34 +---------- tests/tcg/aarch64/gdbstub/test-sve.py | 33 +---------- tests/tcg/multiarch/gdbstub/interrupt.py | 47 ++-------------- tests/tcg/multiarch/gdbstub/memory.py | 41 +------------- tests/tcg/multiarch/gdbstub/registers.py | 41 ++------------ tests/tcg/multiarch/gdbstub/sha1.py | 40 ++----------- .../multiarch/gdbstub/test-proc-mappings.py | 39 +------------ .../multiarch/gdbstub/test-qxfer-auxv-read.py | 37 +----------- .../gdbstub/test-thread-breakpoint.py | 37 +----------- tests/tcg/s390x/gdbstub/test-signals-s390x.py | 42 +------------- tests/tcg/s390x/gdbstub/test-svc.py | 39 +------------ 13 files changed, 96 insertions(+), 397 deletions(-) create mode 100644 tests/guest-debug/test_gdbstub.py
tests/guest-debug/run-test.py +6 -1
@@ -97,7 +97,12 @@ def log(output, msg): sleep(1) log(output, "GDB CMD: %s" % (gdb_cmd)) - result = subprocess.call(gdb_cmd, shell=True, stdout=output, stderr=stderr) + gdb_env = dict(os.environ) + gdb_pythonpath = gdb_env.get("PYTHONPATH", "").split(os.pathsep) + gdb_pythonpath.append(os.path.dirname(os.path.realpath(__file__))) + gdb_env["PYTHONPATH"] = os.pathsep.join(gdb_pythonpath) + result = subprocess.call(gdb_cmd, shell=True, stdout=output, stderr=stderr, + env=gdb_env) # A result of greater than 128 indicates a fatal signal (likely a # crash due to gdb internal failure). That's a problem for GDB and
tests/guest-debug/test_gdbstub.py new file +56 -0
56 lines not on this page · raw message
tests/tcg/aarch64/gdbstub/test-sve-ioctl.py +2 -32
@@ -8,19 +8,10 @@ # import gdb -import sys +from test_gdbstub import main, report initial_vlen = 0 -failcount = 0 -def report(cond, msg): - "Report success/fail of test" - if cond: - print ("PASS: %s" % (msg)) - else: - print ("FAIL: %s" % (msg)) - global failcount - failcount += 1 class TestBreakpoint(gdb.Breakpoint): def __init__(self, sym_name="__sve_ld_done"):
@@ -64,26 +55,5 @@ def run_test(): gdb.execute("c") -# -# This runs as the script it sourced (via -x, via run-test.py) -# -try: - inferior = gdb.selected_inferior() - arch = inferior.architecture() - report(arch.name() == "aarch64", "connected to aarch64") -except (gdb.error, AttributeError): - print("SKIPPING (not connected)", file=sys.stderr) - exit(0) - -try: - # Run the actual tests - run_test() -except: - print ("GDB Exception: %s" % (sys.exc_info()[0])) - failcount += 1 - import code - code.InteractiveConsole(locals=globals()).interact() - raise -print("All tests complete: %d failures" % failcount) -exit(failcount) +main(run_test, expected_arch="aarch64")
tests/tcg/aarch64/gdbstub/test-sve.py +2 -31
@@ -6,20 +6,10 @@ # import gdb -import sys +from test_gdbstub import main, report MAGIC = 0xDEADBEEF -failcount = 0 - -def report(cond, msg): - "Report success/fail of test" - if cond: - print ("PASS: %s" % (msg)) - else: - print ("FAIL: %s" % (msg)) - global failcount - failcount += 1 def run_test(): "Run through the tests one by one"
@@ -54,24 +44,5 @@ def run_test(): report(str(v.type) == "uint64_t", "size of %s" % (reg)) report(int(v) == MAGIC, "%s is 0x%x" % (reg, MAGIC)) -# -# This runs as the script it sourced (via -x, via run-test.py) -# -try: - inferior = gdb.selected_inferior() - arch = inferior.architecture() - report(arch.name() == "aarch64", "connected to aarch64") -except (gdb.error, AttributeError): - print("SKIPPING (not connected)", file=sys.stderr) - exit(0) - -try: - # Run the actual tests - run_test() -except: - print ("GDB Exception: %s" % (sys.exc_info()[0])) - failcount += 1 - -print("All tests complete: %d failures" % failcount) -exit(failcount) +main(run_test, expected_arch="aarch64")
tests/tcg/multiarch/gdbstub/interrupt.py +5 -42
62 lines not on this page · raw message
tests/tcg/multiarch/gdbstub/memory.py +3 -38
50 lines not on this page · raw message
tests/tcg/multiarch/gdbstub/registers.py +6 -35
71 lines not on this page · raw message
tests/tcg/multiarch/gdbstub/sha1.py +5 -35
@@ -7,19 +7,11 @@ # import gdb -import sys +from test_gdbstub import main, report + initial_vlen = 0 -failcount = 0 -def report(cond, msg): - "Report success/fail of test" - if cond: - print("PASS: %s" % (msg)) - else: - print("FAIL: %s" % (msg)) - global failcount - failcount += 1 def check_break(sym_name): "Setup breakpoint, continue and check we stopped."
@@ -35,6 +27,7 @@ def check_break(sym_name): bp.delete() + def run_test(): "Run through the tests one by one"
@@ -57,28 +50,5 @@ def run_test(): # finally check we don't barf inspecting registers gdb.execute("info registers") -# -# This runs as the script it sourced (via -x, via run-test.py) -# -try: - inferior = gdb.selected_inferior() - arch = inferior.architecture() - print("ATTACHED: %s" % arch.name()) -except (gdb.error, AttributeError): - print("SKIPPING (not connected)", file=sys.stderr) - exit(0) - -if gdb.parse_and_eval('$pc') == 0: - print("SKIP: PC not set") - exit(0) - -try: - # Run the actual tests - run_test() -except (gdb.error): - print ("GDB Exception: %s" % (sys.exc_info()[0])) - failcount += 1 - pass - -print("All tests complete: %d failures" % failcount) -exit(failcount) + +main(run_test)
tests/tcg/multiarch/gdbstub/test-proc-mappings.py +2 -37
@@ -3,20 +3,7 @@ This runs as a sourced script (via -x, via run-test.py).""" from __future__ import print_function import gdb -import sys - - -n_failures = 0 - - -def report(cond, msg): - """Report success/fail of a test""" - if cond: - print("PASS: {}".format(msg)) - else: - print("FAIL: {}".format(msg)) - global n_failures - n_failures += 1 +from test_gdbstub import main, report def run_test():
@@ -37,26 +24,4 @@ def run_test(): # report("/sha1" in mappings, "Found the test binary name in the mappings") -def main(): - """Prepare the environment and run through the tests""" - try: - inferior = gdb.selected_inferior() - print("ATTACHED: {}".format(inferior.architecture().name())) - except (gdb.error, AttributeError): - print("SKIPPING (not connected)") - exit(0) - - if gdb.parse_and_eval('$pc') == 0: - print("SKIP: PC not set") - exit(0) - - try: - # Run the actual tests - run_test() - except gdb.error: - report(False, "GDB Exception: {}".format(sys.exc_info()[0])) - print("All tests complete: %d failures" % n_failures) - exit(n_failures) - - -main() +main(run_test)
tests/tcg/multiarch/gdbstub/test-qxfer-auxv-read.py +2 -35
@@ -6,18 +6,8 @@ # import gdb -import sys +from test_gdbstub import main, report -failcount = 0 - -def report(cond, msg): - "Report success/fail of test" - if cond: - print ("PASS: %s" % (msg)) - else: - print ("FAIL: %s" % (msg)) - global failcount - failcount += 1 def run_test(): "Run through the tests one by one"
@@ -26,28 +16,5 @@ def run_test(): report(isinstance(auxv, str), "Fetched auxv from inferior") report(auxv.find("sha1"), "Found test binary name in auxv") -# -# This runs as the script it sourced (via -x, via run-test.py) -# -try: - inferior = gdb.selected_inferior() - arch = inferior.architecture() - print("ATTACHED: %s" % arch.name()) -except (gdb.error, AttributeError): - print("SKIPPING (not connected)", file=sys.stderr) - exit(0) - -if gdb.parse_and_eval('$pc') == 0: - print("SKIP: PC not set") - exit(0) - -try: - # Run the actual tests - run_test() -except (gdb.error): - print ("GDB Exception: %s" % (sys.exc_info()[0])) - failcount += 1 - pass -print("All tests complete: %d failures" % failcount) -exit(failcount) +main(run_test)
tests/tcg/multiarch/gdbstub/test-thread-breakpoint.py +2 -35
@@ -6,18 +6,8 @@ # import gdb -import sys +from test_gdbstub import main, report -failcount = 0 - -def report(cond, msg): - "Report success/fail of test" - if cond: - print ("PASS: %s" % (msg)) - else: - print ("FAIL: %s" % (msg)) - global failcount - failcount += 1 def run_test(): "Run through the tests one by one"
@@ -29,28 +19,5 @@ def run_test(): frame = gdb.selected_frame() report(str(frame.function()) == "thread1_func", "break @ %s"%frame) -# -# This runs as the script it sourced (via -x, via run-test.py) -# -try: - inferior = gdb.selected_inferior() - arch = inferior.architecture() - print("ATTACHED: %s" % arch.name()) -except (gdb.error, AttributeError): - print("SKIPPING (not connected)", file=sys.stderr) - exit(0) - -if gdb.parse_and_eval('$pc') == 0: - print("SKIP: PC not set") - exit(0) - -try: - # Run the actual tests - run_test() -except (gdb.error): - print ("GDB Exception: %s" % (sys.exc_info()[0])) - failcount += 1 - pass -print("All tests complete: %d failures" % failcount) -exit(failcount) +main(run_test)
tests/tcg/s390x/gdbstub/test-signals-s390x.py +3 -39
53 lines not on this page · raw message
tests/tcg/s390x/gdbstub/test-svc.py +2 -37
@@ -3,20 +3,7 @@ This runs as a sourced script (via -x, via run-test.py).""" from __future__ import print_function import gdb -import sys - - -n_failures = 0 - - -def report(cond, msg): - """Report success/fail of a test""" - if cond: - print("PASS: {}".format(msg)) - else: - print("FAIL: {}".format(msg)) - global n_failures - n_failures += 1 +from test_gdbstub import main, report def run_test():
@@ -35,26 +22,4 @@ def run_test(): gdb.execute("si") -def main(): - """Prepare the environment and run through the tests""" - try: - inferior = gdb.selected_inferior() - print("ATTACHED: {}".format(inferior.architecture().name())) - except (gdb.error, AttributeError): - print("SKIPPING (not connected)") - exit(0) - - if gdb.parse_and_eval('$pc') == 0: - print("SKIP: PC not set") - exit(0) - - try: - # Run the actual tests - run_test() - except gdb.error: - report(False, "GDB Exception: {}".format(sys.exc_info()[0])) - print("All tests complete: %d failures" % n_failures) - exit(n_failures) - - -main() +main(run_test)
Signature · 1 line
2.43.0
PATCH 3/3 tests/tcg: Add the PROT_NONE gdbstub test
In reply to Ilya LeoshkevichMake sure that qemu gdbstub, like gdbserver, allows reading from and writing to PROT_NONE pages.
--- tests/tcg/multiarch/Makefile.target | 9 +++++- tests/tcg/multiarch/gdbstub/prot-none.py | 22 ++++++++++++++ tests/tcg/multiarch/prot-none.c | 38 ++++++++++++++++++++++++ 3 files changed, 68 insertions(+), 1 deletion(-) create mode 100644 tests/tcg/multiarch/gdbstub/prot-none.py create mode 100644 tests/tcg/multiarch/prot-none.c
tests/tcg/multiarch/Makefile.target +8 -1
@@ -101,13 +101,20 @@ run-gdbstub-registers: sha512 --bin $< --test $(MULTIARCH_SRC)/gdbstub/registers.py, \ checking register enumeration) +run-gdbstub-prot-none: prot-none + $(call run-test, $@, env PROT_NONE_PY=1 $(GDB_SCRIPT) \ + --gdb $(GDB) \ + --qemu $(QEMU) --qargs "$(QEMU_OPTS)" \ + --bin $< --test $(MULTIARCH_SRC)/gdbstub/prot-none.py, \ + accessing PROT_NONE memory) + else run-gdbstub-%: $(call skip-test, "gdbstub test $*", "need working gdb with $(patsubst -%,,$(TARGET_NAME)) support") endif EXTRA_RUNS += run-gdbstub-sha1 run-gdbstub-qxfer-auxv-read \ run-gdbstub-proc-mappings run-gdbstub-thread-breakpoint \ - run-gdbstub-registers + run-gdbstub-registers run-gdbstub-prot-none # ARM Compatible Semi Hosting Tests #
tests/tcg/multiarch/gdbstub/prot-none.py new file +22 -0
@@ -0,0 +1,22 @@ +"""Test that GDB can access PROT_NONE pages. + +This runs as a sourced script (via -x, via run-test.py). + +SPDX-License-Identifier: GPL-2.0-or-later +""" +from test_gdbstub import main, report + + +def run_test(): + """Run through the tests one by one""" + gdb.Breakpoint("break_here") + gdb.execute("continue") + val = int(gdb.parse_and_eval("*p")) + report(val == 42, "{} != 42".format(val)) + gdb.execute("set *p = 24") + gdb.execute("continue") + exitcode = int(gdb.parse_and_eval("$_exitcode")) + report(exitcode == 0, "{} != 0".format(exitcode)) + + +main(run_test)
tests/tcg/multiarch/prot-none.c new file +38 -0
@@ -0,0 +1,38 @@ +/* +* Test that GDB can access PROT_NONE pages. +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ +#include <assert.h> +#include <stdlib.h> +#include <sys/mman.h> +#include <unistd.h> + +void break_here (long *p) +{ +} + +int main (void ) +{ +long pagesize =sysconf (_SC_PAGESIZE); +int err; +long *p; + + p =mmap (NULL , pagesize,PROT_READ |PROT_WRITE , +MAP_PRIVATE |MAP_ANONYMOUS ,-1 ,0 ); +assert (p !=MAP_FAILED ); + *p =42 ; + + err =mprotect (p, pagesize,PROT_NONE ); +assert (err ==0 ); + +break_here (p); + + err =mprotect (p, pagesize,PROT_READ ); +assert (err ==0 ); +if (getenv ("PROT_NONE_PY" )) { +assert (*p ==24 ); + } + +return EXIT_SUCCESS ; +}
Signature · 1 line
2.43.0