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
106 lines
3.5 KiB
Go
106 lines
3.5 KiB
Go
package proc
|
|
|
|
// Process represents the target of the debugger. This
|
|
// target could be a system process, core file, etc.
|
|
//
|
|
// Implementations of Process are not required to be thread safe and users
|
|
// of Process should not assume they are.
|
|
// There is one exception to this rule: it is safe to call RequestManualStop
|
|
// concurrently with ContinueOnce.
|
|
type Process interface {
|
|
Info
|
|
ProcessManipulation
|
|
RecordingManipulation
|
|
|
|
Breakpoints() *BreakpointMap
|
|
|
|
// Memory returns a memory read/writer for this process's memory.
|
|
Memory() MemoryReadWriter
|
|
}
|
|
|
|
// ProcessInternal holds a set of methods that are not meant to be called by
|
|
// anyone except for an instance of `proc.Target`. These methods are not
|
|
// safe to use by themselves and should never be called directly outside of
|
|
// the `proc` package.
|
|
// This is temporary and in support of an ongoing refactor.
|
|
type ProcessInternal interface {
|
|
// Restart restarts the recording from the specified position, or from the
|
|
// last checkpoint if pos == "".
|
|
// If pos starts with 'c' it's a checkpoint ID, otherwise it's an event
|
|
// number.
|
|
// Returns the new current thread after the restart has completed.
|
|
Restart(pos string) (Thread, error)
|
|
Detach(bool) error
|
|
ContinueOnce() (trapthread Thread, stopReason StopReason, err error)
|
|
|
|
WriteBreakpoint(addr uint64) (file string, line int, fn *Function, originalData []byte, err error)
|
|
EraseBreakpoint(*Breakpoint) error
|
|
}
|
|
|
|
// RecordingManipulation is an interface for manipulating process recordings.
|
|
type RecordingManipulation interface {
|
|
// Recorded returns true if the current process is a recording and the path
|
|
// to the trace directory.
|
|
Recorded() (recorded bool, tracedir string)
|
|
// Direction changes execution direction.
|
|
ChangeDirection(Direction) error
|
|
// GetDirection returns the current direction of execution.
|
|
GetDirection() Direction
|
|
// When returns current recording position.
|
|
When() (string, error)
|
|
// Checkpoint sets a checkpoint at the current position.
|
|
Checkpoint(where string) (id int, err error)
|
|
// Checkpoints returns the list of currently set checkpoint.
|
|
Checkpoints() ([]Checkpoint, error)
|
|
// ClearCheckpoint removes a checkpoint.
|
|
ClearCheckpoint(id int) error
|
|
}
|
|
|
|
// Direction is the direction of execution for the target process.
|
|
type Direction int8
|
|
|
|
const (
|
|
// Forward direction executes the target normally.
|
|
Forward Direction = 0
|
|
// Backward direction executes the target in reverse.
|
|
Backward Direction = 1
|
|
)
|
|
|
|
// Checkpoint is a checkpoint
|
|
type Checkpoint struct {
|
|
ID int
|
|
When string
|
|
Where string
|
|
}
|
|
|
|
// Info is an interface that provides general information on the target.
|
|
type Info interface {
|
|
Pid() int
|
|
// ResumeNotify specifies a channel that will be closed the next time
|
|
// ContinueOnce finishes resuming the target.
|
|
ResumeNotify(chan<- struct{})
|
|
// Valid returns true if this Process can be used. When it returns false it
|
|
// also returns an error describing why the Process is invalid (either
|
|
// ErrProcessExited or ErrProcessDetached).
|
|
Valid() (bool, error)
|
|
BinInfo() *BinaryInfo
|
|
EntryPoint() (uint64, error)
|
|
|
|
ThreadInfo
|
|
}
|
|
|
|
// ThreadInfo is an interface for getting information on active threads
|
|
// in the process.
|
|
type ThreadInfo interface {
|
|
FindThread(threadID int) (Thread, bool)
|
|
ThreadList() []Thread
|
|
}
|
|
|
|
// ProcessManipulation is an interface for changing the execution state of a process.
|
|
type ProcessManipulation interface {
|
|
RequestManualStop() error
|
|
// CheckAndClearManualStopRequest returns true the first time it's called
|
|
// after a call to RequestManualStop.
|
|
CheckAndClearManualStopRequest() bool
|
|
}
|