Skip to contentSkip to conversation

target/riscv: throw debug exception before page fault

PATCH Superseded Daniel Henrique Barboza 3 participants 8 messages Jan 20, 2025 – Jan 21, 2025 RISC-V

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

v2 cover target/riscv: throw debug exception before page fault

Hi,

This second version implements the change Richard suggested in v1, i.e. do not search for wps twice.

To do that we need to make an assumption that a watchpoint for a 64 bit address will have size 8, in particular when the user does not set a watchpoint size. To be consistent we also need to consider that 32 bit CPUs would use watchpoints of size 4, which is something we're not considering. Patch 1 was added to make things more consistent in this regard.

Patches based on master.

Changes from v1:
- patch 1 (new):
- add watchpoints of size 4 when dealing with 32 bit addresses
- patch 2:
- instead of looking for watchpoints twice, call cpu_check_watchpoint() and rely on fall-through in case no watchpoints are found
- v1 link: https://mail.gnu.org/archive/html/qemu-devel/2025-01/msg03575.html

Daniel Henrique Barboza (2):
target/riscv/debug.c: use wp size = 4 for 32-bit CPUs target/riscv: throw debug exception before page fault

 target/riscv/cpu_helper.c | 19 +++++++++++++++++++
 target/riscv/debug.c      |  6 ++++--
 2 files changed, 23 insertions(+), 2 deletions(-)
Signature · 1 line
2.47.1
#1 lore raw

PATCH v2 1/2 target/riscv/debug.c: use wp size = 4 for 32-bit CPUs

The mcontrol select bit (19) is always zero, meaning our triggers will always match virtual addresses. In this condition, if the user does not specify a size for the trigger, the access size defaults to XLEN.

At this moment we're using def_size = 8 regardless of CPU XLEN. Use def_size = 4 in case we're running 32 bits.

Fixes 95799e36c1 ("target/riscv: Add initial support for the Sdtrig extension")
---
 target/riscv/debug.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)
target/riscv/debug.c +4 -2
index f6241a80be..9db4048523 100644
@@ -478,7 +478,7 @@ static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index)
     bool enabled = type2_breakpoint_enabled(ctrl);
     CPUState *cs = env_cpu(env);
     int flags = BP_CPU | BP_STOP_BEFORE_ACCESS;
-    uint32_t size;
+    uint32_t size, def_size;
 
     if (!enabled) {
         return;
@@ -501,7 +501,9 @@ static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index)
             cpu_watchpoint_insert(cs, addr, size, flags,
                                   &env->cpu_watchpoint[index]);
         } else {
-            cpu_watchpoint_insert(cs, addr, 8, flags,
+            def_size = riscv_cpu_mxl(env) == MXL_RV64 ? 8 : 4;
+
+            cpu_watchpoint_insert(cs, addr, def_size, flags,
                                   &env->cpu_watchpoint[index]);
         }
     }
Signature · 1 line
2.47.1
Reviewed-by on v2 1/2
#2 lore raw

Re: [PATCH v2 1/2] target/riscv/debug.c: use wp size = 4 for 32-bit CPUs

Quoted 27 lines · Daniel Henrique Barboza

The mcontrol select bit (19) is always zero, meaning our triggers will always match virtual addresses. In this condition, if the user does not specify a size for the trigger, the access size defaults to XLEN.

At this moment we're using def_size = 8 regardless of CPU XLEN. Use def_size = 4 in case we're running 32 bits.

Fixes 95799e36c1 ("target/riscv: Add initial support for the Sdtrig extension")
---
  target/riscv/debug.c | 6 ++++--
  1 file changed, 4 insertions(+), 2 deletions(-)
target/riscv/debug.c +1 -1
index f6241a80be..9db4048523 100644
@@ -478,7 +478,7 @@ static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index)
      bool enabled = type2_breakpoint_enabled(ctrl);
      CPUState *cs = env_cpu(env);
      int flags = BP_CPU | BP_STOP_BEFORE_ACCESS;
-    uint32_t size;
+    uint32_t size, def_size;
 
      if (!enabled) {
          return;

target/riscv/debug.c static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index) · line 504

Quoted 5 lines
target/riscv/debug.c +1 -1
@@ -501,7 +501,9 @@ static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index)
              cpu_watchpoint_insert(cs, addr, size, flags,
                                    &env->cpu_watchpoint[index]);
          } else {
-            cpu_watchpoint_insert(cs, addr, 8, flags,
+            def_size = riscv_cpu_mxl(env) == MXL_RV64 ? 8 : 4;

riscv_cpu_mxl() seems bugprone w.r.t. MXL_RV128, better could be some riscv_cpu_mxl_wordsize() helper like riscv_cpu_mxl_bits() (or better named).

Anyway this pattern is already all over, so meanwhile:

Quoted 5 lines
target/riscv/debug.c +2 -0
+
+            cpu_watchpoint_insert(cs, addr, def_size, flags,
                                    &env->cpu_watchpoint[index]);
          }
      }
#3 lore raw

Re: [PATCH v2 1/2] target/riscv/debug.c: use wp size = 4 for 32-bit CPUs

Quoted 28 lines · Philippe Mathieu-Daudé
Quoted 27 lines · Daniel Henrique Barboza

The mcontrol select bit (19) is always zero, meaning our triggers will always match virtual addresses. In this condition, if the user does not specify a size for the trigger, the access size defaults to XLEN.

At this moment we're using def_size = 8 regardless of CPU XLEN. Use def_size = 4 in case we're running 32 bits.

Fixes 95799e36c1 ("target/riscv: Add initial support for the Sdtrig extension")

---
  target/riscv/debug.c | 6 ++++--

  1 file changed, 4 insertions(+), 2 deletions(-)
target/riscv/debug.c +1 -1
index f6241a80be..9db4048523 100644
@@ -478,7 +478,7 @@ static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index)
       bool enabled = type2_breakpoint_enabled(ctrl);
       CPUState *cs = env_cpu(env);
       int flags = BP_CPU | BP_STOP_BEFORE_ACCESS;
-    uint32_t size;
+    uint32_t size, def_size;
       if (!enabled) {
           return;
@@ -501,7 +501,9 @@ static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index)
               cpu_watchpoint_insert(cs, addr, size, flags,
Quoted 8 lines

target/riscv/debug.c static void type2_breakpoint_insert(CPURISCVState *env, target_ulong index) · line 504

Quoted 4 lines
target/riscv/debug.c +1 -1
                                     &env->cpu_watchpoint[index]);
           } else {
-            cpu_watchpoint_insert(cs, addr, 8, flags,
+            def_size = riscv_cpu_mxl(env) == MXL_RV64 ? 8 : 4;

riscv_cpu_mxl() seems bugprone w.r.t. MXL_RV128, better could be some riscv_cpu_mxl_wordsize() helper like riscv_cpu_mxl_bits() (or better named).

This existing pattern is benign since we don't have a functional RV128 and is safe seems to interpret RV64 == RV128.

However, if/when RV128 becomes a thing, we'll spare a moderate amount of agony if we choose to have a little suffering right now. I'll take a note about it and perhaps a refactor might be in order.

Thanks,

Daniel

Quoted 10 lines

Anyway this pattern is already all over, so meanwhile:

Quoted 5 lines
target/riscv/debug.c +2 -0
+
+            cpu_watchpoint_insert(cs, addr, def_size, flags,
                                     &env->cpu_watchpoint[index]);
           }
       }
#4 lore raw

Re: [PATCH v2 1/2] target/riscv/debug.c: use wp size = 4 for 32-bit CPUs

Quoted 30 lines · Daniel Henrique Barboza
Quoted 15 lines · Philippe Mathieu-Daudé
Quoted 12 lines · Daniel Henrique Barboza

The mcontrol select bit (19) is always zero, meaning our triggers will always match virtual addresses. In this condition, if the user does not specify a size for the trigger, the access size defaults to XLEN.

At this moment we're using def_size = 8 regardless of CPU XLEN. Use def_size = 4 in case we're running 32 bits.

Fixes 95799e36c1 ("target/riscv: Add initial support for the Sdtrig extension")

---
  target/riscv/debug.c | 6 ++++--

  1 file changed, 4 insertions(+), 2 deletions(-)
Quoted 11 lines

target/riscv/debug.c static void type2_breakpoint_insert(CPURISCVState · line 505

Quoted 7 lines
target/riscv/debug.c +1 -1
@@ -501,7 +501,9 @@ static void type2_breakpoint_insert(CPURISCVState 
 *env, target_ulong index)
               cpu_watchpoint_insert(cs, addr, size, flags,
                                     &env->cpu_watchpoint[index]);
           } else {
-            cpu_watchpoint_insert(cs, addr, 8, flags,
+            def_size = riscv_cpu_mxl(env) == MXL_RV64 ? 8 : 4;

riscv_cpu_mxl() seems bugprone w.r.t. MXL_RV128, better could be some riscv_cpu_mxl_wordsize() helper like riscv_cpu_mxl_bits() (or better named).

Quoted 4 lines

This existing pattern is benign since we don't have a functional RV128 and is safe seems to interpret RV64 == RV128.

However, if/when RV128 becomes a thing, we'll spare a moderate amount of agony

😱

Quoted 7 lines

if we choose to have a little suffering right now. I'll take a note about it and perhaps a refactor might be in order.

Thanks,

Daniel

#5 lore raw

PATCH v2 2/2 target/riscv: throw debug exception before page fault

In reply to Daniel Henrique Barboza

In the RISC-V privileged ISA section 3.1.15 table 15, it is determined that a debug exception that is triggered from a load/store has a higher priority than a possible fault that this access might trigger.

This is not the case ATM as shown in [1]. Adding a breakpoint in an address that deliberately will fault is causing a load page fault instead of a debug exception. The reason is that we're throwing in the page fault as soon as the fault occurs (end of riscv_cpu_tlb_fill(), raise_mmu_exception()), not allowing the installed watchpoints to trigger.

Call cpu_check_watchpoint() in the page fault path to search and execute any watchpoints that might exist for the address, never returning back to the fault path. If no watchpoints are found cpu_check_watchpoint() will return and we'll fall-through the regular path to raise_mmu_exception().

[1] https://gitlab.com/qemu-project/qemu/-/issues/2627

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2627

---
 target/riscv/cpu_helper.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
target/riscv/cpu_helper.c +19 -0
index e1dfc4ecbf..ae0a659ec7 100644
@@ -27,6 +27,7 @@
 #include "exec/page-protection.h"
 #include "instmap.h"
 #include "tcg/tcg-op.h"
+#include "hw/core/tcg-cpu-ops.h"
 #include "trace.h"
 #include "semihosting/common-semi.h"
 #include "system/cpu-timers.h"
@@ -1708,6 +1709,24 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,
     } else if (probe) {
         return false;
     } else {
+        int wp_len = riscv_cpu_mxl(env) == MXL_RV64 ? 8 : 4;
+        int wp_access = 0;
+
+        if (access_type == MMU_DATA_LOAD) {
+            wp_access |= BP_MEM_READ;
+        } else if (access_type == MMU_DATA_STORE) {
+            wp_access |= BP_MEM_WRITE;
+        }
+
+        /*
+         * If a watchpoint isn't found for 'addr' this will
+         * be a no-op and we'll resume the mmu_exception path.
+         * Otherwise we'll throw a debug exception and execution
+         * will continue elsewhere.
+         */
+        cpu_check_watchpoint(cs, address, wp_len, MEMTXATTRS_UNSPECIFIED,
+                             wp_access, retaddr);
+
         raise_mmu_exception(env, address, access_type, pmp_violation,
                             first_stage_error, two_stage_lookup,
                             two_stage_indirect_error);
Signature · 1 line
2.47.1
#6 lore raw
Quoted 38 lines · Daniel Henrique Barboza

In the RISC-V privileged ISA section 3.1.15 table 15, it is determined that a debug exception that is triggered from a load/store has a higher priority than a possible fault that this access might trigger.

This is not the case ATM as shown in [1]. Adding a breakpoint in an address that deliberately will fault is causing a load page fault instead of a debug exception. The reason is that we're throwing in the page fault as soon as the fault occurs (end of riscv_cpu_tlb_fill(), raise_mmu_exception()), not allowing the installed watchpoints to trigger.

Call cpu_check_watchpoint() in the page fault path to search and execute any watchpoints that might exist for the address, never returning back to the fault path. If no watchpoints are found cpu_check_watchpoint() will return and we'll fall-through the regular path to raise_mmu_exception().

[1] https://gitlab.com/qemu-project/qemu/-/issues/2627

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2627

---
  target/riscv/cpu_helper.c | 19 +++++++++++++++++++
  1 file changed, 19 insertions(+)
target/riscv/cpu_helper.c +1 -0
index e1dfc4ecbf..ae0a659ec7 100644
@@ -27,6 +27,7 @@
  #include "exec/page-protection.h"
  #include "instmap.h"
  #include "tcg/tcg-op.h"
+#include "hw/core/tcg-cpu-ops.h"
  #include "trace.h"
  #include "semihosting/common-semi.h"
  #include "system/cpu-timers.h"

target/riscv/cpu_helper.c bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, · line 1712

Quoted 4 lines
target/riscv/cpu_helper.c +1 -0
@@ -1708,6 +1709,24 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,
      } else if (probe) {
          return false;
      } else {
+        int wp_len = riscv_cpu_mxl(env) == MXL_RV64 ? 8 : 4;

Surely 'size' may be relevant?

r~

Quoted 20 lines
target/riscv/cpu_helper.c +17 -0
+        int wp_access = 0;
+
+        if (access_type == MMU_DATA_LOAD) {
+            wp_access |= BP_MEM_READ;
+        } else if (access_type == MMU_DATA_STORE) {
+            wp_access |= BP_MEM_WRITE;
+        }
+
+        /*
+         * If a watchpoint isn't found for 'addr' this will
+         * be a no-op and we'll resume the mmu_exception path.
+         * Otherwise we'll throw a debug exception and execution
+         * will continue elsewhere.
+         */
+        cpu_check_watchpoint(cs, address, wp_len, MEMTXATTRS_UNSPECIFIED,
+                             wp_access, retaddr);
+
          raise_mmu_exception(env, address, access_type, pmp_violation,
                              first_stage_error, two_stage_lookup,
                              two_stage_indirect_error);
#7 lore raw
Quoted 37 lines · Richard Henderson
Quoted 36 lines · Daniel Henrique Barboza

In the RISC-V privileged ISA section 3.1.15 table 15, it is determined that a debug exception that is triggered from a load/store has a higher priority than a possible fault that this access might trigger.

This is not the case ATM as shown in [1]. Adding a breakpoint in an address that deliberately will fault is causing a load page fault instead of a debug exception. The reason is that we're throwing in the page fault as soon as the fault occurs (end of riscv_cpu_tlb_fill(), raise_mmu_exception()), not allowing the installed watchpoints to trigger.

Call cpu_check_watchpoint() in the page fault path to search and execute any watchpoints that might exist for the address, never returning back to the fault path. If no watchpoints are found cpu_check_watchpoint() will return and we'll fall-through the regular path to raise_mmu_exception().

[1] https://gitlab.com/qemu-project/qemu/-/issues/2627

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2627

---
  target/riscv/cpu_helper.c | 19 +++++++++++++++++++

  1 file changed, 19 insertions(+)
target/riscv/cpu_helper.c +1 -0
index e1dfc4ecbf..ae0a659ec7 100644
@@ -27,6 +27,7 @@
   #include "exec/page-protection.h"
   #include "instmap.h"
   #include "tcg/tcg-op.h"
+#include "hw/core/tcg-cpu-ops.h"
   #include "trace.h"
   #include "semihosting/common-semi.h"
Quoted 8 lines

target/riscv/cpu_helper.c bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, · line 1712

Quoted 6 lines
target/riscv/cpu_helper.c +1 -0
   #include "system/cpu-timers.h"
@@ -1708,6 +1709,24 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,
       } else if (probe) {
           return false;
       } else {
+        int wp_len = riscv_cpu_mxl(env) == MXL_RV64 ? 8 : 4;

Surely 'size' may be relevant?

Ooops. Yeah, no need to infer wp_len if we can use the access size. I'll do a v3.

Thanks,

Daniel

Quoted 25 lines

r~

Quoted 20 lines
target/riscv/cpu_helper.c +17 -0
+        int wp_access = 0;
+
+        if (access_type == MMU_DATA_LOAD) {
+            wp_access |= BP_MEM_READ;
+        } else if (access_type == MMU_DATA_STORE) {
+            wp_access |= BP_MEM_WRITE;
+        }
+
+        /*
+         * If a watchpoint isn't found for 'addr' this will
+         * be a no-op and we'll resume the mmu_exception path.
+         * Otherwise we'll throw a debug exception and execution
+         * will continue elsewhere.
+         */
+        cpu_check_watchpoint(cs, address, wp_len, MEMTXATTRS_UNSPECIFIED,
+                             wp_access, retaddr);
+
           raise_mmu_exception(env, address, access_type, pmp_violation,
                               first_stage_error, two_stage_lookup,
                               two_stage_indirect_error);