145 lines
3.2 KiB
Go
145 lines
3.2 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
//go:build linux && loong64
|
|
|
|
package debug
|
|
|
|
import (
|
|
"fmt"
|
|
"syscall"
|
|
)
|
|
|
|
// Hardware watchpoint support for LoongArch via debug registers.
|
|
// Uses PTRACE_POKEUSER/PEEKUSER to access HW watchpoint registers.
|
|
|
|
// WatchpointType selects what triggers the watchpoint.
|
|
type WatchpointType int
|
|
|
|
const (
|
|
WatchWrite WatchpointType = 1
|
|
WatchRead WatchpointType = 3
|
|
)
|
|
|
|
const maxWatchpoints = 4
|
|
|
|
func (s *Session) FindFreeWatchpointSlot() int {
|
|
for i := range maxWatchpoints {
|
|
if !s.wpSlots[i] {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
func (s *Session) IsWatchpointSlotUsed(slot int) bool {
|
|
if slot < 0 || slot >= maxWatchpoints {
|
|
return false
|
|
}
|
|
return s.wpSlots[slot]
|
|
}
|
|
|
|
// SetWatchpoint installs a hardware watchpoint.
|
|
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")
|
|
}
|
|
|
|
// LoongArch debug registers: DBGWVR (watchpoint value) and DBGWCR (watchpoint control).
|
|
// Accessed via PTRACE_POKEUSER at architecture-specific offsets.
|
|
if err := ptracePokeUser(s.pid, uintptr(0x1000+slot*8), addr); err != nil {
|
|
return fmt.Errorf("debug: set watchpoint address: %w", err)
|
|
}
|
|
|
|
// DBGWCR: enable + type + size.
|
|
var wcr uint64 = 1 // enable
|
|
switch typ {
|
|
case WatchWrite:
|
|
wcr |= 1 << 3 // store
|
|
case WatchRead:
|
|
wcr |= 3 << 3 // load+store
|
|
}
|
|
var sizeBits uint64
|
|
switch size {
|
|
case 1:
|
|
sizeBits = 0
|
|
case 2:
|
|
sizeBits = 1
|
|
case 4:
|
|
sizeBits = 2
|
|
case 8:
|
|
sizeBits = 3
|
|
}
|
|
wcr |= sizeBits << 5
|
|
|
|
if err := ptracePokeUser(s.pid, uintptr(0x1001+slot*8), wcr); err != nil {
|
|
return fmt.Errorf("debug: set watchpoint control: %w", err)
|
|
}
|
|
|
|
s.wpSlots[slot] = true
|
|
return nil
|
|
}
|
|
|
|
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 !s.wpSlots[slot] {
|
|
return fmt.Errorf("debug: watchpoint slot %d is not in use", slot)
|
|
}
|
|
|
|
if err := ptracePokeUser(s.pid, uintptr(0x1001+slot*8), 0); err != nil {
|
|
return err
|
|
}
|
|
s.wpSlots[slot] = false
|
|
return nil
|
|
}
|
|
|
|
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
|
|
}
|