fix(debug): hardware watchpoints, signal stops and breakpoint restore

Assisted-by: GLM 5.3

debug/watchpoint_linux_riscv64.go

@@ -7,11 +7,16 @@ package debug
 
 import (
 	"fmt"
-	"syscall"
 )
 
-// Hardware watchpoint support for RISC-V via Sdtrig trigger registers.
-// Uses PTRACE_POKEUSER/PEEKUSER to access debug registers.
+// Hardware watchpoints are not reachable through the riscv64 kernel ptrace
+// interface.  arch/riscv/kernel/ptrace.c forwards every POKEUSER/PEEKUSER to
+// the generic ptrace_request, and the riscv user_regset view contains only
+// the GPR, FP and vector regsets: there is no debug-register or trigger
+// regset, and offsets outside the view fail with EIO.  The Sdtrig CSRs
+// (tselect/tdata1/tdata2) are not exposed to ptrace either.  Until the
+// kernel grows a trigger regset, SetWatchpoint reports the fact instead of
+// poking a window that does not exist.
 
 // WatchpointType selects what triggers the watchpoint.
 type WatchpointType int
@@ -21,10 +26,18 @@ const (
 	WatchRead  WatchpointType = 3
 )
 
-const maxWatchpoints = 4
+// maxWatchpoints reports the number of hardware watchpoint slots the
+// architecture provides.  riscv64 exposes none via ptrace; the bound exists
+// so the slot bookkeeping stays consistent.
+func maxWatchpoints() int { return 4 }
+
+// archWatchpointAddr resolves the address of the watchpoint that fired.
+// Unreachable in practice (watchpoints cannot be armed), but si_addr names
+// the accessed address where the kernel does report one.
+func archWatchpointAddr(s *Session, siAddr uint64) uint64 { return siAddr }
 
 func (s *Session) FindFreeWatchpointSlot() int {
-	for i := range maxWatchpoints {
+	for i := range maxWatchpoints() {
 		if !s.wpSlots[i] {
 			return i
 		}
@@ -33,115 +46,26 @@ func (s *Session) FindFreeWatchpointSlot() int {
 }
 
 func (s *Session) IsWatchpointSlotUsed(slot int) bool {
-	if slot < 0 || slot >= maxWatchpoints {
+	if slot < 0 || slot >= maxWatchpoints() {
 		return false
 	}
 	return s.wpSlots[slot]
 }
 
-// SetWatchpoint installs a hardware watchpoint.
+// SetWatchpoint always fails: the riscv64 kernel ptrace interface has no
+// hardware-watchpoint access.
 func (s *Session) SetWatchpoint(slot int, addr uint64, typ WatchpointType, size int) error {
-	if slot < 0 || slot >= maxWatchpoints {
-		return fmt.Errorf("debug: watchpoint slot must be 0-%d", maxWatchpoints-1)
-	}
-	if s.wpSlots[slot] {
-		return fmt.Errorf("debug: watchpoint slot %d already in use", slot)
-	}
-	if size != 1 && size != 2 && size != 4 && size != 8 {
-		return fmt.Errorf("debug: watchpoint size must be 1, 2, 4, or 8")
-	}
-
-	// RISC-V trigger registers: tdata1 encodes type/control, tdata2 holds address.
-	// The exact encoding depends on the trigger implementation (Sdtrig).
-	// Use PTRACE_POKEUSER to write to the trigger CSRs via the kernel's
-	// debug register interface.
-	if err := ptracePokeUser(s.pid, uintptr(0x1000+slot*8), addr); err != nil {
-		return fmt.Errorf("debug: set watchpoint address: %w", err)
-	}
-
-	// tdata1: set match control.  Mode=2 (data match), select=0, action=1 (debug exception).
-	var tdata1 uint64 = 2 << 60 // type = match (2)
-	tdata1 |= 1 << 0            // action = enter debug mode
-	tdata1 |= 1 << 7            // store (write) trigger
-	if typ == WatchRead {
-		tdata1 |= 1 << 6 // load trigger
-	}
-	// Size encoding: 0=1byte, 1=2byte, 2=4byte, 3=8byte.
-	var sizeBits uint64
-	switch size {
-	case 1:
-		sizeBits = 0
-	case 2:
-		sizeBits = 1
-	case 4:
-		sizeBits = 2
-	case 8:
-		sizeBits = 3
-	}
-	tdata1 |= sizeBits << 16 // size field
-
-	if err := ptracePokeUser(s.pid, uintptr(0x1001+slot*8), tdata1); err != nil {
-		return fmt.Errorf("debug: set watchpoint control: %w", err)
-	}
-
-	s.wpSlots[slot] = true
-	return nil
+	return fmt.Errorf("debug: hardware watchpoints are not supported by the riscv64 kernel ptrace interface")
 }
 
+// ClearWatchpoint always fails: no watchpoint can ever be armed.
 func (s *Session) ClearWatchpoint(slot int) error {
-	if slot < 0 || slot >= maxWatchpoints {
-		return fmt.Errorf("debug: watchpoint slot must be 0-%d", maxWatchpoints-1)
+	if slot < 0 || slot >= maxWatchpoints() {
+		return fmt.Errorf("debug: watchpoint slot must be 0-%d", maxWatchpoints()-1)
 	}
-	if !s.wpSlots[slot] {
-		return fmt.Errorf("debug: watchpoint slot %d is not in use", slot)
-	}
-
-	// Disable by clearing tdata1.
-	if err := ptracePokeUser(s.pid, uintptr(0x1001+slot*8), 0); err != nil {
-		return err
-	}
-	s.wpSlots[slot] = false
-	return nil
+	return fmt.Errorf("debug: watchpoint slot %d is not in use", slot)
 }
 
 func (s *Session) ClearAllWatchpoints() error {
-	for slot := 0; slot < maxWatchpoints; slot++ {
-		if s.wpSlots[slot] {
-			if err := s.ClearWatchpoint(slot); err != nil {
-				return err
-			}
-		}
-	}
 	return nil
 }
-
-func ptracePokeUser(pid int, offset uintptr, val uint64) error {
-	const ptracePokeuser = 6
-	_, _, errno := syscall.Syscall6(
-		syscall.SYS_PTRACE,
-		uintptr(ptracePokeuser),
-		uintptr(pid),
-		offset,
-		uintptr(val),
-		0, 0,
-	)
-	if errno != 0 {
-		return errno
-	}
-	return nil
-}
-
-func ptracePeekUser(pid int, offset uintptr) (uint64, error) {
-	const ptracePeekuser = 3
-	val, _, errno := syscall.Syscall6(
-		syscall.SYS_PTRACE,
-		uintptr(ptracePeekuser),
-		uintptr(pid),
-		offset,
-		0, 0, 0,
-	)
-	if errno != 0 {
-		return 0, errno
-	}
-	return uint64(val), nil
-}