petrbalvin
b5d6f1b46a
The Go runtime can migrate the debuggee's target-mode goroutine off the process leader before PTRACE_TRACEME, which left the trace relation on a thread the session never addressed: its stops starved the waits on the leader, and a kill sequence that resumed nothing and then blocked in Wait4 hung the whole package. The debuggee now reports the traced thread in the launch handshake and parks with a thread-directed stop, every ptrace request and wait addresses that thread, a SIGURG arriving on a single-step resumes it as a single-step again instead of letting the tracee run uncontrolled, a resume rejected with ESRCH lifts a group-stop with SIGCONT and retries once, and Kill resumes, kills and reaps through non-blocking waits so it returns for a tracee in any state. Assisted-by: GLM 5.3
95 lines
2.2 KiB
Go
95 lines
2.2 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
//go:build linux && arm64
|
|
|
|
package debug
|
|
|
|
import (
|
|
"fmt"
|
|
"syscall"
|
|
"unsafe"
|
|
)
|
|
|
|
// GetRegs reads the general-purpose registers of the stopped debuggee.
|
|
func (s *Session) GetRegs() (Regs, error) {
|
|
var regs Regs
|
|
_, _, errno := syscall.Syscall6(
|
|
syscall.SYS_PTRACE,
|
|
uintptr(syscall.PTRACE_GETREGS),
|
|
uintptr(s.tid),
|
|
0,
|
|
uintptr(unsafe.Pointer(®s)),
|
|
0, 0,
|
|
)
|
|
if errno != 0 {
|
|
return regs, fmt.Errorf("debug: PTRACE_GETREGS: %w", errno)
|
|
}
|
|
return regs, nil
|
|
}
|
|
|
|
// SetRegs writes the general-purpose registers of the stopped debuggee.
|
|
func (s *Session) SetRegs(regs *Regs) error {
|
|
_, _, errno := syscall.Syscall6(
|
|
syscall.SYS_PTRACE,
|
|
uintptr(syscall.PTRACE_SETREGS),
|
|
uintptr(s.tid),
|
|
0,
|
|
uintptr(unsafe.Pointer(regs)),
|
|
0, 0,
|
|
)
|
|
if errno != 0 {
|
|
return fmt.Errorf("debug: PTRACE_SETREGS: %w", errno)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ntPrFPREG is the NT_PRFPREG note type (ELF NT ver): the FP register set.
|
|
const ntPrFPREG = 0x2
|
|
|
|
// FPRegs holds the arm64 FP/NEON register state, matching the kernel's
|
|
// user_fpsimd_struct layout (32 128-bit V registers, then FPSR and FPCR).
|
|
type FPRegs struct {
|
|
V [32][16]byte // V0-V31 (128-bit NEON/FP registers)
|
|
FPSR uint32
|
|
FPCR uint32
|
|
}
|
|
|
|
// GetFPRegs retrieves the FP register state via PTRACE_GETREGSET with
|
|
// NT_PRFPREG (this architecture has no PTRACE_GETFPREGS request).
|
|
func (s *Session) GetFPRegs() (FPRegs, error) {
|
|
var fp FPRegs
|
|
iovec := syscall.Iovec{
|
|
Base: (*byte)(unsafe.Pointer(&fp)),
|
|
Len: uint64(unsafe.Sizeof(fp)),
|
|
}
|
|
_, _, errno := syscall.Syscall6(
|
|
syscall.SYS_PTRACE,
|
|
uintptr(syscall.PTRACE_GETREGSET),
|
|
uintptr(s.tid),
|
|
uintptr(ntPrFPREG),
|
|
uintptr(unsafe.Pointer(&iovec)),
|
|
0, 0,
|
|
)
|
|
if errno != 0 {
|
|
return fp, fmt.Errorf("debug: PTRACE_GETREGSET (NT_PRFPREG): %w", errno)
|
|
}
|
|
return fp, nil
|
|
}
|
|
|
|
// VectorRegs holds the full SIMD register state.
|
|
type VectorRegs struct {
|
|
V [32][16]byte // V0-V31 (128-bit)
|
|
}
|
|
|
|
// GetVectorRegs retrieves the SIMD registers.
|
|
func (s *Session) GetVectorRegs() (VectorRegs, error) {
|
|
var v VectorRegs
|
|
fp, err := s.GetFPRegs()
|
|
if err != nil {
|
|
return v, err
|
|
}
|
|
copy(v.V[:][:], fp.V[:][:])
|
|
return v, nil
|
|
}
|