0843376018
On linux we can not read memory if the thread we use to do it is occupied doing certain system calls. The exact conditions when this happens have never been clear. This problem was worked around by using the Blocked method which recognized the most common circumstances where this would happen. However this is a hack: Blocked returning true doesn't mean that the problem will manifest and Blocked returning false doesn't necessarily mean the problem will not manifest. A side effect of this is issue #2151 where sometimes we can't read the memory of a thread and find its associated goroutine. This commit fixes this problem by always reading memory using a thread we know to be good for this, specifically the one returned by ContinueOnce. In particular the changes are as follows: 1. Remove (ProcessInternal).CurrentThread and (ProcessInternal).SetCurrentThread, the "current thread" becomes a field of Target, CurrentThread becomes a (*Target) method and (*Target).SwitchThread basically just sets a field Target. 2. The backends keep track of their own internal idea of what the current thread is, to use it to read memory, this is the thread they return from ContinueOnce as trapthread 3. The current thread in the backend and the current thread in Target only ever get synchronized in two places: when the backend creates a Target object the currentThread field of Target is initialized with the backend's current thread and when (*Target).Restart gets called (when a recording is rewound the currentThread used by Target might not exist anymore). 4. We remove the MemoryReadWriter interface embedded in Thread and instead add a Memory method to Process that returns a MemoryReadWriter. The backends will return something here that will read memory using the current thread saved by the backend. 5. The Thread.Blocked method is removed One possible problem with this change is processes that have threads with different memory maps. As far as I can determine this could happen on old versions of linux but this option was removed in linux 2.5. Fixes #2151
128 lines
3.1 KiB
Go
128 lines
3.1 KiB
Go
//+build darwin,!macnative
|
|
|
|
package native
|
|
|
|
import (
|
|
"errors"
|
|
"sync"
|
|
|
|
"github.com/go-delve/delve/pkg/proc"
|
|
)
|
|
|
|
var ErrNativeBackendDisabled = errors.New("native backend disabled during compilation")
|
|
|
|
// Launch returns ErrNativeBackendDisabled.
|
|
func Launch(_ []string, _ string, _ proc.LaunchFlags, _ []string, _ string, _ [3]string) (*proc.Target, error) {
|
|
return nil, ErrNativeBackendDisabled
|
|
}
|
|
|
|
// Attach returns ErrNativeBackendDisabled.
|
|
func Attach(_ int, _ []string) (*proc.Target, error) {
|
|
return nil, ErrNativeBackendDisabled
|
|
}
|
|
|
|
// waitStatus is a synonym for the platform-specific WaitStatus
|
|
type waitStatus struct{}
|
|
|
|
// osSpecificDetails holds information specific to the OSX/Darwin
|
|
// operating system / kernel.
|
|
type osSpecificDetails struct{}
|
|
|
|
// osProcessDetails holds Darwin specific information.
|
|
type osProcessDetails struct{}
|
|
|
|
func findExecutable(path string, pid int) string {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func killProcess(pid int) error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func registers(thread *nativeThread) (proc.Registers, error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) loadProcessInformation(wg *sync.WaitGroup) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) requestManualStop() (err error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) resume() error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) trapWait(pid int) (*nativeThread, error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) stop(trapthread *nativeThread) (*nativeThread, error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) updateThreadList() error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) kill() (err error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (dbp *nativeProcess) detach(kill bool) error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
// EntryPoint returns the entry point for the process,
|
|
// useful for PIEs.
|
|
func (dbp *nativeProcess) EntryPoint() (uint64, error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
// SetPC sets the value of the PC register.
|
|
func (t *nativeThread) SetPC(pc uint64) error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
// SetSP sets the value of the SP register.
|
|
func (t *nativeThread) SetSP(sp uint64) error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
// SetDX sets the value of the DX register.
|
|
func (t *nativeThread) SetDX(dx uint64) error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
// ReadMemory reads len(buf) bytes at addr into buf.
|
|
func (t *nativeThread) ReadMemory(buf []byte, addr uint64) (int, error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
// WriteMemory writes the contents of data at addr.
|
|
func (t *nativeThread) WriteMemory(addr uint64, data []byte) (int, error) {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (t *nativeThread) resume() error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (t *nativeThread) singleStep() error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func (t *nativeThread) restoreRegisters(sr proc.Registers) error {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
// Stopped returns whether the thread is stopped at
|
|
// the operating system level.
|
|
func (t *nativeThread) Stopped() bool {
|
|
panic(ErrNativeBackendDisabled)
|
|
}
|
|
|
|
func initialize(dbp *nativeProcess) error { return nil }
|