From 3c8d4d52b825e313f21824da63c0904ba2ebb76e Mon Sep 17 00:00:00 2001 From: aarzilli Date: Thu, 26 Mar 2020 13:05:09 +0100 Subject: [PATCH] *: un-export unnecessarily public symbols --- pkg/dwarf/frame/entries.go | 2 +- pkg/dwarf/frame/entries_test.go | 2 +- pkg/dwarf/frame/parser.go | 2 +- pkg/dwarf/frame/table.go | 4 +- pkg/proc/core/core.go | 120 +++++++-------- pkg/proc/core/core_test.go | 4 +- pkg/proc/core/linux_core.go | 138 ++++++++--------- pkg/proc/core/windows_amd64_minidump.go | 10 +- pkg/proc/gdbserial/gdbserver.go | 164 ++++++++++----------- pkg/proc/gdbserial/gdbserver_conn.go | 2 +- pkg/proc/gdbserial/rr.go | 2 +- pkg/proc/native/nonative_darwin.go | 54 +++---- pkg/proc/native/proc.go | 84 +++++------ pkg/proc/native/proc_darwin.go | 44 +++--- pkg/proc/native/proc_freebsd.go | 70 ++++----- pkg/proc/native/proc_linux.go | 60 ++++---- pkg/proc/native/proc_windows.go | 38 ++--- pkg/proc/native/ptrace_darwin.go | 16 +- pkg/proc/native/ptrace_freebsd.go | 20 +-- pkg/proc/native/ptrace_linux.go | 37 +---- pkg/proc/native/ptrace_linux_386.go | 16 +- pkg/proc/native/ptrace_linux_64bit.go | 8 +- pkg/proc/native/ptrace_linux_amd64.go | 6 +- pkg/proc/native/register_linux_386.go | 14 +- pkg/proc/native/registers_darwin_amd64.go | 8 +- pkg/proc/native/registers_freebsd_amd64.go | 12 +- pkg/proc/native/registers_linux_amd64.go | 12 +- pkg/proc/native/registers_linux_arm64.go | 24 +-- pkg/proc/native/registers_windows_amd64.go | 8 +- pkg/proc/native/threads.go | 32 ++-- pkg/proc/native/threads_darwin.go | 26 ++-- pkg/proc/native/threads_freebsd.go | 34 ++--- pkg/proc/native/threads_linux.go | 30 ++-- pkg/proc/native/threads_linux_386.go | 2 +- pkg/proc/native/threads_linux_amd64.go | 2 +- pkg/proc/native/threads_linux_arm64.go | 6 +- pkg/proc/native/threads_windows.go | 22 +-- pkg/proc/proc_test.go | 21 --- pkg/proc/test/support.go | 14 +- pkg/terminal/command.go | 60 ++++---- pkg/terminal/disasmprint.go | 2 +- 41 files changed, 593 insertions(+), 639 deletions(-) diff --git a/pkg/dwarf/frame/entries.go b/pkg/dwarf/frame/entries.go index 1607b1fc..f78b1853 100644 --- a/pkg/dwarf/frame/entries.go +++ b/pkg/dwarf/frame/entries.go @@ -53,7 +53,7 @@ func (fde *FrameDescriptionEntry) EstablishFrame(pc uint64) *FrameContext { type FrameDescriptionEntries []*FrameDescriptionEntry -func NewFrameIndex() FrameDescriptionEntries { +func newFrameIndex() FrameDescriptionEntries { return make(FrameDescriptionEntries, 0, 1000) } diff --git a/pkg/dwarf/frame/entries_test.go b/pkg/dwarf/frame/entries_test.go index cd919af4..30506380 100644 --- a/pkg/dwarf/frame/entries_test.go +++ b/pkg/dwarf/frame/entries_test.go @@ -13,7 +13,7 @@ func ptrSizeByRuntimeArch() int { } func TestFDEForPC(t *testing.T) { - frames := NewFrameIndex() + frames := newFrameIndex() frames = append(frames, &FrameDescriptionEntry{begin: 10, size: 40}, &FrameDescriptionEntry{begin: 50, size: 50}, diff --git a/pkg/dwarf/frame/parser.go b/pkg/dwarf/frame/parser.go index 6d12dad2..086b131c 100644 --- a/pkg/dwarf/frame/parser.go +++ b/pkg/dwarf/frame/parser.go @@ -29,7 +29,7 @@ type parseContext struct { func Parse(data []byte, order binary.ByteOrder, staticBase uint64, ptrSize int) FrameDescriptionEntries { var ( buf = bytes.NewBuffer(data) - pctx = &parseContext{buf: buf, entries: NewFrameIndex(), staticBase: staticBase, ptrSize: ptrSize} + pctx = &parseContext{buf: buf, entries: newFrameIndex(), staticBase: staticBase, ptrSize: ptrSize} ) for fn := parselength; buf.Len() != 0; { diff --git a/pkg/dwarf/frame/table.go b/pkg/dwarf/frame/table.go index 4857c370..c22a95f5 100644 --- a/pkg/dwarf/frame/table.go +++ b/pkg/dwarf/frame/table.go @@ -127,7 +127,7 @@ func executeCIEInstructions(cie *CommonInformationEntry) *FrameContext { buf: bytes.NewBuffer(initialInstructions), } - frame.ExecuteDwarfProgram() + frame.executeDwarfProgram() return frame } @@ -142,7 +142,7 @@ func executeDwarfProgramUntilPC(fde *FrameDescriptionEntry, pc uint64) *FrameCon return frame } -func (frame *FrameContext) ExecuteDwarfProgram() { +func (frame *FrameContext) executeDwarfProgram() { for frame.buf.Len() > 0 { executeDwarfInstruction(frame) } diff --git a/pkg/proc/core/core.go b/pkg/proc/core/core.go index 7da7c981..3e6aa1bb 100644 --- a/pkg/proc/core/core.go +++ b/pkg/proc/core/core.go @@ -9,7 +9,7 @@ import ( "github.com/go-delve/delve/pkg/proc" ) -// A SplicedMemory represents a memory space formed from multiple regions, +// A splicedMemory represents a memory space formed from multiple regions, // each of which may override previously regions. For example, in the following // core, the program text was loaded at 0x400000: // Start End Page Offset @@ -22,7 +22,7 @@ import ( // 0x0000000000002000 0x0000000000002000 RW 1000 // This can be represented in a SplicedMemory by adding the original region, // then putting the RW mapping on top of it. -type SplicedMemory struct { +type splicedMemory struct { readers []readerEntry } @@ -33,7 +33,7 @@ type readerEntry struct { } // Add adds a new region to the SplicedMemory, which may override existing regions. -func (r *SplicedMemory) Add(reader proc.MemoryReader, off, length uintptr) { +func (r *splicedMemory) Add(reader proc.MemoryReader, off, length uintptr) { if length == 0 { return } @@ -93,7 +93,7 @@ func (r *SplicedMemory) Add(reader proc.MemoryReader, off, length uintptr) { } // ReadMemory implements MemoryReader.ReadMemory. -func (r *SplicedMemory) ReadMemory(buf []byte, addr uintptr) (n int, err error) { +func (r *splicedMemory) ReadMemory(buf []byte, addr uintptr) (n int, err error) { started := false for _, entry := range r.readers { if entry.offset+entry.length < addr { @@ -132,40 +132,40 @@ func (r *SplicedMemory) ReadMemory(buf []byte, addr uintptr) (n int, err error) return n, nil } -// OffsetReaderAt wraps a ReaderAt into a MemoryReader, subtracting a fixed +// offsetReaderAt wraps a ReaderAt into a MemoryReader, subtracting a fixed // offset from the address. This is useful to represent a mapping in an address // space. For example, if program text is mapped in at 0x400000, an // OffsetReaderAt with offset 0x400000 can be wrapped around file.Open(program) // to return the results of a read in that part of the address space. -type OffsetReaderAt struct { +type offsetReaderAt struct { reader io.ReaderAt offset uintptr } // ReadMemory will read the memory at addr-offset. -func (r *OffsetReaderAt) ReadMemory(buf []byte, addr uintptr) (n int, err error) { +func (r *offsetReaderAt) ReadMemory(buf []byte, addr uintptr) (n int, err error) { return r.reader.ReadAt(buf, int64(addr-r.offset)) } -// Process represents a core file. -type Process struct { +// process represents a core file. +type process struct { mem proc.MemoryReader - Threads map[int]*Thread + Threads map[int]*thread pid int entryPoint uint64 bi *proc.BinaryInfo breakpoints proc.BreakpointMap - currentThread *Thread + currentThread *thread } -var _ proc.ProcessInternal = &Process{} +var _ proc.ProcessInternal = &process{} -// Thread represents a thread in the core file being debugged. -type Thread struct { +// thread represents a thread in the core file being debugged. +type thread struct { th osThread - p *Process + p *process common proc.CommonThread } @@ -189,7 +189,7 @@ var ( ErrChangeRegisterCore = errors.New("can not change register values of core process") ) -type openFn func(string, string) (*Process, error) +type openFn func(string, string) (*process, error) var openFns = []openFn{readLinuxCore, readAMD64Minidump} @@ -201,7 +201,7 @@ var ErrUnrecognizedFormat = errors.New("unrecognized core format") // If the DWARF information cannot be found in the binary, Delve will look // for external debug files in the directories passed in. func OpenCore(corePath, exePath string, debugInfoDirs []string) (*proc.Target, error) { - var p *Process + var p *process var err error for _, openFn := range openFns { p, err = openFn(corePath, exePath) @@ -222,49 +222,49 @@ func OpenCore(corePath, exePath string, debugInfoDirs []string) (*proc.Target, e } // BinInfo will return the binary info. -func (p *Process) BinInfo() *proc.BinaryInfo { +func (p *process) BinInfo() *proc.BinaryInfo { return p.bi } // EntryPoint will return the entry point address for this core file. -func (p *Process) EntryPoint() (uint64, error) { +func (p *process) EntryPoint() (uint64, error) { return p.entryPoint, nil } // writeBreakpoint is a noop function since you // cannot write breakpoints into core files. -func (p *Process) writeBreakpoint(addr uint64) (file string, line int, fn *proc.Function, originalData []byte, err error) { +func (p *process) writeBreakpoint(addr uint64) (file string, line int, fn *proc.Function, originalData []byte, err error) { return "", 0, nil, nil, errors.New("cannot write a breakpoint to a core file") } // Recorded returns whether this is a live or recorded process. Always returns true for core files. -func (p *Process) Recorded() (bool, string) { return true, "" } +func (p *process) Recorded() (bool, string) { return true, "" } // Restart will only return an error for core files, as they are not executing. -func (p *Process) Restart(string) error { return ErrContinueCore } +func (p *process) Restart(string) error { return ErrContinueCore } // ChangeDirection will only return an error as you cannot continue a core process. -func (p *Process) ChangeDirection(proc.Direction) error { return ErrContinueCore } +func (p *process) ChangeDirection(proc.Direction) error { return ErrContinueCore } // GetDirection will always return forward. -func (p *Process) GetDirection() proc.Direction { return proc.Forward } +func (p *process) GetDirection() proc.Direction { return proc.Forward } // When does not apply to core files, it is to support the Mozilla 'rr' backend. -func (p *Process) When() (string, error) { return "", nil } +func (p *process) When() (string, error) { return "", nil } // Checkpoint for core files returns an error, there is no execution of a core file. -func (p *Process) Checkpoint(string) (int, error) { return -1, ErrContinueCore } +func (p *process) Checkpoint(string) (int, error) { return -1, ErrContinueCore } // Checkpoints returns nil on core files, you cannot set checkpoints when debugging core files. -func (p *Process) Checkpoints() ([]proc.Checkpoint, error) { return nil, nil } +func (p *process) Checkpoints() ([]proc.Checkpoint, error) { return nil, nil } // ClearCheckpoint clears a checkpoint, but will only return an error for core files. -func (p *Process) ClearCheckpoint(int) error { return errors.New("checkpoint not found") } +func (p *process) ClearCheckpoint(int) error { return errors.New("checkpoint not found") } // ReadMemory will return memory from the core file at the specified location and put the // read memory into `data`, returning the length read, and returning an error if // the length read is shorter than the length of the `data` buffer. -func (t *Thread) ReadMemory(data []byte, addr uintptr) (n int, err error) { +func (t *thread) ReadMemory(data []byte, addr uintptr) (n int, err error) { n, err = t.p.mem.ReadMemory(data, addr) if err == nil && n != len(data) { err = ErrShortRead @@ -274,13 +274,13 @@ func (t *Thread) ReadMemory(data []byte, addr uintptr) (n int, err error) { // WriteMemory will only return an error for core files, you cannot write // to the memory of a core process. -func (t *Thread) WriteMemory(addr uintptr, data []byte) (int, error) { +func (t *thread) WriteMemory(addr uintptr, data []byte) (int, error) { return 0, ErrWriteCore } // Location returns the location of this thread based on // the value of the instruction pointer register. -func (t *Thread) Location() (*proc.Location, error) { +func (t *thread) Location() (*proc.Location, error) { regs, err := t.th.registers(false) if err != nil { return nil, err @@ -293,150 +293,150 @@ func (t *Thread) Location() (*proc.Location, error) { // Breakpoint returns the current breakpoint this thread is stopped at. // For core files this always returns an empty BreakpointState struct, as // there are no breakpoints when debugging core files. -func (t *Thread) Breakpoint() *proc.BreakpointState { +func (t *thread) Breakpoint() *proc.BreakpointState { return &proc.BreakpointState{} } // ThreadID returns the ID for this thread. -func (t *Thread) ThreadID() int { +func (t *thread) ThreadID() int { return int(t.th.pid()) } // Registers returns the current value of the registers for this thread. -func (t *Thread) Registers(floatingPoint bool) (proc.Registers, error) { +func (t *thread) Registers(floatingPoint bool) (proc.Registers, error) { return t.th.registers(floatingPoint) } // RestoreRegisters will only return an error for core files, // you cannot change register values for core files. -func (t *Thread) RestoreRegisters(proc.Registers) error { +func (t *thread) RestoreRegisters(proc.Registers) error { return ErrChangeRegisterCore } // BinInfo returns information about the binary. -func (t *Thread) BinInfo() *proc.BinaryInfo { +func (t *thread) BinInfo() *proc.BinaryInfo { return t.p.bi } // StepInstruction will only return an error for core files, // you cannot execute a core file. -func (t *Thread) StepInstruction() error { +func (t *thread) StepInstruction() error { return ErrContinueCore } // Blocked will return false always for core files as there is // no execution. -func (t *Thread) Blocked() bool { +func (t *thread) Blocked() bool { return false } // SetCurrentBreakpoint will always just return nil // for core files, as there are no breakpoints in core files. -func (t *Thread) SetCurrentBreakpoint(adjustPC bool) error { +func (t *thread) SetCurrentBreakpoint(adjustPC bool) error { return nil } // Common returns a struct containing common information // across thread implementations. -func (t *Thread) Common() *proc.CommonThread { +func (t *thread) Common() *proc.CommonThread { return &t.common } // SetPC will always return an error, you cannot // change register values when debugging core files. -func (t *Thread) SetPC(uint64) error { +func (t *thread) SetPC(uint64) error { return ErrChangeRegisterCore } // SetSP will always return an error, you cannot // change register values when debugging core files. -func (t *Thread) SetSP(uint64) error { +func (t *thread) SetSP(uint64) error { return ErrChangeRegisterCore } // SetDX will always return an error, you cannot // change register values when debugging core files. -func (t *Thread) SetDX(uint64) error { +func (t *thread) SetDX(uint64) error { return ErrChangeRegisterCore } // Breakpoints will return all breakpoints for the process. -func (p *Process) Breakpoints() *proc.BreakpointMap { +func (p *process) Breakpoints() *proc.BreakpointMap { return &p.breakpoints } // ClearBreakpoint will always return an error as you cannot set or clear // breakpoints on core files. -func (p *Process) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { +func (p *process) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { return nil, proc.NoBreakpointError{Addr: addr} } // ClearInternalBreakpoints will always return nil and have no // effect since you cannot set breakpoints on core files. -func (p *Process) ClearInternalBreakpoints() error { +func (p *process) ClearInternalBreakpoints() error { return nil } // ContinueOnce will always return an error because you // cannot control execution of a core file. -func (p *Process) ContinueOnce() (proc.Thread, proc.StopReason, error) { +func (p *process) ContinueOnce() (proc.Thread, proc.StopReason, error) { return nil, proc.StopUnknown, ErrContinueCore } // StepInstruction will always return an error // as you cannot control execution of a core file. -func (p *Process) StepInstruction() error { +func (p *process) StepInstruction() error { return ErrContinueCore } // RequestManualStop will return nil and have no effect // as you cannot control execution of a core file. -func (p *Process) RequestManualStop() error { +func (p *process) RequestManualStop() error { return nil } // CheckAndClearManualStopRequest will always return false and // have no effect since there are no manual stop requests as // there is no controlling execution of a core file. -func (p *Process) CheckAndClearManualStopRequest() bool { +func (p *process) CheckAndClearManualStopRequest() bool { return false } // CurrentThread returns the current active thread. -func (p *Process) CurrentThread() proc.Thread { +func (p *process) CurrentThread() proc.Thread { return p.currentThread } // Detach will always return nil and have no // effect as you cannot detach from a core file // and have it continue execution or exit. -func (p *Process) Detach(bool) error { +func (p *process) Detach(bool) error { return nil } // Valid returns whether the process is active. Always returns true // for core files as it cannot exit or be otherwise detached from. -func (p *Process) Valid() (bool, error) { +func (p *process) Valid() (bool, error) { return true, nil } // Pid returns the process ID of this process. -func (p *Process) Pid() int { +func (p *process) Pid() int { return p.pid } // ResumeNotify is a no-op on core files as we cannot // control execution. -func (p *Process) ResumeNotify(chan<- struct{}) { +func (p *process) ResumeNotify(chan<- struct{}) { } // SetBreakpoint will always return an error for core files as you cannot write memory or control execution. -func (p *Process) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error) { +func (p *process) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error) { return nil, ErrWriteCore } // ThreadList will return a list of all threads currently in the process. -func (p *Process) ThreadList() []proc.Thread { +func (p *process) ThreadList() []proc.Thread { r := make([]proc.Thread, 0, len(p.Threads)) for _, v := range p.Threads { r = append(r, v) @@ -445,12 +445,12 @@ func (p *Process) ThreadList() []proc.Thread { } // FindThread will return the thread with the corresponding thread ID. -func (p *Process) FindThread(threadID int) (proc.Thread, bool) { +func (p *process) FindThread(threadID int) (proc.Thread, bool) { t, ok := p.Threads[threadID] return t, ok } // SetCurrentThread is used internally by proc.Target to change the current thread. -func (p *Process) SetCurrentThread(th proc.Thread) { - p.currentThread = th.(*Thread) +func (p *process) SetCurrentThread(th proc.Thread) { + p.currentThread = th.(*thread) } diff --git a/pkg/proc/core/core_test.go b/pkg/proc/core/core_test.go index df4b08d0..7c3a250e 100644 --- a/pkg/proc/core/core_test.go +++ b/pkg/proc/core/core_test.go @@ -134,10 +134,10 @@ func TestSplicedReader(t *testing.T) { } for _, test := range tests { t.Run(test.name, func(t *testing.T) { - mem := &SplicedMemory{} + mem := &splicedMemory{} for _, region := range test.regions { r := bytes.NewReader(region.data) - mem.Add(&OffsetReaderAt{r, 0}, region.off, region.length) + mem.Add(&offsetReaderAt{r, 0}, region.off, region.length) } got := make([]byte, test.readLen) n, err := mem.ReadMemory(got, test.readAddr) diff --git a/pkg/proc/core/linux_core.go b/pkg/proc/core/linux_core.go index 03727246..48099431 100644 --- a/pkg/proc/core/linux_core.go +++ b/pkg/proc/core/linux_core.go @@ -15,68 +15,68 @@ import ( // Copied from golang.org/x/sys/unix.Timeval since it's not available on all // systems. -type LinuxCoreTimeval struct { +type linuxCoreTimeval struct { Sec int64 Usec int64 } // NT_FILE is file mapping information, e.g. program text mappings. Desc is a LinuxNTFile. -const NT_FILE elf.NType = 0x46494c45 // "FILE". +const _NT_FILE elf.NType = 0x46494c45 // "FILE". // NT_X86_XSTATE is other registers, including AVX and such. -const NT_X86_XSTATE elf.NType = 0x202 // Note type for notes containing X86 XSAVE area. +const _NT_X86_XSTATE elf.NType = 0x202 // Note type for notes containing X86 XSAVE area. // NT_AUXV is the note type for notes containing a copy of the Auxv array -const NT_AUXV elf.NType = 0x6 +const _NT_AUXV elf.NType = 0x6 // NT_FPREGSET is the note type for floating point registers. -const NT_FPREGSET elf.NType = 0x2 +const _NT_FPREGSET elf.NType = 0x2 // Fetch architecture using exeELF.Machine from core file // Refer http://man7.org/linux/man-pages/man5/elf.5.html const ( - EM_AARCH64 = 183 - EM_X86_64 = 62 + _EM_AARCH64 = 183 + _EM_X86_64 = 62 _ARM_FP_HEADER_START = 512 ) const elfErrorBadMagicNumber = "bad magic number" -func linuxThreadsFromNotes(p *Process, notes []*Note, machineType elf.Machine) { +func linuxThreadsFromNotes(p *process, notes []*note, machineType elf.Machine) { var lastThreadAMD *linuxAMD64Thread var lastThreadARM *linuxARM64Thread for _, note := range notes { switch note.Type { case elf.NT_PRSTATUS: - if machineType == EM_X86_64 { - t := note.Desc.(*LinuxPrStatusAMD64) + if machineType == _EM_X86_64 { + t := note.Desc.(*linuxPrStatusAMD64) lastThreadAMD = &linuxAMD64Thread{linutil.AMD64Registers{Regs: &t.Reg}, t} - p.Threads[int(t.Pid)] = &Thread{lastThreadAMD, p, proc.CommonThread{}} + p.Threads[int(t.Pid)] = &thread{lastThreadAMD, p, proc.CommonThread{}} if p.currentThread == nil { p.currentThread = p.Threads[int(t.Pid)] } - } else if machineType == EM_AARCH64 { - t := note.Desc.(*LinuxPrStatusARM64) + } else if machineType == _EM_AARCH64 { + t := note.Desc.(*linuxPrStatusARM64) lastThreadARM = &linuxARM64Thread{linutil.ARM64Registers{Regs: &t.Reg}, t} - p.Threads[int(t.Pid)] = &Thread{lastThreadARM, p, proc.CommonThread{}} + p.Threads[int(t.Pid)] = &thread{lastThreadARM, p, proc.CommonThread{}} if p.currentThread == nil { p.currentThread = p.Threads[int(t.Pid)] } } - case NT_FPREGSET: - if machineType == EM_AARCH64 { + case _NT_FPREGSET: + if machineType == _EM_AARCH64 { if lastThreadARM != nil { lastThreadARM.regs.Fpregs = note.Desc.(*linutil.ARM64PtraceFpRegs).Decode() } } - case NT_X86_XSTATE: - if machineType == EM_X86_64 { + case _NT_X86_XSTATE: + if machineType == _EM_X86_64 { if lastThreadAMD != nil { lastThreadAMD.regs.Fpregs = note.Desc.(*linutil.AMD64Xstate).Decode() } } case elf.NT_PRPSINFO: - p.pid = int(note.Desc.(*LinuxPrPsInfo).Pid) + p.pid = int(note.Desc.(*linuxPrPsInfo).Pid) } } } @@ -87,7 +87,7 @@ func linuxThreadsFromNotes(p *Process, notes []*Note, machineType elf.Machine) { // http://uhlo.blogspot.fr/2012/05/brief-look-into-core-dumps.html, // elf_core_dump in http://lxr.free-electrons.com/source/fs/binfmt_elf.c, // and, if absolutely desperate, readelf.c from the binutils source. -func readLinuxCore(corePath, exePath string) (*Process, error) { +func readLinuxCore(corePath, exePath string) (*process, error) { coreFile, err := elf.Open(corePath) if err != nil { if _, isfmterr := err.(*elf.FormatError); isfmterr && (strings.Contains(err.Error(), elfErrorBadMagicNumber) || strings.Contains(err.Error(), " at offset 0x0: too short")) { @@ -122,9 +122,9 @@ func readLinuxCore(corePath, exePath string) (*Process, error) { // TODO support 386 var bi *proc.BinaryInfo switch machineType { - case EM_X86_64: + case _EM_X86_64: bi = proc.NewBinaryInfo("linux", "amd64") - case EM_AARCH64: + case _EM_AARCH64: bi = proc.NewBinaryInfo("linux", "arm64") default: return nil, fmt.Errorf("unsupported machine type") @@ -132,9 +132,9 @@ func readLinuxCore(corePath, exePath string) (*Process, error) { entryPoint := findEntryPoint(notes, bi.Arch.PtrSize()) - p := &Process{ + p := &process{ mem: memory, - Threads: map[int]*Thread{}, + Threads: map[int]*thread{}, entryPoint: entryPoint, bi: bi, breakpoints: proc.NewBreakpointMap(), @@ -146,12 +146,12 @@ func readLinuxCore(corePath, exePath string) (*Process, error) { type linuxAMD64Thread struct { regs linutil.AMD64Registers - t *LinuxPrStatusAMD64 + t *linuxPrStatusAMD64 } type linuxARM64Thread struct { regs linutil.ARM64Registers - t *LinuxPrStatusARM64 + t *linuxPrStatusARM64 } func (t *linuxAMD64Thread) registers(floatingPoint bool) (proc.Registers, error) { @@ -187,14 +187,14 @@ func (t *linuxARM64Thread) pid() int { // - NT_PRSTATUS: Information about a thread, including base registers, state, etc. Desc is a LinuxPrStatus. // - NT_FPREGSET (Not implemented): x87 floating point registers. // - NT_X86_XSTATE: Other registers, including AVX and such. -type Note struct { +type note struct { Type elf.NType Name string Desc interface{} // Decoded Desc from the } // readNotes reads all the notes from the notes prog in core. -func readNotes(core *elf.File, machineType elf.Machine) ([]*Note, error) { +func readNotes(core *elf.File, machineType elf.Machine) ([]*note, error) { var notesProg *elf.Prog for _, prog := range core.Progs { if prog.Type == elf.PT_NOTE { @@ -204,7 +204,7 @@ func readNotes(core *elf.File, machineType elf.Machine) ([]*Note, error) { } r := notesProg.Open() - notes := []*Note{} + notes := []*note{} for { note, err := readNote(r, machineType) if err == io.EOF { @@ -220,11 +220,11 @@ func readNotes(core *elf.File, machineType elf.Machine) ([]*Note, error) { } // readNote reads a single note from r, decoding the descriptor if possible. -func readNote(r io.ReadSeeker, machineType elf.Machine) (*Note, error) { +func readNote(r io.ReadSeeker, machineType elf.Machine) (*note, error) { // Notes are laid out as described in the SysV ABI: // http://www.sco.com/developers/gabi/latest/ch5.pheader.html#note_section - note := &Note{} - hdr := &ELFNotesHdr{} + note := ¬e{} + hdr := &elfNotesHdr{} err := binary.Read(r, binary.LittleEndian, hdr) if err != nil { @@ -247,10 +247,10 @@ func readNote(r io.ReadSeeker, machineType elf.Machine) (*Note, error) { descReader := bytes.NewReader(desc) switch note.Type { case elf.NT_PRSTATUS: - if machineType == EM_X86_64 { - note.Desc = &LinuxPrStatusAMD64{} - } else if machineType == EM_AARCH64 { - note.Desc = &LinuxPrStatusARM64{} + if machineType == _EM_X86_64 { + note.Desc = &linuxPrStatusAMD64{} + } else if machineType == _EM_AARCH64 { + note.Desc = &linuxPrStatusARM64{} } else { return nil, fmt.Errorf("unsupported machine type") } @@ -258,39 +258,39 @@ func readNote(r io.ReadSeeker, machineType elf.Machine) (*Note, error) { return nil, fmt.Errorf("reading NT_PRSTATUS: %v", err) } case elf.NT_PRPSINFO: - note.Desc = &LinuxPrPsInfo{} + note.Desc = &linuxPrPsInfo{} if err := binary.Read(descReader, binary.LittleEndian, note.Desc); err != nil { return nil, fmt.Errorf("reading NT_PRPSINFO: %v", err) } - case NT_FILE: + case _NT_FILE: // No good documentation reference, but the structure is // simply a header, including entry count, followed by that // many entries, and then the file name of each entry, // null-delimited. Not reading the names here. - data := &LinuxNTFile{} - if err := binary.Read(descReader, binary.LittleEndian, &data.LinuxNTFileHdr); err != nil { + data := &linuxNTFile{} + if err := binary.Read(descReader, binary.LittleEndian, &data.linuxNTFileHdr); err != nil { return nil, fmt.Errorf("reading NT_FILE header: %v", err) } for i := 0; i < int(data.Count); i++ { - entry := &LinuxNTFileEntry{} + entry := &linuxNTFileEntry{} if err := binary.Read(descReader, binary.LittleEndian, entry); err != nil { return nil, fmt.Errorf("reading NT_FILE entry %v: %v", i, err) } data.entries = append(data.entries, entry) } note.Desc = data - case NT_X86_XSTATE: - if machineType == EM_X86_64 { + case _NT_X86_XSTATE: + if machineType == _EM_X86_64 { var fpregs linutil.AMD64Xstate if err := linutil.AMD64XstateRead(desc, true, &fpregs); err != nil { return nil, err } note.Desc = &fpregs } - case NT_AUXV: + case _NT_AUXV: note.Desc = desc - case NT_FPREGSET: - if machineType == EM_AARCH64 { + case _NT_FPREGSET: + if machineType == _EM_AARCH64 { fpregs := &linutil.ARM64PtraceFpRegs{} rdr := bytes.NewReader(desc[:_ARM_FP_HEADER_START]) if err := binary.Read(rdr, binary.LittleEndian, fpregs.Byte()); err != nil { @@ -320,15 +320,15 @@ func skipPadding(r io.ReadSeeker, pad int64) error { return nil } -func buildMemory(core, exeELF *elf.File, exe io.ReaderAt, notes []*Note) proc.MemoryReader { - memory := &SplicedMemory{} +func buildMemory(core, exeELF *elf.File, exe io.ReaderAt, notes []*note) proc.MemoryReader { + memory := &splicedMemory{} // For now, assume all file mappings are to the exe. for _, note := range notes { - if note.Type == NT_FILE { - fileNote := note.Desc.(*LinuxNTFile) + if note.Type == _NT_FILE { + fileNote := note.Desc.(*linuxNTFile) for _, entry := range fileNote.entries { - r := &OffsetReaderAt{ + r := &offsetReaderAt{ reader: exe, offset: uintptr(entry.Start - (entry.FileOfs * fileNote.PageSize)), } @@ -346,7 +346,7 @@ func buildMemory(core, exeELF *elf.File, exe io.ReaderAt, notes []*Note) proc.Me if prog.Filesz == 0 { continue } - r := &OffsetReaderAt{ + r := &offsetReaderAt{ reader: prog.ReaderAt, offset: uintptr(prog.Vaddr), } @@ -357,9 +357,9 @@ func buildMemory(core, exeELF *elf.File, exe io.ReaderAt, notes []*Note) proc.Me return memory } -func findEntryPoint(notes []*Note, ptrSize int) uint64 { +func findEntryPoint(notes []*note, ptrSize int) uint64 { for _, note := range notes { - if note.Type == NT_AUXV { + if note.Type == _NT_AUXV { return linutil.EntryPointFromAuxv(note.Desc.([]byte), ptrSize) } } @@ -370,7 +370,7 @@ func findEntryPoint(notes []*Note, ptrSize int) uint64 { // AMD64 specific primarily because of unix.PtraceRegs, but also // because some of the fields are word sized. // See http://lxr.free-electrons.com/source/include/uapi/linux/elfcore.h -type LinuxPrPsInfo struct { +type linuxPrPsInfo struct { State uint8 Sname int8 Zomb uint8 @@ -384,61 +384,61 @@ type LinuxPrPsInfo struct { } // LinuxPrStatusAMD64 is a copy of the prstatus kernel struct. -type LinuxPrStatusAMD64 struct { - Siginfo LinuxSiginfo +type linuxPrStatusAMD64 struct { + Siginfo linuxSiginfo Cursig uint16 _ [2]uint8 Sigpend uint64 Sighold uint64 Pid, Ppid, Pgrp, Sid int32 - Utime, Stime, CUtime, CStime LinuxCoreTimeval + Utime, Stime, CUtime, CStime linuxCoreTimeval Reg linutil.AMD64PtraceRegs Fpvalid int32 } // LinuxPrStatusARM64 is a copy of the prstatus kernel struct. -type LinuxPrStatusARM64 struct { - Siginfo LinuxSiginfo +type linuxPrStatusARM64 struct { + Siginfo linuxSiginfo Cursig uint16 _ [2]uint8 Sigpend uint64 Sighold uint64 Pid, Ppid, Pgrp, Sid int32 - Utime, Stime, CUtime, CStime LinuxCoreTimeval + Utime, Stime, CUtime, CStime linuxCoreTimeval Reg linutil.ARM64PtraceRegs Fpvalid int32 } // LinuxSiginfo is a copy of the // siginfo kernel struct. -type LinuxSiginfo struct { +type linuxSiginfo struct { Signo int32 Code int32 Errno int32 } // LinuxNTFile contains information on mapped files. -type LinuxNTFile struct { - LinuxNTFileHdr - entries []*LinuxNTFileEntry +type linuxNTFile struct { + linuxNTFileHdr + entries []*linuxNTFileEntry } // LinuxNTFileHdr is a header struct for NTFile. -type LinuxNTFileHdr struct { +type linuxNTFileHdr struct { Count uint64 PageSize uint64 } // LinuxNTFileEntry is an entry of an NT_FILE note. -type LinuxNTFileEntry struct { +type linuxNTFileEntry struct { Start uint64 End uint64 FileOfs uint64 } -// ELFNotesHdr is the ELF Notes header. +// elfNotesHdr is the ELF Notes header. // Same size on 64 and 32-bit machines. -type ELFNotesHdr struct { +type elfNotesHdr struct { Namesz uint32 Descsz uint32 Type uint32 diff --git a/pkg/proc/core/windows_amd64_minidump.go b/pkg/proc/core/windows_amd64_minidump.go index 08627c5d..1f94f4f7 100644 --- a/pkg/proc/core/windows_amd64_minidump.go +++ b/pkg/proc/core/windows_amd64_minidump.go @@ -7,7 +7,7 @@ import ( "github.com/go-delve/delve/pkg/proc/winutil" ) -func readAMD64Minidump(minidumpPath, exePath string) (*Process, error) { +func readAMD64Minidump(minidumpPath, exePath string) (*process, error) { var logfn func(string, ...interface{}) if logflags.Minidump() { logfn = logflags.MinidumpLogger().Infof @@ -21,16 +21,16 @@ func readAMD64Minidump(minidumpPath, exePath string) (*Process, error) { return nil, err } - memory := &SplicedMemory{} + memory := &splicedMemory{} for i := range mdmp.MemoryRanges { m := &mdmp.MemoryRanges[i] memory.Add(m, uintptr(m.Addr), uintptr(len(m.Data))) } - p := &Process{ + p := &process{ mem: memory, - Threads: map[int]*Thread{}, + Threads: map[int]*thread{}, bi: proc.NewBinaryInfo("windows", "amd64"), breakpoints: proc.NewBreakpointMap(), pid: int(mdmp.Pid), @@ -38,7 +38,7 @@ func readAMD64Minidump(minidumpPath, exePath string) (*Process, error) { for i := range mdmp.Threads { th := &mdmp.Threads[i] - p.Threads[int(th.ID)] = &Thread{&windowsAMD64Thread{th}, p, proc.CommonThread{}} + p.Threads[int(th.ID)] = &thread{&windowsAMD64Thread{th}, p, proc.CommonThread{}} if p.currentThread == nil { p.currentThread = p.Threads[int(th.ID)] } diff --git a/pkg/proc/gdbserial/gdbserver.go b/pkg/proc/gdbserial/gdbserver.go index d2270ab8..490bc6c2 100644 --- a/pkg/proc/gdbserial/gdbserver.go +++ b/pkg/proc/gdbserial/gdbserver.go @@ -100,12 +100,12 @@ var ErrDirChange = errors.New("direction change with internal breakpoints") // Process implements proc.Process using a connection to a debugger stub // that understands Gdb Remote Serial Protocol. -type Process struct { +type gdbProcess struct { bi *proc.BinaryInfo conn gdbConn - threads map[int]*Thread - currentThread *Thread + threads map[int]*gdbThread + currentThread *gdbThread exited, detached bool ctrlC bool // ctrl-c was sent to stop inferior @@ -126,15 +126,15 @@ type Process struct { onDetach func() // called after a successful detach } -var _ proc.ProcessInternal = &Process{} +var _ proc.ProcessInternal = &gdbProcess{} // Thread represents an operating system thread. -type Thread struct { +type gdbThread struct { ID int strID string regs gdbRegisters CurrentBreakpoint proc.BreakpointState - p *Process + p *gdbProcess sig uint8 // signal received by thread after last stop setbp bool // thread was stopped because of a breakpoint common proc.CommonThread @@ -165,20 +165,20 @@ type gdbRegister struct { regnum int } -// New creates a new Process instance. +// newProcess creates a new Process instance. // If process is not nil it is the stub's process and will be killed after // Detach. // Use Listen, Dial or Connect to complete connection. -func New(process *os.Process) *Process { +func newProcess(process *os.Process) *gdbProcess { logger := logflags.GdbWireLogger() - p := &Process{ + p := &gdbProcess{ conn: gdbConn{ maxTransmitAttempts: maxTransmitAttempts, inbuf: make([]byte, 0, initialInputBufferSize), direction: proc.Forward, log: logger, }, - threads: make(map[int]*Thread), + threads: make(map[int]*gdbThread), bi: proc.NewBinaryInfo(runtime.GOOS, runtime.GOARCH), breakpoints: proc.NewBreakpointMap(), gcmdok: true, @@ -198,7 +198,7 @@ func New(process *os.Process) *Process { } // Listen waits for a connection from the stub. -func (p *Process) Listen(listener net.Listener, path string, pid int, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { +func (p *gdbProcess) Listen(listener net.Listener, path string, pid int, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { acceptChan := make(chan net.Conn) go func() { @@ -220,7 +220,7 @@ func (p *Process) Listen(listener net.Listener, path string, pid int, debugInfoD } // Dial attempts to connect to the stub. -func (p *Process) Dial(addr string, path string, pid int, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { +func (p *gdbProcess) Dial(addr string, path string, pid int, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { for { conn, err := net.Dial("tcp", addr) if err == nil { @@ -241,7 +241,7 @@ func (p *Process) Dial(addr string, path string, pid int, debugInfoDirs []string // program and the PID of the target process, both are optional, however // some stubs do not provide ways to determine path and pid automatically // and Connect will be unable to function without knowing them. -func (p *Process) Connect(conn net.Conn, path string, pid int, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { +func (p *gdbProcess) Connect(conn net.Conn, path string, pid int, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { p.conn.conn = conn p.conn.pid = pid err := p.conn.handshake() @@ -400,7 +400,7 @@ func LLDBLaunch(cmd []string, wd string, foreground bool, debugInfoDirs []string return nil, err } - p := New(process.Process) + p := newProcess(process.Process) p.conn.isDebugserver = isDebugserver var tgt *proc.Target @@ -450,7 +450,7 @@ func LLDBAttach(pid int, path string, debugInfoDirs []string) (*proc.Target, err return nil, err } - p := New(process.Process) + p := newProcess(process.Process) p.conn.isDebugserver = isDebugserver var tgt *proc.Target @@ -464,7 +464,7 @@ func LLDBAttach(pid int, path string, debugInfoDirs []string) (*proc.Target, err // EntryPoint will return the process entry point address, useful for // debugging PIEs. -func (p *Process) EntryPoint() (uint64, error) { +func (p *gdbProcess) EntryPoint() (uint64, error) { var entryPoint uint64 if auxv, err := p.conn.readAuxv(); err == nil { // If we can't read the auxiliary vector it just means it's not supported @@ -478,7 +478,7 @@ func (p *Process) EntryPoint() (uint64, error) { // initialize uses qProcessInfo to load the inferior's PID and // executable path. This command is not supported by all stubs and not all // stubs will report both the PID and executable path. -func (p *Process) initialize(path string, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { +func (p *gdbProcess) initialize(path string, debugInfoDirs []string, stopReason proc.StopReason) (*proc.Target, error) { var err error if path == "" { // If we are attaching to a running process and the user didn't specify @@ -542,7 +542,7 @@ func (p *Process) initialize(path string, debugInfoDirs []string, stopReason pro return tgt, nil } -func queryProcessInfo(p *Process, pid int) (int, string, error) { +func queryProcessInfo(p *gdbProcess, pid int) (int, string, error) { pi, err := p.conn.queryProcessInfo(pid) if err != nil { return 0, "", err @@ -555,24 +555,24 @@ func queryProcessInfo(p *Process, pid int) (int, string, error) { } // BinInfo returns information on the binary. -func (p *Process) BinInfo() *proc.BinaryInfo { +func (p *gdbProcess) BinInfo() *proc.BinaryInfo { return p.bi } // Recorded returns whether or not we are debugging // a recorded "traced" program. -func (p *Process) Recorded() (bool, string) { +func (p *gdbProcess) Recorded() (bool, string) { return p.tracedir != "", p.tracedir } // Pid returns the process ID. -func (p *Process) Pid() int { +func (p *gdbProcess) Pid() int { return int(p.conn.pid) } // Valid returns true if we are not detached // and the process has not exited. -func (p *Process) Valid() (bool, error) { +func (p *gdbProcess) Valid() (bool, error) { if p.detached { return false, proc.ErrProcessDetached } @@ -584,18 +584,18 @@ func (p *Process) Valid() (bool, error) { // ResumeNotify specifies a channel that will be closed the next time // ContinueOnce finishes resuming the target. -func (p *Process) ResumeNotify(ch chan<- struct{}) { +func (p *gdbProcess) ResumeNotify(ch chan<- struct{}) { p.conn.resumeChan = ch } // FindThread returns the thread with the given ID. -func (p *Process) FindThread(threadID int) (proc.Thread, bool) { +func (p *gdbProcess) FindThread(threadID int) (proc.Thread, bool) { thread, ok := p.threads[threadID] return thread, ok } // ThreadList returns all threads in the process. -func (p *Process) ThreadList() []proc.Thread { +func (p *gdbProcess) ThreadList() []proc.Thread { r := make([]proc.Thread, 0, len(p.threads)) for _, thread := range p.threads { r = append(r, thread) @@ -605,13 +605,13 @@ func (p *Process) ThreadList() []proc.Thread { // CurrentThread returns the current active // selected thread. -func (p *Process) CurrentThread() proc.Thread { +func (p *gdbProcess) CurrentThread() proc.Thread { return p.currentThread } // SetCurrentThread is used internally by proc.Target to change the current thread. -func (p *Process) SetCurrentThread(th proc.Thread) { - p.currentThread = th.(*Thread) +func (p *gdbProcess) SetCurrentThread(th proc.Thread) { + p.currentThread = th.(*gdbThread) } const ( @@ -631,7 +631,7 @@ const ( // ContinueOnce will continue execution of the process until // a breakpoint is hit or signal is received. -func (p *Process) ContinueOnce() (proc.Thread, proc.StopReason, error) { +func (p *gdbProcess) ContinueOnce() (proc.Thread, proc.StopReason, error) { if p.exited { return nil, proc.StopExited, &proc.ErrProcessExited{Pid: p.conn.pid} } @@ -655,7 +655,7 @@ func (p *Process) ContinueOnce() (proc.Thread, proc.StopReason, error) { // resume all threads var threadID string - var trapthread *Thread + var trapthread *gdbThread var tu = threadUpdater{p: p} var atstart bool continueLoop: @@ -732,7 +732,7 @@ continueLoop: return trapthread, stopReason, err } -func (p *Process) findThreadByStrID(threadID string) *Thread { +func (p *gdbProcess) findThreadByStrID(threadID string) *gdbThread { for _, thread := range p.threads { if thread.strID == threadID { return thread @@ -746,8 +746,8 @@ func (p *Process) findThreadByStrID(threadID string) *Thread { // and returns true if we should stop execution in response to one of the // signals and return control to the user. // Adjusts trapthread to a thread that we actually want to stop at. -func (p *Process) handleThreadSignals(trapthread *Thread) (trapthreadOut *Thread, atstart bool, shouldStop bool) { - var trapthreadCandidate *Thread +func (p *gdbProcess) handleThreadSignals(trapthread *gdbThread) (trapthreadOut *gdbThread, atstart bool, shouldStop bool) { + var trapthreadCandidate *gdbThread for _, th := range p.threads { isStopSignal := false @@ -820,7 +820,7 @@ func (p *Process) handleThreadSignals(trapthread *Thread) (trapthreadOut *Thread // RequestManualStop will attempt to stop the process // without a breakpoint or signal having been recieved. -func (p *Process) RequestManualStop() error { +func (p *gdbProcess) RequestManualStop() error { p.conn.manualStopMutex.Lock() p.manualStopRequested = true if !p.conn.running { @@ -834,7 +834,7 @@ func (p *Process) RequestManualStop() error { // CheckAndClearManualStopRequest will check for a manual // stop and then clear that state. -func (p *Process) CheckAndClearManualStopRequest() bool { +func (p *gdbProcess) CheckAndClearManualStopRequest() bool { p.conn.manualStopMutex.Lock() msr := p.manualStopRequested p.manualStopRequested = false @@ -842,20 +842,20 @@ func (p *Process) CheckAndClearManualStopRequest() bool { return msr } -func (p *Process) getManualStopRequested() bool { +func (p *gdbProcess) getManualStopRequested() bool { p.conn.manualStopMutex.Lock() msr := p.manualStopRequested p.conn.manualStopMutex.Unlock() return msr } -func (p *Process) setCtrlC(v bool) { +func (p *gdbProcess) setCtrlC(v bool) { p.conn.manualStopMutex.Lock() p.ctrlC = v p.conn.manualStopMutex.Unlock() } -func (p *Process) getCtrlC() bool { +func (p *gdbProcess) getCtrlC() bool { p.conn.manualStopMutex.Lock() defer p.conn.manualStopMutex.Unlock() return p.ctrlC @@ -863,7 +863,7 @@ func (p *Process) getCtrlC() bool { // Detach will detach from the target process, // if 'kill' is true it will also kill the process. -func (p *Process) Detach(kill bool) error { +func (p *gdbProcess) Detach(kill bool) error { if kill && !p.exited { err := p.conn.kill() if err != nil { @@ -891,7 +891,7 @@ func (p *Process) Detach(kill bool) error { } // Restart will restart the process from the given position. -func (p *Process) Restart(pos string) error { +func (p *gdbProcess) Restart(pos string) error { if p.tracedir == "" { return proc.ErrNotRecorded } @@ -932,7 +932,7 @@ func (p *Process) Restart(pos string) error { // When executes the 'when' command for the Mozilla RR backend. // This command will return rr's internal event number. -func (p *Process) When() (string, error) { +func (p *gdbProcess) When() (string, error) { if p.tracedir == "" { return "", proc.ErrNotRecorded } @@ -948,7 +948,7 @@ const ( ) // Checkpoint creates a checkpoint from which you can restart the program. -func (p *Process) Checkpoint(where string) (int, error) { +func (p *gdbProcess) Checkpoint(where string) (int, error) { if p.tracedir == "" { return -1, proc.ErrNotRecorded } @@ -976,7 +976,7 @@ func (p *Process) Checkpoint(where string) (int, error) { } // Checkpoints returns a list of all checkpoints set. -func (p *Process) Checkpoints() ([]proc.Checkpoint, error) { +func (p *gdbProcess) Checkpoints() ([]proc.Checkpoint, error) { if p.tracedir == "" { return nil, proc.ErrNotRecorded } @@ -1006,7 +1006,7 @@ func (p *Process) Checkpoints() ([]proc.Checkpoint, error) { const deleteCheckpointPrefix = "Deleted checkpoint " // ClearCheckpoint clears the checkpoint for the given ID. -func (p *Process) ClearCheckpoint(id int) error { +func (p *gdbProcess) ClearCheckpoint(id int) error { if p.tracedir == "" { return proc.ErrNotRecorded } @@ -1021,7 +1021,7 @@ func (p *Process) ClearCheckpoint(id int) error { } // ChangeDirection sets whether to run the program forwards or in reverse execution. -func (p *Process) ChangeDirection(dir proc.Direction) error { +func (p *gdbProcess) ChangeDirection(dir proc.Direction) error { if p.tracedir == "" { if dir != proc.Forward { return proc.ErrNotRecorded @@ -1042,17 +1042,17 @@ func (p *Process) ChangeDirection(dir proc.Direction) error { } // GetDirection returns the current direction of execution. -func (p *Process) GetDirection() proc.Direction { +func (p *gdbProcess) GetDirection() proc.Direction { return p.conn.direction } // Breakpoints returns the list of breakpoints currently set. -func (p *Process) Breakpoints() *proc.BreakpointMap { +func (p *gdbProcess) Breakpoints() *proc.BreakpointMap { return &p.breakpoints } // FindBreakpoint returns the breakpoint at the given address. -func (p *Process) FindBreakpoint(pc uint64) (*proc.Breakpoint, bool) { +func (p *gdbProcess) FindBreakpoint(pc uint64) (*proc.Breakpoint, bool) { // Directly use addr to lookup breakpoint. if bp, ok := p.breakpoints.M[pc]; ok { return bp, true @@ -1060,7 +1060,7 @@ func (p *Process) FindBreakpoint(pc uint64) (*proc.Breakpoint, bool) { return nil, false } -func (p *Process) writeBreakpoint(addr uint64) (string, int, *proc.Function, []byte, error) { +func (p *gdbProcess) writeBreakpoint(addr uint64) (string, int, *proc.Function, []byte, error) { f, l, fn := p.bi.PCToLine(uint64(addr)) if err := p.conn.setBreakpoint(addr); err != nil { @@ -1071,7 +1071,7 @@ func (p *Process) writeBreakpoint(addr uint64) (string, int, *proc.Function, []b } // SetBreakpoint creates a new breakpoint. -func (p *Process) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error) { +func (p *gdbProcess) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error) { if p.exited { return nil, &proc.ErrProcessExited{Pid: p.conn.pid} } @@ -1079,7 +1079,7 @@ func (p *Process) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast. } // ClearBreakpoint clears a breakpoint at the given address. -func (p *Process) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { +func (p *gdbProcess) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { if p.exited { return nil, &proc.ErrProcessExited{Pid: p.conn.pid} } @@ -1089,7 +1089,7 @@ func (p *Process) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { } // ClearInternalBreakpoints clear all internal use breakpoints like those set by 'next'. -func (p *Process) ClearInternalBreakpoints() error { +func (p *gdbProcess) ClearInternalBreakpoints() error { return p.breakpoints.ClearInternalBreakpoints(func(bp *proc.Breakpoint) error { if err := p.conn.clearBreakpoint(bp.Addr); err != nil { return err @@ -1104,7 +1104,7 @@ func (p *Process) ClearInternalBreakpoints() error { } type threadUpdater struct { - p *Process + p *gdbProcess seen map[int]bool done bool } @@ -1133,7 +1133,7 @@ func (tu *threadUpdater) Add(threads []string) error { tid := int(n) tu.seen[tid] = true if _, found := tu.p.threads[tid]; !found { - tu.p.threads[tid] = &Thread{ID: tid, strID: threadID, p: tu.p} + tu.p.threads[tid] = &gdbThread{ID: tid, strID: threadID, p: tu.p} } } return nil @@ -1170,7 +1170,7 @@ func (tu *threadUpdater) Finish() { // Some stubs will return the list of running threads in the stop packet, if // this happens the threadUpdater will know that we have already updated the // thread list and the first step of updateThreadList will be skipped. -func (p *Process) updateThreadList(tu *threadUpdater) error { +func (p *gdbProcess) updateThreadList(tu *threadUpdater) error { if !tu.done { first := true for { @@ -1211,19 +1211,19 @@ func (p *Process) updateThreadList(tu *threadUpdater) error { } // clearThreadRegisters clears the memoized thread register state. -func (p *Process) clearThreadRegisters() { +func (p *gdbProcess) clearThreadRegisters() { for _, thread := range p.threads { thread.regs.regs = nil } } -func (p *Process) clearThreadSignals() { +func (p *gdbProcess) clearThreadSignals() { for _, th := range p.threads { th.sig = 0 } } -func (p *Process) setCurrentBreakpoints() error { +func (p *gdbProcess) setCurrentBreakpoints() error { if p.threadStopInfo { for _, th := range p.threads { if th.setbp { @@ -1248,7 +1248,7 @@ func (p *Process) setCurrentBreakpoints() error { } // ReadMemory will read into 'data' memory at the address provided. -func (t *Thread) ReadMemory(data []byte, addr uintptr) (n int, err error) { +func (t *gdbThread) ReadMemory(data []byte, addr uintptr) (n int, err error) { err = t.p.conn.readMemory(data, addr) if err != nil { return 0, err @@ -1257,12 +1257,12 @@ func (t *Thread) ReadMemory(data []byte, addr uintptr) (n int, err error) { } // WriteMemory will write into the memory at 'addr' the data provided. -func (t *Thread) WriteMemory(addr uintptr, data []byte) (written int, err error) { +func (t *gdbThread) WriteMemory(addr uintptr, data []byte) (written int, err error) { return t.p.conn.writeMemory(addr, data) } // Location returns the current location of this thread. -func (t *Thread) Location() (*proc.Location, error) { +func (t *gdbThread) Location() (*proc.Location, error) { regs, err := t.Registers(false) if err != nil { return nil, err @@ -1278,17 +1278,17 @@ func (t *Thread) Location() (*proc.Location, error) { } // Breakpoint returns the current active breakpoint for this thread. -func (t *Thread) Breakpoint() *proc.BreakpointState { +func (t *gdbThread) Breakpoint() *proc.BreakpointState { return &t.CurrentBreakpoint } // ThreadID returns this threads ID. -func (t *Thread) ThreadID() int { +func (t *gdbThread) ThreadID() int { return t.ID } // Registers returns the CPU registers for this thread. -func (t *Thread) Registers(floatingPoint bool) (proc.Registers, error) { +func (t *gdbThread) Registers(floatingPoint bool) (proc.Registers, error) { if t.regs.regs == nil { if err := t.reloadRegisters(); err != nil { return nil, err @@ -1298,22 +1298,22 @@ func (t *Thread) Registers(floatingPoint bool) (proc.Registers, error) { } // RestoreRegisters will set the CPU registers the value of those provided. -func (t *Thread) RestoreRegisters(savedRegs proc.Registers) error { +func (t *gdbThread) RestoreRegisters(savedRegs proc.Registers) error { copy(t.regs.buf, savedRegs.(*gdbRegisters).buf) return t.writeRegisters() } // BinInfo will return information on the binary being debugged. -func (t *Thread) BinInfo() *proc.BinaryInfo { +func (t *gdbThread) BinInfo() *proc.BinaryInfo { return t.p.bi } // Common returns common information across Process implementations. -func (t *Thread) Common() *proc.CommonThread { +func (t *gdbThread) Common() *proc.CommonThread { return &t.common } -func (t *Thread) stepInstruction(tu *threadUpdater) error { +func (t *gdbThread) stepInstruction(tu *threadUpdater) error { pc := t.regs.PC() if _, atbp := t.p.breakpoints.M[pc]; atbp { err := t.p.conn.clearBreakpoint(pc) @@ -1329,12 +1329,12 @@ func (t *Thread) stepInstruction(tu *threadUpdater) error { } // StepInstruction will step exactly 1 CPU instruction. -func (t *Thread) StepInstruction() error { +func (t *gdbThread) StepInstruction() error { return t.stepInstruction(&threadUpdater{p: t.p}) } // Blocked returns true if the thread is blocked in runtime or kernel code. -func (t *Thread) Blocked() bool { +func (t *gdbThread) Blocked() bool { regs, err := t.Registers(false) if err != nil { return false @@ -1362,7 +1362,7 @@ func (t *Thread) Blocked() bool { // loadGInstr returns the correct MOV instruction for the current // OS/architecture that can be executed to load the address of G from an // inferior's thread. -func (p *Process) loadGInstr() []byte { +func (p *gdbProcess) loadGInstr() []byte { var op []byte switch p.bi.GOOS { case "windows", "darwin", "freebsd": @@ -1400,7 +1400,7 @@ func (regs *gdbRegisters) init(regsInfo []gdbRegisterInfo) { // It will also load the address of the thread's G. // Loading the address of G can be done in one of two ways reloadGAlloc, if // the stub can allocate memory, or reloadGAtPC, if the stub can't. -func (t *Thread) reloadRegisters() error { +func (t *gdbThread) reloadRegisters() error { if t.regs.regs == nil { t.regs.init(t.p.conn.regsInfo) } @@ -1438,7 +1438,7 @@ func (t *Thread) reloadRegisters() error { return t.reloadGAtPC() } -func (t *Thread) writeSomeRegisters(regNames ...string) error { +func (t *gdbThread) writeSomeRegisters(regNames ...string) error { if t.p.gcmdok { return t.p.conn.writeRegisters(t.strID, t.regs.buf) } @@ -1450,7 +1450,7 @@ func (t *Thread) writeSomeRegisters(regNames ...string) error { return nil } -func (t *Thread) writeRegisters() error { +func (t *gdbThread) writeRegisters() error { if t.p.gcmdok { return t.p.conn.writeRegisters(t.strID, t.regs.buf) } @@ -1462,7 +1462,7 @@ func (t *Thread) writeRegisters() error { return nil } -func (t *Thread) readSomeRegisters(regNames ...string) error { +func (t *gdbThread) readSomeRegisters(regNames ...string) error { if t.p.gcmdok { return t.p.conn.readRegisters(t.strID, t.regs.buf) } @@ -1478,7 +1478,7 @@ func (t *Thread) readSomeRegisters(regNames ...string) error { // reloadGAtPC overwrites the instruction that the thread is stopped at with // the MOV instruction used to load current G, executes this single // instruction and then puts everything back the way it was. -func (t *Thread) reloadGAtPC() error { +func (t *gdbThread) reloadGAtPC() error { movinstr := t.p.loadGInstr() if t.Blocked() { @@ -1558,7 +1558,7 @@ func (t *Thread) reloadGAtPC() error { // t.p.loadGInstrAddr must point to valid memory on the inferior, containing // a MOV instruction that loads the address of the current G in the RCX // register. -func (t *Thread) reloadGAlloc() error { +func (t *gdbThread) reloadGAlloc() error { if t.Blocked() { t.regs.tls = 0 t.regs.gaddr = 0 @@ -1606,13 +1606,13 @@ func (t *Thread) reloadGAlloc() error { return err } -func (t *Thread) clearBreakpointState() { +func (t *gdbThread) clearBreakpointState() { t.setbp = false t.CurrentBreakpoint.Clear() } // SetCurrentBreakpoint will find and set the threads current breakpoint. -func (t *Thread) SetCurrentBreakpoint(adjustPC bool) error { +func (t *gdbThread) SetCurrentBreakpoint(adjustPC bool) error { // adjustPC is ignored, it is the stub's responsibiility to set the PC // address correctly after hitting a breakpoint. t.clearBreakpointState() @@ -1843,7 +1843,7 @@ func (regs *gdbRegisters) Get(n int) (uint64, error) { } // SetPC will set the value of the PC register to the given value. -func (t *Thread) SetPC(pc uint64) error { +func (t *gdbThread) SetPC(pc uint64) error { t.regs.setPC(pc) if t.p.gcmdok { return t.p.conn.writeRegisters(t.strID, t.regs.buf) @@ -1853,7 +1853,7 @@ func (t *Thread) SetPC(pc uint64) error { } // SetSP will set the value of the SP register to the given value. -func (t *Thread) SetSP(sp uint64) error { +func (t *gdbThread) SetSP(sp uint64) error { t.regs.setSP(sp) if t.p.gcmdok { return t.p.conn.writeRegisters(t.strID, t.regs.buf) @@ -1863,7 +1863,7 @@ func (t *Thread) SetSP(sp uint64) error { } // SetDX will set the value of the DX register to the given value. -func (t *Thread) SetDX(dx uint64) error { +func (t *gdbThread) SetDX(dx uint64) error { t.regs.setDX(dx) if t.p.gcmdok { return t.p.conn.writeRegisters(t.strID, t.regs.buf) diff --git a/pkg/proc/gdbserial/gdbserver_conn.go b/pkg/proc/gdbserial/gdbserver_conn.go index 7928be9f..1186893d 100644 --- a/pkg/proc/gdbserial/gdbserver_conn.go +++ b/pkg/proc/gdbserial/gdbserver_conn.go @@ -545,7 +545,7 @@ func (conn *gdbConn) writeRegister(threadID string, regnum int, data []byte) err // resume each thread. If a thread has sig == 0 the 'c' action will be used, // otherwise the 'C' action will be used and the value of sig will be passed // to it. -func (conn *gdbConn) resume(threads map[int]*Thread, tu *threadUpdater) (string, uint8, error) { +func (conn *gdbConn) resume(threads map[int]*gdbThread, tu *threadUpdater) (string, uint8, error) { if conn.direction == proc.Forward { conn.outbuf.Reset() fmt.Fprintf(&conn.outbuf, "$vCont") diff --git a/pkg/proc/gdbserial/rr.go b/pkg/proc/gdbserial/rr.go index 0140fe67..7b6198f2 100644 --- a/pkg/proc/gdbserial/rr.go +++ b/pkg/proc/gdbserial/rr.go @@ -104,7 +104,7 @@ func Replay(tracedir string, quiet, deleteOnDetach bool, debugInfoDirs []string) return nil, init.err } - p := New(rrcmd.Process) + p := newProcess(rrcmd.Process) p.tracedir = tracedir if deleteOnDetach { p.onDetach = func() { diff --git a/pkg/proc/native/nonative_darwin.go b/pkg/proc/native/nonative_darwin.go index a8f1a7a8..2f006f3b 100644 --- a/pkg/proc/native/nonative_darwin.go +++ b/pkg/proc/native/nonative_darwin.go @@ -21,15 +21,15 @@ func Attach(pid int, _ []string) (*proc.Target, error) { return nil, ErrNativeBackendDisabled } -// WaitStatus is a synonym for the platform-specific WaitStatus -type WaitStatus struct{} +// waitStatus is a synonym for the platform-specific WaitStatus +type waitStatus struct{} -// OSSpecificDetails holds information specific to the OSX/Darwin +// osSpecificDetails holds information specific to the OSX/Darwin // operating system / kernel. -type OSSpecificDetails struct{} +type osSpecificDetails struct{} -// OSProcessDetails holds Darwin specific information. -type OSProcessDetails struct{} +// osProcessDetails holds Darwin specific information. +type osProcessDetails struct{} func findExecutable(path string, pid int) string { panic(ErrNativeBackendDisabled) @@ -39,94 +39,94 @@ func killProcess(pid int) error { panic(ErrNativeBackendDisabled) } -func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { +func registers(thread *nativeThread, floatingPoint bool) (proc.Registers, error) { panic(ErrNativeBackendDisabled) } -func (dbp *Process) loadProcessInformation(wg *sync.WaitGroup) { +func (dbp *nativeProcess) loadProcessInformation(wg *sync.WaitGroup) { panic(ErrNativeBackendDisabled) } -func (dbp *Process) requestManualStop() (err error) { +func (dbp *nativeProcess) requestManualStop() (err error) { panic(ErrNativeBackendDisabled) } -func (dbp *Process) resume() error { +func (dbp *nativeProcess) resume() error { panic(ErrNativeBackendDisabled) } -func (dbp *Process) trapWait(pid int) (*Thread, error) { +func (dbp *nativeProcess) trapWait(pid int) (*nativeThread, error) { panic(ErrNativeBackendDisabled) } -func (dbp *Process) stop(trapthread *Thread) (err error) { +func (dbp *nativeProcess) stop(trapthread *nativeThread) (err error) { panic(ErrNativeBackendDisabled) } -func (dbp *Process) updateThreadList() error { +func (dbp *nativeProcess) updateThreadList() error { panic(ErrNativeBackendDisabled) } -func (dbp *Process) kill() (err error) { +func (dbp *nativeProcess) kill() (err error) { panic(ErrNativeBackendDisabled) } -func (dbp *Process) detach(kill bool) error { +func (dbp *nativeProcess) detach(kill bool) error { panic(ErrNativeBackendDisabled) } // EntryPoint returns the entry point for the process, // useful for PIEs. -func (dbp *Process) EntryPoint() (uint64, error) { +func (dbp *nativeProcess) EntryPoint() (uint64, error) { panic(ErrNativeBackendDisabled) } // Blocked returns true if the thread is blocked -func (t *Thread) Blocked() bool { +func (t *nativeThread) Blocked() bool { panic(ErrNativeBackendDisabled) } // SetPC sets the value of the PC register. -func (t *Thread) SetPC(pc uint64) error { +func (t *nativeThread) SetPC(pc uint64) error { panic(ErrNativeBackendDisabled) } // SetSP sets the value of the SP register. -func (t *Thread) SetSP(sp uint64) error { +func (t *nativeThread) SetSP(sp uint64) error { panic(ErrNativeBackendDisabled) } // SetDX sets the value of the DX register. -func (t *Thread) SetDX(dx uint64) error { +func (t *nativeThread) SetDX(dx uint64) error { panic(ErrNativeBackendDisabled) } // ReadMemory reads len(buf) bytes at addr into buf. -func (t *Thread) ReadMemory(buf []byte, addr uintptr) (int, error) { +func (t *nativeThread) ReadMemory(buf []byte, addr uintptr) (int, error) { panic(ErrNativeBackendDisabled) } // WriteMemory writes the contents of data at addr. -func (t *Thread) WriteMemory(addr uintptr, data []byte) (int, error) { +func (t *nativeThread) WriteMemory(addr uintptr, data []byte) (int, error) { panic(ErrNativeBackendDisabled) } -func (t *Thread) resume() error { +func (t *nativeThread) resume() error { panic(ErrNativeBackendDisabled) } -func (t *Thread) singleStep() error { +func (t *nativeThread) singleStep() error { panic(ErrNativeBackendDisabled) } -func (t *Thread) restoreRegisters(sr proc.Registers) error { +func (t *nativeThread) restoreRegisters(sr proc.Registers) error { panic(ErrNativeBackendDisabled) } // Stopped returns whether the thread is stopped at // the operating system level. -func (t *Thread) Stopped() bool { +func (t *nativeThread) Stopped() bool { panic(ErrNativeBackendDisabled) } -func initialize(dbp *Process) error { return nil } +func initialize(dbp *nativeProcess) error { return nil } diff --git a/pkg/proc/native/proc.go b/pkg/proc/native/proc.go index 22823a90..1fe3454a 100644 --- a/pkg/proc/native/proc.go +++ b/pkg/proc/native/proc.go @@ -10,7 +10,7 @@ import ( // Process represents all of the information the debugger // is holding onto regarding the process we are debugging. -type Process struct { +type nativeProcess struct { bi *proc.BinaryInfo pid int // Process Pid @@ -20,12 +20,12 @@ type Process struct { breakpoints proc.BreakpointMap // List of threads mapped as such: pid -> *Thread - threads map[int]*Thread + threads map[int]*nativeThread // Active thread - currentThread *Thread + currentThread *nativeThread - os *OSProcessDetails + os *osProcessDetails firstStart bool stopMu sync.Mutex resumeChan chan<- struct{} @@ -37,19 +37,19 @@ type Process struct { exited, detached bool } -var _ proc.ProcessInternal = &Process{} +var _ proc.ProcessInternal = &nativeProcess{} -// New returns an initialized Process struct. Before returning, +// newProcess returns an initialized Process struct. Before returning, // it will also launch a goroutine in order to handle ptrace(2) // functions. For more information, see the documentation on // `handlePtraceFuncs`. -func New(pid int) *Process { - dbp := &Process{ +func newProcess(pid int) *nativeProcess { + dbp := &nativeProcess{ pid: pid, - threads: make(map[int]*Thread), + threads: make(map[int]*nativeThread), breakpoints: proc.NewBreakpointMap(), firstStart: true, - os: new(OSProcessDetails), + os: new(osProcessDetails), ptraceChan: make(chan func()), ptraceDoneChan: make(chan interface{}), bi: proc.NewBinaryInfo(runtime.GOOS, runtime.GOARCH), @@ -59,20 +59,20 @@ func New(pid int) *Process { } // BinInfo will return the binary info struct associated with this process. -func (dbp *Process) BinInfo() *proc.BinaryInfo { +func (dbp *nativeProcess) BinInfo() *proc.BinaryInfo { return dbp.bi } // Recorded always returns false for the native proc backend. -func (dbp *Process) Recorded() (bool, string) { return false, "" } +func (dbp *nativeProcess) Recorded() (bool, string) { return false, "" } // Restart will always return an error in the native proc backend, only for // recorded traces. -func (dbp *Process) Restart(string) error { return proc.ErrNotRecorded } +func (dbp *nativeProcess) Restart(string) error { return proc.ErrNotRecorded } // ChangeDirection will always return an error in the native proc backend, only for // recorded traces. -func (dbp *Process) ChangeDirection(dir proc.Direction) error { +func (dbp *nativeProcess) ChangeDirection(dir proc.Direction) error { if dir != proc.Forward { return proc.ErrNotRecorded } @@ -80,25 +80,25 @@ func (dbp *Process) ChangeDirection(dir proc.Direction) error { } // GetDirection will always return Forward. -func (p *Process) GetDirection() proc.Direction { return proc.Forward } +func (p *nativeProcess) GetDirection() proc.Direction { return proc.Forward } // When will always return an empty string and nil, not supported on native proc backend. -func (dbp *Process) When() (string, error) { return "", nil } +func (dbp *nativeProcess) When() (string, error) { return "", nil } // Checkpoint will always return an error on the native proc backend, // only supported for recorded traces. -func (dbp *Process) Checkpoint(string) (int, error) { return -1, proc.ErrNotRecorded } +func (dbp *nativeProcess) Checkpoint(string) (int, error) { return -1, proc.ErrNotRecorded } // Checkpoints will always return an error on the native proc backend, // only supported for recorded traces. -func (dbp *Process) Checkpoints() ([]proc.Checkpoint, error) { return nil, proc.ErrNotRecorded } +func (dbp *nativeProcess) Checkpoints() ([]proc.Checkpoint, error) { return nil, proc.ErrNotRecorded } // ClearCheckpoint will always return an error on the native proc backend, // only supported in recorded traces. -func (dbp *Process) ClearCheckpoint(int) error { return proc.ErrNotRecorded } +func (dbp *nativeProcess) ClearCheckpoint(int) error { return proc.ErrNotRecorded } // Detach from the process being debugged, optionally killing it. -func (dbp *Process) Detach(kill bool) (err error) { +func (dbp *nativeProcess) Detach(kill bool) (err error) { if dbp.exited { return nil } @@ -135,7 +135,7 @@ func (dbp *Process) Detach(kill bool) (err error) { // Valid returns whether the process is still attached to and // has not exited. -func (dbp *Process) Valid() (bool, error) { +func (dbp *nativeProcess) Valid() (bool, error) { if dbp.detached { return false, proc.ErrProcessDetached } @@ -147,17 +147,17 @@ func (dbp *Process) Valid() (bool, error) { // ResumeNotify specifies a channel that will be closed the next time // ContinueOnce finishes resuming the target. -func (dbp *Process) ResumeNotify(ch chan<- struct{}) { +func (dbp *nativeProcess) ResumeNotify(ch chan<- struct{}) { dbp.resumeChan = ch } // Pid returns the process ID. -func (dbp *Process) Pid() int { +func (dbp *nativeProcess) Pid() int { return dbp.pid } // ThreadList returns a list of threads in the process. -func (dbp *Process) ThreadList() []proc.Thread { +func (dbp *nativeProcess) ThreadList() []proc.Thread { r := make([]proc.Thread, 0, len(dbp.threads)) for _, v := range dbp.threads { r = append(r, v) @@ -166,29 +166,29 @@ func (dbp *Process) ThreadList() []proc.Thread { } // FindThread attempts to find the thread with the specified ID. -func (dbp *Process) FindThread(threadID int) (proc.Thread, bool) { +func (dbp *nativeProcess) FindThread(threadID int) (proc.Thread, bool) { th, ok := dbp.threads[threadID] return th, ok } // CurrentThread returns the current selected, active thread. -func (dbp *Process) CurrentThread() proc.Thread { +func (dbp *nativeProcess) CurrentThread() proc.Thread { return dbp.currentThread } // SetCurrentThread is used internally by proc.Target to change the current thread. -func (p *Process) SetCurrentThread(th proc.Thread) { - p.currentThread = th.(*Thread) +func (p *nativeProcess) SetCurrentThread(th proc.Thread) { + p.currentThread = th.(*nativeThread) } // Breakpoints returns a list of breakpoints currently set. -func (dbp *Process) Breakpoints() *proc.BreakpointMap { +func (dbp *nativeProcess) Breakpoints() *proc.BreakpointMap { return &dbp.breakpoints } // RequestManualStop sets the `halt` flag and // sends SIGSTOP to all threads. -func (dbp *Process) RequestManualStop() error { +func (dbp *nativeProcess) RequestManualStop() error { if dbp.exited { return &proc.ErrProcessExited{Pid: dbp.Pid()} } @@ -200,7 +200,7 @@ func (dbp *Process) RequestManualStop() error { // CheckAndClearManualStopRequest checks if a manual stop has // been requested, and then clears that state. -func (dbp *Process) CheckAndClearManualStopRequest() bool { +func (dbp *nativeProcess) CheckAndClearManualStopRequest() bool { dbp.stopMu.Lock() defer dbp.stopMu.Unlock() @@ -210,7 +210,7 @@ func (dbp *Process) CheckAndClearManualStopRequest() bool { return msr } -func (dbp *Process) writeBreakpoint(addr uint64) (string, int, *proc.Function, []byte, error) { +func (dbp *nativeProcess) writeBreakpoint(addr uint64) (string, int, *proc.Function, []byte, error) { f, l, fn := dbp.bi.PCToLine(uint64(addr)) originalData := make([]byte, dbp.bi.Arch.BreakpointSize()) @@ -227,12 +227,12 @@ func (dbp *Process) writeBreakpoint(addr uint64) (string, int, *proc.Function, [ // SetBreakpoint sets a breakpoint at addr, and stores it in the process wide // break point table. -func (dbp *Process) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error) { +func (dbp *nativeProcess) SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error) { return dbp.breakpoints.Set(addr, kind, cond, dbp.writeBreakpoint) } // ClearBreakpoint clears the breakpoint at addr. -func (dbp *Process) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { +func (dbp *nativeProcess) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { if dbp.exited { return nil, &proc.ErrProcessExited{Pid: dbp.Pid()} } @@ -241,7 +241,7 @@ func (dbp *Process) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) { // ContinueOnce will continue the target until it stops. // This could be the result of a breakpoint or signal. -func (dbp *Process) ContinueOnce() (proc.Thread, proc.StopReason, error) { +func (dbp *nativeProcess) ContinueOnce() (proc.Thread, proc.StopReason, error) { if dbp.exited { return nil, proc.StopExited, &proc.ErrProcessExited{Pid: dbp.Pid()} } @@ -270,7 +270,7 @@ func (dbp *Process) ContinueOnce() (proc.Thread, proc.StopReason, error) { } // FindBreakpoint finds the breakpoint for the given pc. -func (dbp *Process) FindBreakpoint(pc uint64, adjustPC bool) (*proc.Breakpoint, bool) { +func (dbp *nativeProcess) FindBreakpoint(pc uint64, adjustPC bool) (*proc.Breakpoint, bool) { if adjustPC { // Check to see if address is past the breakpoint, (i.e. breakpoint was hit). if bp, ok := dbp.breakpoints.M[pc-uint64(dbp.bi.Arch.BreakpointSize())]; ok { @@ -286,7 +286,7 @@ func (dbp *Process) FindBreakpoint(pc uint64, adjustPC bool) (*proc.Breakpoint, // initialize will ensure that all relevant information is loaded // so the process is ready to be debugged. -func (dbp *Process) initialize(path string, debugInfoDirs []string) (*proc.Target, error) { +func (dbp *nativeProcess) initialize(path string, debugInfoDirs []string) (*proc.Target, error) { if err := initialize(dbp); err != nil { return nil, err } @@ -307,7 +307,7 @@ func (dbp *Process) initialize(path string, debugInfoDirs []string) (*proc.Targe // ClearInternalBreakpoints will clear all non-user set breakpoints. These // breakpoints are set for internal operations such as 'next'. -func (dbp *Process) ClearInternalBreakpoints() error { +func (dbp *nativeProcess) ClearInternalBreakpoints() error { return dbp.breakpoints.ClearInternalBreakpoints(func(bp *proc.Breakpoint) error { if err := dbp.currentThread.ClearBreakpoint(bp); err != nil { return err @@ -321,7 +321,7 @@ func (dbp *Process) ClearInternalBreakpoints() error { }) } -func (dbp *Process) handlePtraceFuncs() { +func (dbp *nativeProcess) handlePtraceFuncs() { // We must ensure here that we are running on the same thread during // while invoking the ptrace(2) syscall. This is due to the fact that ptrace(2) expects // all commands after PTRACE_ATTACH to come from the same thread. @@ -333,19 +333,19 @@ func (dbp *Process) handlePtraceFuncs() { } } -func (dbp *Process) execPtraceFunc(fn func()) { +func (dbp *nativeProcess) execPtraceFunc(fn func()) { dbp.ptraceChan <- fn <-dbp.ptraceDoneChan } -func (dbp *Process) postExit() { +func (dbp *nativeProcess) postExit() { dbp.exited = true close(dbp.ptraceChan) close(dbp.ptraceDoneChan) dbp.bi.Close() } -func (dbp *Process) writeSoftwareBreakpoint(thread *Thread, addr uint64) error { +func (dbp *nativeProcess) writeSoftwareBreakpoint(thread *nativeThread, addr uint64) error { _, err := thread.WriteMemory(uintptr(addr), dbp.bi.Arch.BreakpointInstruction()) return err } diff --git a/pkg/proc/native/proc_darwin.go b/pkg/proc/native/proc_darwin.go index bbc8e1af..0e0c409c 100644 --- a/pkg/proc/native/proc_darwin.go +++ b/pkg/proc/native/proc_darwin.go @@ -20,8 +20,8 @@ import ( "github.com/go-delve/delve/pkg/proc" ) -// OSProcessDetails holds Darwin specific information. -type OSProcessDetails struct { +// osProcessDetails holds Darwin specific information. +type osProcessDetails struct { task C.task_t // mach task for the debugged process. exceptionPort C.mach_port_t // mach port for receiving mach exceptions. notificationPort C.mach_port_t // mach port for dead name notification (process exit). @@ -64,7 +64,7 @@ func Launch(cmd []string, wd string, foreground bool, _ []string) (*proc.Target, // argv array must be null terminated. argvSlice = append(argvSlice, nil) - dbp := New(0) + dbp := newProcess(0) var pid int dbp.execPtraceFunc(func() { ret := C.fork_exec(argv0, &argvSlice[0], C.int(len(argvSlice)), @@ -129,7 +129,7 @@ func Launch(cmd []string, wd string, foreground bool, _ []string) (*proc.Target, // Attach to an existing process with the given PID. func Attach(pid int, _ []string) (*proc.Target, error) { - dbp := New(pid) + dbp := newProcess(pid) kret := C.acquire_mach_task(C.int(pid), &dbp.os.task, &dbp.os.portSet, &dbp.os.exceptionPort, @@ -142,7 +142,7 @@ func Attach(pid int, _ []string) (*proc.Target, error) { dbp.os.initialized = true var err error - dbp.execPtraceFunc(func() { err = PtraceAttach(dbp.pid) }) + dbp.execPtraceFunc(func() { err = ptraceAttach(dbp.pid) }) if err != nil { return nil, err } @@ -160,7 +160,7 @@ func Attach(pid int, _ []string) (*proc.Target, error) { } // Kill kills the process. -func (dbp *Process) kill() (err error) { +func (dbp *nativeProcess) kill() (err error) { if dbp.exited { return nil } @@ -184,7 +184,7 @@ func (dbp *Process) kill() (err error) { return } -func (dbp *Process) requestManualStop() (err error) { +func (dbp *nativeProcess) requestManualStop() (err error) { var ( task = C.mach_port_t(dbp.os.task) thread = C.mach_port_t(dbp.currentThread.os.threadAct) @@ -201,11 +201,11 @@ func (dbp *Process) requestManualStop() (err error) { var couldNotGetThreadCount = errors.New("could not get thread count") var couldNotGetThreadList = errors.New("could not get thread list") -func (dbp *Process) updateThreadList() error { +func (dbp *nativeProcess) updateThreadList() error { return dbp.updateThreadListForTask(dbp.os.task) } -func (dbp *Process) updateThreadListForTask(task C.task_t) error { +func (dbp *nativeProcess) updateThreadListForTask(task C.task_t) error { var ( err error kret C.kern_return_t @@ -255,14 +255,14 @@ func (dbp *Process) updateThreadListForTask(task C.task_t) error { return nil } -func (dbp *Process) addThread(port int, attach bool) (*Thread, error) { +func (dbp *nativeProcess) addThread(port int, attach bool) (*nativeThread, error) { if thread, ok := dbp.threads[port]; ok { return thread, nil } - thread := &Thread{ + thread := &nativeThread{ ID: port, dbp: dbp, - os: new(OSSpecificDetails), + os: new(osSpecificDetails), } dbp.threads[port] = thread thread.os.threadAct = C.thread_act_t(port) @@ -279,7 +279,7 @@ func findExecutable(path string, pid int) string { return path } -func (dbp *Process) trapWait(pid int) (*Thread, error) { +func (dbp *nativeProcess) trapWait(pid int) (*nativeThread, error) { for { task := dbp.os.task port := C.mach_port_wait(dbp.os.portSet, &task, C.int(0)) @@ -357,7 +357,7 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) { } } -func (dbp *Process) waitForStop() ([]int, error) { +func (dbp *nativeProcess) waitForStop() ([]int, error) { ports := make([]int, 0, len(dbp.threads)) count := 0 for { @@ -379,7 +379,7 @@ func (dbp *Process) waitForStop() ([]int, error) { } } -func (dbp *Process) wait(pid, options int) (int, *sys.WaitStatus, error) { +func (dbp *nativeProcess) wait(pid, options int) (int, *sys.WaitStatus, error) { var status sys.WaitStatus wpid, err := sys.Wait4(pid, &status, options, nil) return wpid, &status, err @@ -389,7 +389,7 @@ func killProcess(pid int) error { return sys.Kill(pid, sys.SIGINT) } -func (dbp *Process) exitGuard(err error) error { +func (dbp *nativeProcess) exitGuard(err error) error { if err != ErrContinueThread { return err } @@ -401,7 +401,7 @@ func (dbp *Process) exitGuard(err error) error { return err } -func (dbp *Process) resume() error { +func (dbp *nativeProcess) resume() error { // all threads stopped over a breakpoint are made to step over it for _, thread := range dbp.threads { if thread.CurrentBreakpoint.Breakpoint != nil { @@ -421,7 +421,7 @@ func (dbp *Process) resume() error { } // stop stops all running threads and sets breakpoints -func (dbp *Process) stop(trapthread *Thread) (err error) { +func (dbp *nativeProcess) stop(trapthread *nativeThread) (err error) { if dbp.exited { return &proc.ErrProcessExited{Pid: dbp.Pid()} } @@ -452,13 +452,13 @@ func (dbp *Process) stop(trapthread *Thread) (err error) { return nil } -func (dbp *Process) detach(kill bool) error { - return PtraceDetach(dbp.pid, 0) +func (dbp *nativeProcess) detach(kill bool) error { + return ptraceDetach(dbp.pid, 0) } -func (dbp *Process) EntryPoint() (uint64, error) { +func (dbp *nativeProcess) EntryPoint() (uint64, error) { //TODO(aarzilli): implement this return 0, nil } -func initialize(dbp *Process) error { return nil } +func initialize(dbp *nativeProcess) error { return nil } diff --git a/pkg/proc/native/proc_freebsd.go b/pkg/proc/native/proc_freebsd.go index b3ae6e85..df2773a1 100644 --- a/pkg/proc/native/proc_freebsd.go +++ b/pkg/proc/native/proc_freebsd.go @@ -22,18 +22,18 @@ import ( // Process statuses const ( - StatusIdle = 1 - StatusRunning = 2 - StatusSleeping = 3 - StatusStopped = 4 - StatusZombie = 5 - StatusWaiting = 6 - StatusLocked = 7 + statusIdle = 1 + statusRunning = 2 + statusSleeping = 3 + statusStopped = 4 + statusZombie = 5 + statusWaiting = 6 + statusLocked = 7 ) -// OSProcessDetails contains FreeBSD specific +// osProcessDetails contains FreeBSD specific // process details. -type OSProcessDetails struct { +type osProcessDetails struct { comm string tid int } @@ -59,7 +59,7 @@ func Launch(cmd []string, wd string, foreground bool, debugInfoDirs []string) (* foreground = false } - dbp := New(0) + dbp := newProcess(0) dbp.execPtraceFunc(func() { process = exec.Command(cmd[0]) process.Args = cmd @@ -95,10 +95,10 @@ func Launch(cmd []string, wd string, foreground bool, debugInfoDirs []string) (* // the DWARF information cannot be found in the binary, Delve will look // for external debug files in the directories passed in. func Attach(pid int, debugInfoDirs []string) (*proc.Target, error) { - dbp := New(pid) + dbp := newProcess(pid) var err error - dbp.execPtraceFunc(func() { err = PtraceAttach(dbp.pid) }) + dbp.execPtraceFunc(func() { err = ptraceAttach(dbp.pid) }) if err != nil { return nil, err } @@ -115,7 +115,7 @@ func Attach(pid int, debugInfoDirs []string) (*proc.Target, error) { return tgt, nil } -func initialize(dbp *Process) error { +func initialize(dbp *nativeProcess) error { comm, _ := C.find_command_name(C.int(dbp.pid)) defer C.free(unsafe.Pointer(comm)) comm_str := C.GoString(comm) @@ -124,11 +124,11 @@ func initialize(dbp *Process) error { } // kill kills the target process. -func (dbp *Process) kill() (err error) { +func (dbp *nativeProcess) kill() (err error) { if dbp.exited { return nil } - dbp.execPtraceFunc(func() { err = PtraceCont(dbp.pid, int(sys.SIGKILL)) }) + dbp.execPtraceFunc(func() { err = ptraceCont(dbp.pid, int(sys.SIGKILL)) }) if err != nil { return err } @@ -140,13 +140,13 @@ func (dbp *Process) kill() (err error) { } // Used by RequestManualStop -func (dbp *Process) requestManualStop() (err error) { +func (dbp *nativeProcess) requestManualStop() (err error) { return sys.Kill(dbp.pid, sys.SIGTRAP) } // Attach to a newly created thread, and store that thread in our list of // known threads. -func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) { +func (dbp *nativeProcess) addThread(tid int, attach bool) (*nativeThread, error) { if thread, ok := dbp.threads[tid]; ok { return thread, nil } @@ -159,10 +159,10 @@ func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) { } } - dbp.threads[tid] = &Thread{ + dbp.threads[tid] = &nativeThread{ ID: tid, dbp: dbp, - os: new(OSSpecificDetails), + os: new(osSpecificDetails), } if dbp.currentThread == nil { @@ -173,9 +173,9 @@ func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) { } // Used by initialize -func (dbp *Process) updateThreadList() error { +func (dbp *nativeProcess) updateThreadList() error { var tids []int32 - dbp.execPtraceFunc(func() { tids = PtraceGetLwpList(dbp.pid) }) + dbp.execPtraceFunc(func() { tids = ptraceGetLwpList(dbp.pid) }) for _, tid := range tids { if _, err := dbp.addThread(int(tid), false); err != nil { return err @@ -195,12 +195,12 @@ func findExecutable(path string, pid int) string { return path } -func (dbp *Process) trapWait(pid int) (*Thread, error) { +func (dbp *nativeProcess) trapWait(pid int) (*nativeThread, error) { return dbp.trapWaitInternal(pid, false) } // Used by stop and trapWait -func (dbp *Process) trapWaitInternal(pid int, halt bool) (*Thread, error) { +func (dbp *nativeProcess) trapWaitInternal(pid int, halt bool) (*nativeThread, error) { for { wpid, status, err := dbp.wait(pid, 0) if err != nil { @@ -225,13 +225,13 @@ func (dbp *Process) trapWaitInternal(pid int, halt bool) (*Thread, error) { pl_flags := int(info.Flags) th, ok := dbp.threads[tid] if ok { - th.Status = (*WaitStatus)(status) + th.Status = (*waitStatus)(status) } if status.StopSignal() == sys.SIGTRAP { if pl_flags&sys.PL_FLAG_EXITED != 0 { delete(dbp.threads, tid) - dbp.execPtraceFunc(func() { err = PtraceCont(tid, 0) }) + dbp.execPtraceFunc(func() { err = ptraceCont(tid, 0) }) if err != nil { return nil, err } @@ -287,25 +287,25 @@ func status(pid int) rune { // Used by stop and singleStep // waitFast is like wait but does not handle process-exit correctly -func (dbp *Process) waitFast(pid int) (int, *sys.WaitStatus, error) { +func (dbp *nativeProcess) waitFast(pid int) (int, *sys.WaitStatus, error) { var s sys.WaitStatus wpid, err := sys.Wait4(pid, &s, 0, nil) return wpid, &s, err } // Only used in this file -func (dbp *Process) wait(pid, options int) (int, *sys.WaitStatus, error) { +func (dbp *nativeProcess) wait(pid, options int) (int, *sys.WaitStatus, error) { var s sys.WaitStatus wpid, err := sys.Wait4(pid, &s, options, nil) return wpid, &s, err } // Only used in this file -func (dbp *Process) exitGuard(err error) error { +func (dbp *nativeProcess) exitGuard(err error) error { if err != sys.ESRCH { return err } - if status(dbp.pid) == StatusZombie { + if status(dbp.pid) == statusZombie { _, err := dbp.trapWaitInternal(-1, false) return err } @@ -314,7 +314,7 @@ func (dbp *Process) exitGuard(err error) error { } // Used by ContinueOnce -func (dbp *Process) resume() error { +func (dbp *nativeProcess) resume() error { // all threads stopped over a breakpoint are made to step over it for _, thread := range dbp.threads { if thread.CurrentBreakpoint.Breakpoint != nil { @@ -326,13 +326,13 @@ func (dbp *Process) resume() error { } // all threads are resumed var err error - dbp.execPtraceFunc(func() { err = PtraceCont(dbp.pid, 0) }) + dbp.execPtraceFunc(func() { err = ptraceCont(dbp.pid, 0) }) return err } // Used by ContinueOnce // stop stops all running threads and sets breakpoints -func (dbp *Process) stop(trapthread *Thread) (err error) { +func (dbp *nativeProcess) stop(trapthread *nativeThread) (err error) { if dbp.exited { return &proc.ErrProcessExited{Pid: dbp.Pid()} } @@ -348,13 +348,13 @@ func (dbp *Process) stop(trapthread *Thread) (err error) { } // Used by Detach -func (dbp *Process) detach(kill bool) error { - return PtraceDetach(dbp.pid) +func (dbp *nativeProcess) detach(kill bool) error { + return ptraceDetach(dbp.pid) } // Used by PostInitializationSetup // EntryPoint will return the process entry point address, useful for debugging PIEs. -func (dbp *Process) EntryPoint() (uint64, error) { +func (dbp *nativeProcess) EntryPoint() (uint64, error) { ep, err := C.get_entry_point(C.int(dbp.pid)) return uint64(ep), err } diff --git a/pkg/proc/native/proc_linux.go b/pkg/proc/native/proc_linux.go index 61368b96..a134af42 100644 --- a/pkg/proc/native/proc_linux.go +++ b/pkg/proc/native/proc_linux.go @@ -26,21 +26,21 @@ import ( // Process statuses const ( - StatusSleeping = 'S' - StatusRunning = 'R' - StatusTraceStop = 't' - StatusZombie = 'Z' + statusSleeping = 'S' + statusRunning = 'R' + statusTraceStop = 't' + statusZombie = 'Z' // Kernel 2.6 has TraceStop as T // TODO(derekparker) Since this means something different based on the // version of the kernel ('T' is job control stop on modern 3.x+ kernels) we // may want to differentiate at some point. - StatusTraceStopT = 'T' + statusTraceStopT = 'T' ) -// OSProcessDetails contains Linux specific +// osProcessDetails contains Linux specific // process details. -type OSProcessDetails struct { +type osProcessDetails struct { comm string } @@ -65,7 +65,7 @@ func Launch(cmd []string, wd string, foreground bool, debugInfoDirs []string) (* foreground = false } - dbp := New(0) + dbp := newProcess(0) dbp.execPtraceFunc(func() { process = exec.Command(cmd[0]) process.Args = cmd @@ -101,10 +101,10 @@ func Launch(cmd []string, wd string, foreground bool, debugInfoDirs []string) (* // the DWARF information cannot be found in the binary, Delve will look // for external debug files in the directories passed in. func Attach(pid int, debugInfoDirs []string) (*proc.Target, error) { - dbp := New(pid) + dbp := newProcess(pid) var err error - dbp.execPtraceFunc(func() { err = PtraceAttach(dbp.pid) }) + dbp.execPtraceFunc(func() { err = ptraceAttach(dbp.pid) }) if err != nil { return nil, err } @@ -128,7 +128,7 @@ func Attach(pid int, debugInfoDirs []string) (*proc.Target, error) { return tgt, nil } -func initialize(dbp *Process) error { +func initialize(dbp *nativeProcess) error { comm, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/comm", dbp.pid)) if err == nil { // removes newline character @@ -156,7 +156,7 @@ func initialize(dbp *Process) error { } // kill kills the target process. -func (dbp *Process) kill() (err error) { +func (dbp *nativeProcess) kill() (err error) { if dbp.exited { return nil } @@ -173,13 +173,13 @@ func (dbp *Process) kill() (err error) { return } -func (dbp *Process) requestManualStop() (err error) { +func (dbp *nativeProcess) requestManualStop() (err error) { return sys.Kill(dbp.pid, sys.SIGTRAP) } // Attach to a newly created thread, and store that thread in our list of // known threads. -func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) { +func (dbp *nativeProcess) addThread(tid int, attach bool) (*nativeThread, error) { if thread, ok := dbp.threads[tid]; ok { return thread, nil } @@ -217,10 +217,10 @@ func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) { } } - dbp.threads[tid] = &Thread{ + dbp.threads[tid] = &nativeThread{ ID: tid, dbp: dbp, - os: new(OSSpecificDetails), + os: new(osSpecificDetails), } if dbp.currentThread == nil { dbp.currentThread = dbp.threads[tid] @@ -228,7 +228,7 @@ func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) { return dbp.threads[tid], nil } -func (dbp *Process) updateThreadList() error { +func (dbp *nativeProcess) updateThreadList() error { tids, _ := filepath.Glob(fmt.Sprintf("/proc/%d/task/*", dbp.pid)) for _, tidpath := range tids { tidstr := filepath.Base(tidpath) @@ -250,7 +250,7 @@ func findExecutable(path string, pid int) string { return path } -func (dbp *Process) trapWait(pid int) (*Thread, error) { +func (dbp *nativeProcess) trapWait(pid int) (*nativeThread, error) { return dbp.trapWaitInternal(pid, 0) } @@ -261,7 +261,7 @@ const ( trapWaitNohang ) -func (dbp *Process) trapWaitInternal(pid int, options trapWaitOptions) (*Thread, error) { +func (dbp *nativeProcess) trapWaitInternal(pid int, options trapWaitOptions) (*nativeThread, error) { halt := options&trapWaitHalt != 0 for { wopt := 0 @@ -280,7 +280,7 @@ func (dbp *Process) trapWaitInternal(pid int, options trapWaitOptions) (*Thread, } th, ok := dbp.threads[wpid] if ok { - th.Status = (*WaitStatus)(status) + th.Status = (*waitStatus)(status) } if status.Exited() { if wpid == dbp.pid { @@ -387,13 +387,13 @@ func status(pid int, comm string) rune { } // waitFast is like wait but does not handle process-exit correctly -func (dbp *Process) waitFast(pid int) (int, *sys.WaitStatus, error) { +func (dbp *nativeProcess) waitFast(pid int) (int, *sys.WaitStatus, error) { var s sys.WaitStatus wpid, err := sys.Wait4(pid, &s, sys.WALL, nil) return wpid, &s, err } -func (dbp *Process) wait(pid, options int) (int, *sys.WaitStatus, error) { +func (dbp *nativeProcess) wait(pid, options int) (int, *sys.WaitStatus, error) { var s sys.WaitStatus if (pid != dbp.pid) || (options != 0) { wpid, err := sys.Wait4(pid, &s, sys.WALL|options, nil) @@ -418,18 +418,18 @@ func (dbp *Process) wait(pid, options int) (int, *sys.WaitStatus, error) { if wpid != 0 { return wpid, &s, err } - if status(pid, dbp.os.comm) == StatusZombie { + if status(pid, dbp.os.comm) == statusZombie { return pid, nil, nil } time.Sleep(200 * time.Millisecond) } } -func (dbp *Process) exitGuard(err error) error { +func (dbp *nativeProcess) exitGuard(err error) error { if err != sys.ESRCH { return err } - if status(dbp.pid, dbp.os.comm) == StatusZombie { + if status(dbp.pid, dbp.os.comm) == statusZombie { _, err := dbp.trapWaitInternal(-1, 0) return err } @@ -437,7 +437,7 @@ func (dbp *Process) exitGuard(err error) error { return err } -func (dbp *Process) resume() error { +func (dbp *nativeProcess) resume() error { // all threads stopped over a breakpoint are made to step over it for _, thread := range dbp.threads { if thread.CurrentBreakpoint.Breakpoint != nil { @@ -457,7 +457,7 @@ func (dbp *Process) resume() error { } // stop stops all running threads and sets breakpoints -func (dbp *Process) stop(trapthread *Thread) (err error) { +func (dbp *nativeProcess) stop(trapthread *nativeThread) (err error) { if dbp.exited { return &proc.ErrProcessExited{Pid: dbp.Pid()} } @@ -517,9 +517,9 @@ func (dbp *Process) stop(trapthread *Thread) (err error) { return nil } -func (dbp *Process) detach(kill bool) error { +func (dbp *nativeProcess) detach(kill bool) error { for threadID := range dbp.threads { - err := PtraceDetach(threadID, 0) + err := ptraceDetach(threadID, 0) if err != nil { return err } @@ -540,7 +540,7 @@ func (dbp *Process) detach(kill bool) error { // EntryPoint will return the process entry point address, useful for // debugging PIEs. -func (dbp *Process) EntryPoint() (uint64, error) { +func (dbp *nativeProcess) EntryPoint() (uint64, error) { auxvbuf, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/auxv", dbp.pid)) if err != nil { return 0, fmt.Errorf("could not read auxiliary vector: %v", err) diff --git a/pkg/proc/native/proc_windows.go b/pkg/proc/native/proc_windows.go index 4e3c56ca..3a8ca05b 100644 --- a/pkg/proc/native/proc_windows.go +++ b/pkg/proc/native/proc_windows.go @@ -15,8 +15,8 @@ import ( "github.com/go-delve/delve/pkg/proc" ) -// OSProcessDetails holds Windows specific information. -type OSProcessDetails struct { +// osProcessDetails holds Windows specific information. +type osProcessDetails struct { hProcess syscall.Handle breakThread int entryPoint uint64 @@ -58,7 +58,7 @@ func Launch(cmd []string, wd string, foreground bool, _ []string) (*proc.Target, env := proc.DisableAsyncPreemptEnv() var p *os.Process - dbp := New(0) + dbp := newProcess(0) dbp.execPtraceFunc(func() { attr := &os.ProcAttr{ Dir: wd, @@ -86,7 +86,7 @@ func Launch(cmd []string, wd string, foreground bool, _ []string) (*proc.Target, return tgt, nil } -func initialize(dbp *Process) error { +func initialize(dbp *nativeProcess) error { // It should not actually be possible for the // call to waitForDebugEvent to fail, since Windows // will always fire a CREATE_PROCESS_DEBUG_EVENT event @@ -155,7 +155,7 @@ func findExePath(pid int) (string, error) { // Attach to an existing process with the given PID. func Attach(pid int, _ []string) (*proc.Target, error) { - dbp := New(pid) + dbp := newProcess(pid) var err error dbp.execPtraceFunc(func() { // TODO: Probably should have SeDebugPrivilege before starting here. @@ -177,7 +177,7 @@ func Attach(pid int, _ []string) (*proc.Target, error) { } // kill kills the process. -func (dbp *Process) kill() error { +func (dbp *nativeProcess) kill() error { if dbp.exited { return nil } @@ -203,24 +203,24 @@ func (dbp *Process) kill() error { return nil } -func (dbp *Process) requestManualStop() error { +func (dbp *nativeProcess) requestManualStop() error { return _DebugBreakProcess(dbp.os.hProcess) } -func (dbp *Process) updateThreadList() error { +func (dbp *nativeProcess) updateThreadList() error { // We ignore this request since threads are being // tracked as they are created/killed in waitForDebugEvent. return nil } -func (dbp *Process) addThread(hThread syscall.Handle, threadID int, attach, suspendNewThreads bool) (*Thread, error) { +func (dbp *nativeProcess) addThread(hThread syscall.Handle, threadID int, attach, suspendNewThreads bool) (*nativeThread, error) { if thread, ok := dbp.threads[threadID]; ok { return thread, nil } - thread := &Thread{ + thread := &nativeThread{ ID: threadID, dbp: dbp, - os: new(OSSpecificDetails), + os: new(osSpecificDetails), } thread.os.hThread = hThread dbp.threads[threadID] = thread @@ -250,7 +250,7 @@ const ( const _MS_VC_EXCEPTION = 0x406D1388 // part of VisualC protocol to set thread names -func (dbp *Process) waitForDebugEvent(flags waitForDebugEventFlags) (threadID, exitCode int, err error) { +func (dbp *nativeProcess) waitForDebugEvent(flags waitForDebugEventFlags) (threadID, exitCode int, err error) { var debugEvent _DEBUG_EVENT shouldExit := false for { @@ -378,7 +378,7 @@ func (dbp *Process) waitForDebugEvent(flags waitForDebugEventFlags) (threadID, e } } -func (dbp *Process) trapWait(pid int) (*Thread, error) { +func (dbp *nativeProcess) trapWait(pid int) (*nativeThread, error) { var err error var tid, exitCode int dbp.execPtraceFunc(func() { @@ -395,15 +395,15 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) { return th, nil } -func (dbp *Process) wait(pid, options int) (int, *sys.WaitStatus, error) { +func (dbp *nativeProcess) wait(pid, options int) (int, *sys.WaitStatus, error) { return 0, nil, fmt.Errorf("not implemented: wait") } -func (dbp *Process) exitGuard(err error) error { +func (dbp *nativeProcess) exitGuard(err error) error { return err } -func (dbp *Process) resume() error { +func (dbp *nativeProcess) resume() error { for _, thread := range dbp.threads { if thread.CurrentBreakpoint.Breakpoint != nil { if err := thread.StepInstruction(); err != nil { @@ -424,7 +424,7 @@ func (dbp *Process) resume() error { } // stop stops all running threads threads and sets breakpoints -func (dbp *Process) stop(trapthread *Thread) (err error) { +func (dbp *nativeProcess) stop(trapthread *nativeThread) (err error) { if dbp.exited { return &proc.ErrProcessExited{Pid: dbp.Pid()} } @@ -475,7 +475,7 @@ func (dbp *Process) stop(trapthread *Thread) (err error) { return nil } -func (dbp *Process) detach(kill bool) error { +func (dbp *nativeProcess) detach(kill bool) error { if !kill { //TODO(aarzilli): when debug.Target exist Detach should be moved to // debug.Target and the call to RestoreAsyncPreempt should be moved there. @@ -489,7 +489,7 @@ func (dbp *Process) detach(kill bool) error { return _DebugActiveProcessStop(uint32(dbp.pid)) } -func (dbp *Process) EntryPoint() (uint64, error) { +func (dbp *nativeProcess) EntryPoint() (uint64, error) { return dbp.os.entryPoint, nil } diff --git a/pkg/proc/native/ptrace_darwin.go b/pkg/proc/native/ptrace_darwin.go index 87d3b92a..5fd6ca41 100644 --- a/pkg/proc/native/ptrace_darwin.go +++ b/pkg/proc/native/ptrace_darwin.go @@ -4,23 +4,23 @@ package native import sys "golang.org/x/sys/unix" -// PtraceAttach executes the sys.PtraceAttach call. -func PtraceAttach(pid int) error { +// ptraceAttach executes the sys.PtraceAttach call. +func ptraceAttach(pid int) error { return sys.PtraceAttach(pid) } -// PtraceDetach executes the PT_DETACH ptrace call. -func PtraceDetach(tid, sig int) error { +// ptraceDetach executes the PT_DETACH ptrace call. +func ptraceDetach(tid, sig int) error { return ptrace(sys.PT_DETACH, tid, 1, uintptr(sig)) } -// PtraceCont executes the PTRACE_CONT ptrace call. -func PtraceCont(tid, sig int) error { +// ptraceCont executes the PTRACE_CONT ptrace call. +func ptraceCont(tid, sig int) error { return ptrace(sys.PTRACE_CONT, tid, 1, 0) } -// PtraceSingleStep returns PT_STEP ptrace call. -func PtraceSingleStep(tid int) error { +// ptraceSingleStep returns PT_STEP ptrace call. +func ptraceSingleStep(tid int) error { return ptrace(sys.PT_STEP, tid, 1, 0) } diff --git a/pkg/proc/native/ptrace_freebsd.go b/pkg/proc/native/ptrace_freebsd.go index 494ae4c8..1e3fc431 100644 --- a/pkg/proc/native/ptrace_freebsd.go +++ b/pkg/proc/native/ptrace_freebsd.go @@ -17,31 +17,31 @@ import ( "github.com/go-delve/delve/pkg/proc/fbsdutil" ) -// PtraceAttach executes the sys.PtraceAttach call. +// ptraceAttach executes the sys.PtraceAttach call. // pid must be a PID, not a LWPID -func PtraceAttach(pid int) error { +func ptraceAttach(pid int) error { return sys.PtraceAttach(pid) } -// PtraceDetach calls ptrace(PTRACE_DETACH). -func PtraceDetach(pid int) error { +// ptraceDetach calls ptrace(PTRACE_DETACH). +func ptraceDetach(pid int) error { return sys.PtraceDetach(pid) } -// PtraceCont executes ptrace PTRACE_CONT +// ptraceCont executes ptrace PTRACE_CONT // id may be a PID or an LWPID -func PtraceCont(id, sig int) error { +func ptraceCont(id, sig int) error { return sys.PtraceCont(id, sig) } -// PtraceSingleStep executes ptrace PTRACE_SINGLE_STEP. +// ptraceSingleStep executes ptrace PTRACE_SINGLE_STEP. // id may be a PID or an LWPID -func PtraceSingleStep(id int) error { +func ptraceSingleStep(id int) error { return sys.PtraceSingleStep(id) } // Get a list of the thread ids of a process -func PtraceGetLwpList(pid int) (tids []int32) { +func ptraceGetLwpList(pid int) (tids []int32) { num_lwps, _ := C.ptrace_get_num_lwps(C.int(pid)) tids = make([]int32, num_lwps) n, _ := C.ptrace_get_lwp_list(C.int(pid), (*C.int)(unsafe.Pointer(&tids[0])), C.size_t(num_lwps)) @@ -54,7 +54,7 @@ func ptraceGetLwpInfo(wpid int) (info sys.PtraceLwpInfoStruct, err error) { return info, err } -func PtraceGetRegset(id int) (regset fbsdutil.AMD64Xstate, err error) { +func ptraceGetRegset(id int) (regset fbsdutil.AMD64Xstate, err error) { _, _, err = syscall.Syscall6(syscall.SYS_PTRACE, sys.PTRACE_GETFPREGS, uintptr(id), uintptr(unsafe.Pointer(®set.AMD64PtraceFpRegs)), 0, 0, 0) if err == syscall.Errno(0) || err == syscall.ENODEV { var xsave_len C.size_t diff --git a/pkg/proc/native/ptrace_linux.go b/pkg/proc/native/ptrace_linux.go index ab4f5372..d1312755 100644 --- a/pkg/proc/native/ptrace_linux.go +++ b/pkg/proc/native/ptrace_linux.go @@ -2,18 +2,17 @@ package native import ( "syscall" - "unsafe" sys "golang.org/x/sys/unix" ) -// PtraceAttach executes the sys.PtraceAttach call. -func PtraceAttach(pid int) error { +// ptraceAttach executes the sys.PtraceAttach call. +func ptraceAttach(pid int) error { return sys.PtraceAttach(pid) } -// PtraceDetach calls ptrace(PTRACE_DETACH). -func PtraceDetach(tid, sig int) error { +// ptraceDetach calls ptrace(PTRACE_DETACH). +func ptraceDetach(tid, sig int) error { _, _, err := sys.Syscall6(sys.SYS_PTRACE, sys.PTRACE_DETACH, uintptr(tid), 1, uintptr(sig), 0, 0) if err != syscall.Errno(0) { return err @@ -21,31 +20,7 @@ func PtraceDetach(tid, sig int) error { return nil } -// PtraceCont executes ptrace PTRACE_CONT -func PtraceCont(tid, sig int) error { +// ptraceCont executes ptrace PTRACE_CONT +func ptraceCont(tid, sig int) error { return sys.PtraceCont(tid, sig) } - -// PtraceSingleStep executes ptrace PTRACE_SINGLE_STEP. -func PtraceSingleStep(tid int) error { - return sys.PtraceSingleStep(tid) -} - -// PtracePokeUser execute ptrace PTRACE_POKE_USER. -func PtracePokeUser(tid int, off, addr uintptr) error { - _, _, err := sys.Syscall6(sys.SYS_PTRACE, sys.PTRACE_POKEUSR, uintptr(tid), uintptr(off), uintptr(addr), 0, 0) - if err != syscall.Errno(0) { - return err - } - return nil -} - -// PtracePeekUser execute ptrace PTRACE_PEEK_USER. -func PtracePeekUser(tid int, off uintptr) (uintptr, error) { - var val uintptr - _, _, err := syscall.Syscall6(syscall.SYS_PTRACE, syscall.PTRACE_PEEKUSR, uintptr(tid), uintptr(off), uintptr(unsafe.Pointer(&val)), 0, 0) - if err != syscall.Errno(0) { - return 0, err - } - return val, nil -} diff --git a/pkg/proc/native/ptrace_linux_386.go b/pkg/proc/native/ptrace_linux_386.go index 269f95e2..f01e3562 100644 --- a/pkg/proc/native/ptrace_linux_386.go +++ b/pkg/proc/native/ptrace_linux_386.go @@ -12,12 +12,12 @@ import ( "github.com/go-delve/delve/pkg/proc/linutil" ) -// PtraceGetRegset returns floating point registers of the specified thread +// ptraceGetRegset returns floating point registers of the specified thread // using PTRACE. // See i386_linux_fetch_inferior_registers in gdb/i386-linux-nat.c.html // and i386_supply_xsave in gdb/i386-tdep.c.html // and Section 13.1 (and following) of Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 1: Basic Architecture -func PtraceGetRegset(tid int) (regset linutil.I386Xstate, err error) { +func ptraceGetRegset(tid int) (regset linutil.I386Xstate, err error) { _, _, err = syscall.Syscall6(syscall.SYS_PTRACE, sys.PTRACE_GETFPREGS, uintptr(tid), uintptr(0), uintptr(unsafe.Pointer(®set.I386PtraceFpRegs)), 0, 0) if err == syscall.Errno(0) || err == syscall.ENODEV { // ignore ENODEV, it just means this CPU doesn't have X87 registers (??) @@ -43,7 +43,7 @@ func PtraceGetRegset(tid int) (regset linutil.I386Xstate, err error) { return } -// PtraceGetTls return the addr of tls by PTRACE_GET_THREAD_AREA for specify thread. +// ptraceGetTls return the addr of tls by PTRACE_GET_THREAD_AREA for specify thread. // See http://man7.org/linux/man-pages/man2/ptrace.2.html for detail about PTRACE_GET_THREAD_AREA. // struct user_desc at https://golang.org/src/runtime/sys_linux_386.s // type UserDesc struct { @@ -52,7 +52,7 @@ func PtraceGetRegset(tid int) (regset linutil.I386Xstate, err error) { // Limit uint32 // Flag uint32 // } -func PtraceGetTls(gs int32, tid int) (uint32, error) { +func ptraceGetTls(gs int32, tid int) (uint32, error) { ud := [4]uint32{} // Gs usually is 0x33 @@ -64,8 +64,8 @@ func PtraceGetTls(gs int32, tid int) (uint32, error) { return uint32(ud[1]), nil } -// ProcessVmRead calls process_vm_readv -func ProcessVmRead(tid int, addr uintptr, data []byte) (int, error) { +// processVmRead calls process_vm_readv +func processVmRead(tid int, addr uintptr, data []byte) (int, error) { len_iov := uint32(len(data)) local_iov := sys.Iovec{Base: &data[0], Len: len_iov} remote_iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(addr)), Len: len_iov} @@ -78,8 +78,8 @@ func ProcessVmRead(tid int, addr uintptr, data []byte) (int, error) { return int(n), nil } -// ProcessVmWrite calls process_vm_writev -func ProcessVmWrite(tid int, addr uintptr, data []byte) (int, error) { +// processVmWrite calls process_vm_writev +func processVmWrite(tid int, addr uintptr, data []byte) (int, error) { len_iov := uint32(len(data)) local_iov := sys.Iovec{Base: &data[0], Len: len_iov} remote_iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(addr)), Len: len_iov} diff --git a/pkg/proc/native/ptrace_linux_64bit.go b/pkg/proc/native/ptrace_linux_64bit.go index 9206f046..d31cdf59 100644 --- a/pkg/proc/native/ptrace_linux_64bit.go +++ b/pkg/proc/native/ptrace_linux_64bit.go @@ -9,8 +9,8 @@ import ( sys "golang.org/x/sys/unix" ) -// ProcessVmRead calls process_vm_readv -func ProcessVmRead(tid int, addr uintptr, data []byte) (int, error) { +// processVmRead calls process_vm_readv +func processVmRead(tid int, addr uintptr, data []byte) (int, error) { len_iov := uint64(len(data)) local_iov := sys.Iovec{Base: &data[0], Len: len_iov} remote_iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(addr)), Len: len_iov} @@ -23,8 +23,8 @@ func ProcessVmRead(tid int, addr uintptr, data []byte) (int, error) { return int(n), nil } -// ProcessVmWrite calls process_vm_writev -func ProcessVmWrite(tid int, addr uintptr, data []byte) (int, error) { +// processVmWrite calls process_vm_writev +func processVmWrite(tid int, addr uintptr, data []byte) (int, error) { len_iov := uint64(len(data)) local_iov := sys.Iovec{Base: &data[0], Len: len_iov} remote_iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(addr)), Len: len_iov} diff --git a/pkg/proc/native/ptrace_linux_amd64.go b/pkg/proc/native/ptrace_linux_amd64.go index 5532c76f..a56cf19d 100644 --- a/pkg/proc/native/ptrace_linux_amd64.go +++ b/pkg/proc/native/ptrace_linux_amd64.go @@ -9,12 +9,12 @@ import ( "github.com/go-delve/delve/pkg/proc/linutil" ) -// PtraceGetRegset returns floating point registers of the specified thread +// ptraceGetRegset returns floating point registers of the specified thread // using PTRACE. // See amd64_linux_fetch_inferior_registers in gdb/amd64-linux-nat.c.html // and amd64_supply_xsave in gdb/amd64-tdep.c.html // and Section 13.1 (and following) of Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 1: Basic Architecture -func PtraceGetRegset(tid int) (regset linutil.AMD64Xstate, err error) { +func ptraceGetRegset(tid int) (regset linutil.AMD64Xstate, err error) { _, _, err = syscall.Syscall6(syscall.SYS_PTRACE, sys.PTRACE_GETFPREGS, uintptr(tid), uintptr(0), uintptr(unsafe.Pointer(®set.AMD64PtraceFpRegs)), 0, 0) if err == syscall.Errno(0) || err == syscall.ENODEV { // ignore ENODEV, it just means this CPU doesn't have X87 registers (??) @@ -38,4 +38,4 @@ func PtraceGetRegset(tid int) (regset linutil.AMD64Xstate, err error) { regset.Xsave = xstateargs[:iov.Len] err = linutil.AMD64XstateRead(regset.Xsave, false, ®set) return -} \ No newline at end of file +} diff --git a/pkg/proc/native/register_linux_386.go b/pkg/proc/native/register_linux_386.go index 9eb7d162..b8aa0128 100644 --- a/pkg/proc/native/register_linux_386.go +++ b/pkg/proc/native/register_linux_386.go @@ -10,7 +10,7 @@ import ( ) // SetPC sets EIP to the value specified by 'pc'. -func (thread *Thread) SetPC(pc uint64) error { +func (thread *nativeThread) SetPC(pc uint64) error { ir, err := registers(thread, false) if err != nil { return err @@ -22,7 +22,7 @@ func (thread *Thread) SetPC(pc uint64) error { } // SetSP sets ESP to the value specified by 'sp' -func (thread *Thread) SetSP(sp uint64) (err error) { +func (thread *nativeThread) SetSP(sp uint64) (err error) { var ir proc.Registers ir, err = registers(thread, false) if err != nil { @@ -34,7 +34,7 @@ func (thread *Thread) SetSP(sp uint64) (err error) { return } -func (thread *Thread) SetDX(dx uint64) (err error) { +func (thread *nativeThread) SetDX(dx uint64) (err error) { var ir proc.Registers ir, err = registers(thread, false) if err != nil { @@ -46,7 +46,7 @@ func (thread *Thread) SetDX(dx uint64) (err error) { return } -func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { +func registers(thread *nativeThread, floatingPoint bool) (proc.Registers, error) { var ( regs linutil.I386PtraceRegs err error @@ -65,7 +65,7 @@ func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { } } thread.dbp.execPtraceFunc(func() { - tls, _ := PtraceGetTls(regs.Xgs, thread.ThreadID()) + tls, _ := ptraceGetTls(regs.Xgs, thread.ThreadID()) r.Tls = uint64(tls) }) return r, nil @@ -81,8 +81,8 @@ const ( _XSAVE_SSE_REGION_LEN = 416 ) -func (thread *Thread) fpRegisters() (regs []proc.Register, fpregs linutil.I386Xstate, err error) { - thread.dbp.execPtraceFunc(func() { fpregs, err = PtraceGetRegset(thread.ID) }) +func (thread *nativeThread) fpRegisters() (regs []proc.Register, fpregs linutil.I386Xstate, err error) { + thread.dbp.execPtraceFunc(func() { fpregs, err = ptraceGetRegset(thread.ID) }) regs = fpregs.Decode() if err != nil { err = fmt.Errorf("could not get floating point registers: %v", err.Error()) diff --git a/pkg/proc/native/registers_darwin_amd64.go b/pkg/proc/native/registers_darwin_amd64.go index 070eb4df..e3006a0a 100644 --- a/pkg/proc/native/registers_darwin_amd64.go +++ b/pkg/proc/native/registers_darwin_amd64.go @@ -111,7 +111,7 @@ func (r *Regs) GAddr() (uint64, bool) { } // SetPC sets the RIP register to the value specified by `pc`. -func (thread *Thread) SetPC(pc uint64) error { +func (thread *nativeThread) SetPC(pc uint64) error { kret := C.set_pc(thread.os.threadAct, C.uint64_t(pc)) if kret != C.KERN_SUCCESS { return fmt.Errorf("could not set pc") @@ -120,11 +120,11 @@ func (thread *Thread) SetPC(pc uint64) error { } // SetSP sets the RSP register to the value specified by `pc`. -func (thread *Thread) SetSP(sp uint64) error { +func (thread *nativeThread) SetSP(sp uint64) error { return errors.New("not implemented") } -func (thread *Thread) SetDX(dx uint64) error { +func (thread *nativeThread) SetDX(dx uint64) error { return errors.New("not implemented") } @@ -285,7 +285,7 @@ func (r *Regs) Get(n int) (uint64, error) { return 0, proc.ErrUnknownRegister } -func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { +func registers(thread *nativeThread, floatingPoint bool) (proc.Registers, error) { var state C.x86_thread_state64_t var identity C.thread_identifier_info_data_t kret := C.get_registers(C.mach_port_name_t(thread.os.threadAct), &state) diff --git a/pkg/proc/native/registers_freebsd_amd64.go b/pkg/proc/native/registers_freebsd_amd64.go index 84c009df..1ee17fa4 100644 --- a/pkg/proc/native/registers_freebsd_amd64.go +++ b/pkg/proc/native/registers_freebsd_amd64.go @@ -10,7 +10,7 @@ import ( ) // SetPC sets RIP to the value specified by 'pc'. -func (thread *Thread) SetPC(pc uint64) error { +func (thread *nativeThread) SetPC(pc uint64) error { ir, err := registers(thread, false) if err != nil { return err @@ -22,7 +22,7 @@ func (thread *Thread) SetPC(pc uint64) error { } // SetSP sets RSP to the value specified by 'sp' -func (thread *Thread) SetSP(sp uint64) (err error) { +func (thread *nativeThread) SetSP(sp uint64) (err error) { var ir proc.Registers ir, err = registers(thread, false) if err != nil { @@ -34,7 +34,7 @@ func (thread *Thread) SetSP(sp uint64) (err error) { return } -func (thread *Thread) SetDX(dx uint64) (err error) { +func (thread *nativeThread) SetDX(dx uint64) (err error) { var ir proc.Registers ir, err = registers(thread, false) if err != nil { @@ -46,7 +46,7 @@ func (thread *Thread) SetDX(dx uint64) (err error) { return } -func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { +func registers(thread *nativeThread, floatingPoint bool) (proc.Registers, error) { var ( regs fbsdutil.AMD64PtraceRegs err error @@ -82,8 +82,8 @@ const ( _XSAVE_SSE_REGION_LEN = 416 ) -func (thread *Thread) fpRegisters() (regs []proc.Register, fpregs fbsdutil.AMD64Xstate, err error) { - thread.dbp.execPtraceFunc(func() { fpregs, err = PtraceGetRegset(thread.ID) }) +func (thread *nativeThread) fpRegisters() (regs []proc.Register, fpregs fbsdutil.AMD64Xstate, err error) { + thread.dbp.execPtraceFunc(func() { fpregs, err = ptraceGetRegset(thread.ID) }) if err != nil { err = fmt.Errorf("could not get floating point registers: %v", err.Error()) } diff --git a/pkg/proc/native/registers_linux_amd64.go b/pkg/proc/native/registers_linux_amd64.go index 21499701..9a1607da 100644 --- a/pkg/proc/native/registers_linux_amd64.go +++ b/pkg/proc/native/registers_linux_amd64.go @@ -10,7 +10,7 @@ import ( ) // SetPC sets RIP to the value specified by 'pc'. -func (thread *Thread) SetPC(pc uint64) error { +func (thread *nativeThread) SetPC(pc uint64) error { ir, err := registers(thread, false) if err != nil { return err @@ -22,7 +22,7 @@ func (thread *Thread) SetPC(pc uint64) error { } // SetSP sets RSP to the value specified by 'sp' -func (thread *Thread) SetSP(sp uint64) (err error) { +func (thread *nativeThread) SetSP(sp uint64) (err error) { var ir proc.Registers ir, err = registers(thread, false) if err != nil { @@ -34,7 +34,7 @@ func (thread *Thread) SetSP(sp uint64) (err error) { return } -func (thread *Thread) SetDX(dx uint64) (err error) { +func (thread *nativeThread) SetDX(dx uint64) (err error) { var ir proc.Registers ir, err = registers(thread, false) if err != nil { @@ -46,7 +46,7 @@ func (thread *Thread) SetDX(dx uint64) (err error) { return } -func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { +func registers(thread *nativeThread, floatingPoint bool) (proc.Registers, error) { var ( regs linutil.AMD64PtraceRegs err error @@ -77,8 +77,8 @@ const ( _XSAVE_SSE_REGION_LEN = 416 ) -func (thread *Thread) fpRegisters() (regs []proc.Register, fpregs linutil.AMD64Xstate, err error) { - thread.dbp.execPtraceFunc(func() { fpregs, err = PtraceGetRegset(thread.ID) }) +func (thread *nativeThread) fpRegisters() (regs []proc.Register, fpregs linutil.AMD64Xstate, err error) { + thread.dbp.execPtraceFunc(func() { fpregs, err = ptraceGetRegset(thread.ID) }) regs = fpregs.Decode() if err != nil { err = fmt.Errorf("could not get floating point registers: %v", err.Error()) diff --git a/pkg/proc/native/registers_linux_arm64.go b/pkg/proc/native/registers_linux_arm64.go index 53e9941c..7c349254 100644 --- a/pkg/proc/native/registers_linux_arm64.go +++ b/pkg/proc/native/registers_linux_arm64.go @@ -13,12 +13,12 @@ import ( ) const ( - AARCH64_GREGS_SIZE = 34 * 8 - AARCH64_FPREGS_SIZE = 32*16 + 8 + _AARCH64_GREGS_SIZE = 34 * 8 + _AARCH64_FPREGS_SIZE = 32*16 + 8 ) func ptraceGetGRegs(pid int, regs *linutil.ARM64PtraceRegs) (err error) { - iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(regs)), Len: AARCH64_GREGS_SIZE} + iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(regs)), Len: _AARCH64_GREGS_SIZE} _, _, err = syscall.Syscall6(syscall.SYS_PTRACE, sys.PTRACE_GETREGSET, uintptr(pid), uintptr(elf.NT_PRSTATUS), uintptr(unsafe.Pointer(&iov)), 0, 0) if err == syscall.Errno(0) { err = nil @@ -27,7 +27,7 @@ func ptraceGetGRegs(pid int, regs *linutil.ARM64PtraceRegs) (err error) { } func ptraceSetGRegs(pid int, regs *linutil.ARM64PtraceRegs) (err error) { - iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(regs)), Len: AARCH64_GREGS_SIZE} + iov := sys.Iovec{Base: (*byte)(unsafe.Pointer(regs)), Len: _AARCH64_GREGS_SIZE} _, _, err = syscall.Syscall6(syscall.SYS_PTRACE, sys.PTRACE_SETREGSET, uintptr(pid), uintptr(elf.NT_PRSTATUS), uintptr(unsafe.Pointer(&iov)), 0, 0) if err == syscall.Errno(0) { err = nil @@ -35,11 +35,11 @@ func ptraceSetGRegs(pid int, regs *linutil.ARM64PtraceRegs) (err error) { return } -// PtraceGetFpRegset returns floating point registers of the specified thread +// ptraceGetFpRegset returns floating point registers of the specified thread // using PTRACE. -func PtraceGetFpRegset(tid int) (fpregset []byte, err error) { - var arm64_fpregs [AARCH64_FPREGS_SIZE]byte - iov := sys.Iovec{Base: &arm64_fpregs[0], Len: AARCH64_FPREGS_SIZE} +func ptraceGetFpRegset(tid int) (fpregset []byte, err error) { + var arm64_fpregs [_AARCH64_FPREGS_SIZE]byte + iov := sys.Iovec{Base: &arm64_fpregs[0], Len: _AARCH64_FPREGS_SIZE} _, _, err = syscall.Syscall6(syscall.SYS_PTRACE, sys.PTRACE_GETREGSET, uintptr(tid), uintptr(elf.NT_FPREGSET), uintptr(unsafe.Pointer(&iov)), 0, 0) if err != syscall.Errno(0) { if err == syscall.ENODEV { @@ -55,7 +55,7 @@ func PtraceGetFpRegset(tid int) (fpregset []byte, err error) { } // SetPC sets PC to the value specified by 'pc'. -func (thread *Thread) SetPC(pc uint64) error { +func (thread *nativeThread) SetPC(pc uint64) error { ir, err := registers(thread, false) if err != nil { return err @@ -67,7 +67,7 @@ func (thread *Thread) SetPC(pc uint64) error { } // SetSP sets RSP to the value specified by 'sp' -func (thread *Thread) SetSP(sp uint64) (err error) { +func (thread *nativeThread) SetSP(sp uint64) (err error) { var ir proc.Registers ir, err = registers(thread, false) if err != nil { @@ -79,11 +79,11 @@ func (thread *Thread) SetSP(sp uint64) (err error) { return } -func (thread *Thread) SetDX(dx uint64) (err error) { +func (thread *nativeThread) SetDX(dx uint64) (err error) { return fmt.Errorf("not supported") } -func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { +func registers(thread *nativeThread, floatingPoint bool) (proc.Registers, error) { var ( regs linutil.ARM64PtraceRegs err error diff --git a/pkg/proc/native/registers_windows_amd64.go b/pkg/proc/native/registers_windows_amd64.go index 32a56e8b..cc702269 100644 --- a/pkg/proc/native/registers_windows_amd64.go +++ b/pkg/proc/native/registers_windows_amd64.go @@ -9,7 +9,7 @@ import ( ) // SetPC sets the RIP register to the value specified by `pc`. -func (thread *Thread) SetPC(pc uint64) error { +func (thread *nativeThread) SetPC(pc uint64) error { context := winutil.NewCONTEXT() context.ContextFlags = _CONTEXT_ALL @@ -24,7 +24,7 @@ func (thread *Thread) SetPC(pc uint64) error { } // SetSP sets the RSP register to the value specified by `sp`. -func (thread *Thread) SetSP(sp uint64) error { +func (thread *nativeThread) SetSP(sp uint64) error { context := winutil.NewCONTEXT() context.ContextFlags = _CONTEXT_ALL @@ -38,7 +38,7 @@ func (thread *Thread) SetSP(sp uint64) error { return _SetThreadContext(thread.os.hThread, context) } -func (thread *Thread) SetDX(dx uint64) error { +func (thread *nativeThread) SetDX(dx uint64) error { context := winutil.NewCONTEXT() context.ContextFlags = _CONTEXT_ALL @@ -52,7 +52,7 @@ func (thread *Thread) SetDX(dx uint64) error { return _SetThreadContext(thread.os.hThread, context) } -func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) { +func registers(thread *nativeThread, floatingPoint bool) (proc.Registers, error) { context := winutil.NewCONTEXT() context.ContextFlags = _CONTEXT_ALL diff --git a/pkg/proc/native/threads.go b/pkg/proc/native/threads.go index 352e2d5a..daf5d4f6 100644 --- a/pkg/proc/native/threads.go +++ b/pkg/proc/native/threads.go @@ -11,14 +11,14 @@ import ( // Process struct that contains info on the process as // a whole, and Status represents the last result of a `wait` call // on this thread. -type Thread struct { +type nativeThread struct { ID int // Thread ID or mach port - Status *WaitStatus // Status returned from last wait call + Status *waitStatus // Status returned from last wait call CurrentBreakpoint proc.BreakpointState // Breakpoint thread is currently stopped at - dbp *Process + dbp *nativeProcess singleStepping bool - os *OSSpecificDetails + os *osSpecificDetails common proc.CommonThread } @@ -27,7 +27,7 @@ type Thread struct { // If we are currently at a breakpoint, we'll clear it // first and then resume execution. Thread will continue until // it hits a breakpoint or is signaled. -func (t *Thread) Continue() error { +func (t *nativeThread) Continue() error { pc, err := t.PC() if err != nil { return err @@ -48,7 +48,7 @@ func (t *Thread) Continue() error { // If the thread is at a breakpoint, we first clear it, // execute the instruction, and then replace the breakpoint. // Otherwise we simply execute the next instruction. -func (t *Thread) StepInstruction() (err error) { +func (t *nativeThread) StepInstruction() (err error) { t.singleStepping = true defer func() { t.singleStepping = false @@ -85,7 +85,7 @@ func (t *Thread) StepInstruction() (err error) { // Location returns the threads location, including the file:line // of the corresponding source code, the function we're in // and the current instruction address. -func (t *Thread) Location() (*proc.Location, error) { +func (t *nativeThread) Location() (*proc.Location, error) { pc, err := t.PC() if err != nil { return nil, err @@ -95,19 +95,19 @@ func (t *Thread) Location() (*proc.Location, error) { } // BinInfo returns information on the binary. -func (t *Thread) BinInfo() *proc.BinaryInfo { +func (t *nativeThread) BinInfo() *proc.BinaryInfo { return t.dbp.bi } // Common returns information common across Process // implementations. -func (t *Thread) Common() *proc.CommonThread { +func (t *nativeThread) Common() *proc.CommonThread { return &t.common } // SetCurrentBreakpoint sets the current breakpoint that this // thread is stopped at as CurrentBreakpoint on the thread struct. -func (t *Thread) SetCurrentBreakpoint(adjustPC bool) error { +func (t *nativeThread) SetCurrentBreakpoint(adjustPC bool) error { t.CurrentBreakpoint.Clear() pc, err := t.PC() if err != nil { @@ -139,17 +139,17 @@ func (t *Thread) SetCurrentBreakpoint(adjustPC bool) error { // Breakpoint returns the current breakpoint that is active // on this thread. -func (t *Thread) Breakpoint() *proc.BreakpointState { +func (t *nativeThread) Breakpoint() *proc.BreakpointState { return &t.CurrentBreakpoint } // ThreadID returns the ID of this thread. -func (t *Thread) ThreadID() int { +func (t *nativeThread) ThreadID() int { return t.ID } // ClearBreakpoint clears the specified breakpoint. -func (t *Thread) ClearBreakpoint(bp *proc.Breakpoint) error { +func (t *nativeThread) ClearBreakpoint(bp *proc.Breakpoint) error { if _, err := t.WriteMemory(uintptr(bp.Addr), bp.OriginalData); err != nil { return fmt.Errorf("could not clear breakpoint %s", err) } @@ -157,18 +157,18 @@ func (t *Thread) ClearBreakpoint(bp *proc.Breakpoint) error { } // Registers obtains register values from the debugged process. -func (t *Thread) Registers(floatingPoint bool) (proc.Registers, error) { +func (t *nativeThread) Registers(floatingPoint bool) (proc.Registers, error) { return registers(t, floatingPoint) } // RestoreRegisters will set the value of the CPU registers to those // passed in via 'savedRegs'. -func (t *Thread) RestoreRegisters(savedRegs proc.Registers) error { +func (t *nativeThread) RestoreRegisters(savedRegs proc.Registers) error { return t.restoreRegisters(savedRegs) } // PC returns the current program counter value for this thread. -func (t *Thread) PC() (uint64, error) { +func (t *nativeThread) PC() (uint64, error) { regs, err := t.Registers(false) if err != nil { return 0, err diff --git a/pkg/proc/native/threads_darwin.go b/pkg/proc/native/threads_darwin.go index 9aeea20e..68fe01da 100644 --- a/pkg/proc/native/threads_darwin.go +++ b/pkg/proc/native/threads_darwin.go @@ -15,12 +15,12 @@ import ( "github.com/go-delve/delve/pkg/proc" ) -// WaitStatus is a synonym for the platform-specific WaitStatus -type WaitStatus sys.WaitStatus +// waitStatus is a synonym for the platform-specific WaitStatus +type waitStatus sys.WaitStatus -// OSSpecificDetails holds information specific to the OSX/Darwin +// osSpecificDetails holds information specific to the OSX/Darwin // operating system / kernel. -type OSSpecificDetails struct { +type osSpecificDetails struct { threadAct C.thread_act_t registers C.x86_thread_state64_t exists bool @@ -30,7 +30,7 @@ type OSSpecificDetails struct { // be continued. var ErrContinueThread = fmt.Errorf("could not continue thread") -func (t *Thread) stop() (err error) { +func (t *nativeThread) stop() (err error) { kret := C.thread_suspend(t.os.threadAct) if kret != C.KERN_SUCCESS { errStr := C.GoString(C.mach_error_string(C.mach_error_t(kret))) @@ -49,7 +49,7 @@ func (t *Thread) stop() (err error) { return } -func (t *Thread) singleStep() error { +func (t *nativeThread) singleStep() error { kret := C.single_step(t.os.threadAct) if kret != C.KERN_SUCCESS { return fmt.Errorf("could not single step") @@ -71,10 +71,10 @@ func (t *Thread) singleStep() error { return nil } -func (t *Thread) resume() error { +func (t *nativeThread) resume() error { // TODO(dp) set flag for ptrace stops var err error - t.dbp.execPtraceFunc(func() { err = PtraceCont(t.dbp.pid, 0) }) + t.dbp.execPtraceFunc(func() { err = ptraceCont(t.dbp.pid, 0) }) if err == nil { return nil } @@ -85,7 +85,7 @@ func (t *Thread) resume() error { return nil } -func (t *Thread) Blocked() bool { +func (t *nativeThread) Blocked() bool { // TODO(dp) cache the func pc to remove this lookup regs, err := t.Registers(false) if err != nil { @@ -106,11 +106,11 @@ func (t *Thread) Blocked() bool { // Stopped returns whether the thread is stopped at // the operating system level. -func (t *Thread) Stopped() bool { +func (t *nativeThread) Stopped() bool { return C.thread_blocked(t.os.threadAct) > C.int(0) } -func (t *Thread) WriteMemory(addr uintptr, data []byte) (int, error) { +func (t *nativeThread) WriteMemory(addr uintptr, data []byte) (int, error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } @@ -128,7 +128,7 @@ func (t *Thread) WriteMemory(addr uintptr, data []byte) (int, error) { return len(data), nil } -func (t *Thread) ReadMemory(buf []byte, addr uintptr) (int, error) { +func (t *nativeThread) ReadMemory(buf []byte, addr uintptr) (int, error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } @@ -148,6 +148,6 @@ func (t *Thread) ReadMemory(buf []byte, addr uintptr) (int, error) { return len(buf), nil } -func (t *Thread) restoreRegisters(sr proc.Registers) error { +func (t *nativeThread) restoreRegisters(sr proc.Registers) error { return errors.New("not implemented") } diff --git a/pkg/proc/native/threads_freebsd.go b/pkg/proc/native/threads_freebsd.go index 22880d12..2c569f6c 100644 --- a/pkg/proc/native/threads_freebsd.go +++ b/pkg/proc/native/threads_freebsd.go @@ -13,14 +13,14 @@ import ( "github.com/go-delve/delve/pkg/proc" ) -type WaitStatus sys.WaitStatus +type waitStatus sys.WaitStatus -// OSSpecificDetails hold FreeBSD specific process details. -type OSSpecificDetails struct { +// osSpecificDetails hold FreeBSD specific process details. +type osSpecificDetails struct { registers sys.Reg } -func (t *Thread) stop() (err error) { +func (t *nativeThread) stop() (err error) { _, err = C.thr_kill2(C.pid_t(t.dbp.pid), C.long(t.ID), C.int(sys.SIGSTOP)) if err != nil { err = fmt.Errorf("stop err %s on thread %d", err, t.ID) @@ -28,7 +28,7 @@ func (t *Thread) stop() (err error) { } // If the process is stopped, we must continue it so it can receive the // signal - t.dbp.execPtraceFunc(func() { err = PtraceCont(t.dbp.pid, 0) }) + t.dbp.execPtraceFunc(func() { err = ptraceCont(t.dbp.pid, 0) }) if err != nil { return err } @@ -40,22 +40,22 @@ func (t *Thread) stop() (err error) { return } -func (t *Thread) Stopped() bool { +func (t *nativeThread) Stopped() bool { state := status(t.dbp.pid) - return state == StatusStopped + return state == statusStopped } -func (t *Thread) resume() error { +func (t *nativeThread) resume() error { return t.resumeWithSig(0) } -func (t *Thread) resumeWithSig(sig int) (err error) { - t.dbp.execPtraceFunc(func() { err = PtraceCont(t.ID, sig) }) +func (t *nativeThread) resumeWithSig(sig int) (err error) { + t.dbp.execPtraceFunc(func() { err = ptraceCont(t.ID, sig) }) return } -func (t *Thread) singleStep() (err error) { - t.dbp.execPtraceFunc(func() { err = PtraceSingleStep(t.ID) }) +func (t *nativeThread) singleStep() (err error) { + t.dbp.execPtraceFunc(func() { err = ptraceSingleStep(t.ID) }) if err != nil { return err } @@ -67,7 +67,7 @@ func (t *Thread) singleStep() (err error) { if th.ID == t.ID { break } - t.dbp.execPtraceFunc(func() { err = PtraceCont(th.ID, 0) }) + t.dbp.execPtraceFunc(func() { err = ptraceCont(th.ID, 0) }) if err != nil { return err } @@ -75,7 +75,7 @@ func (t *Thread) singleStep() (err error) { return nil } -func (t *Thread) Blocked() bool { +func (t *nativeThread) Blocked() bool { loc, err := t.Location() if err != nil { return false @@ -86,7 +86,7 @@ func (t *Thread) Blocked() bool { return false } -func (t *Thread) restoreRegisters(savedRegs proc.Registers) error { +func (t *nativeThread) restoreRegisters(savedRegs proc.Registers) error { sr := savedRegs.(*fbsdutil.AMD64Registers) var restoreRegistersErr error @@ -110,7 +110,7 @@ func (t *Thread) restoreRegisters(savedRegs proc.Registers) error { return restoreRegistersErr } -func (t *Thread) WriteMemory(addr uintptr, data []byte) (written int, err error) { +func (t *nativeThread) WriteMemory(addr uintptr, data []byte) (written int, err error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } @@ -121,7 +121,7 @@ func (t *Thread) WriteMemory(addr uintptr, data []byte) (written int, err error) return written, err } -func (t *Thread) ReadMemory(data []byte, addr uintptr) (n int, err error) { +func (t *nativeThread) ReadMemory(data []byte, addr uintptr) (n int, err error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } diff --git a/pkg/proc/native/threads_linux.go b/pkg/proc/native/threads_linux.go index b2431256..20c62fe4 100644 --- a/pkg/proc/native/threads_linux.go +++ b/pkg/proc/native/threads_linux.go @@ -8,18 +8,18 @@ import ( "github.com/go-delve/delve/pkg/proc" ) -type WaitStatus sys.WaitStatus +type waitStatus sys.WaitStatus -// OSSpecificDetails hold Linux specific +// osSpecificDetails hold Linux specific // process details. -type OSSpecificDetails struct { +type osSpecificDetails struct { delayedSignal int registers sys.PtraceRegs running bool setbp bool } -func (t *Thread) stop() (err error) { +func (t *nativeThread) stop() (err error) { err = sys.Tgkill(t.dbp.pid, t.ID, sys.SIGSTOP) if err != nil { err = fmt.Errorf("stop err %s on thread %d", err, t.ID) @@ -30,24 +30,24 @@ func (t *Thread) stop() (err error) { // Stopped returns whether the thread is stopped at // the operating system level. -func (t *Thread) Stopped() bool { +func (t *nativeThread) Stopped() bool { state := status(t.ID, t.dbp.os.comm) - return state == StatusTraceStop || state == StatusTraceStopT + return state == statusTraceStop || state == statusTraceStopT } -func (t *Thread) resume() error { +func (t *nativeThread) resume() error { sig := t.os.delayedSignal t.os.delayedSignal = 0 return t.resumeWithSig(sig) } -func (t *Thread) resumeWithSig(sig int) (err error) { +func (t *nativeThread) resumeWithSig(sig int) (err error) { t.os.running = true - t.dbp.execPtraceFunc(func() { err = PtraceCont(t.ID, sig) }) + t.dbp.execPtraceFunc(func() { err = ptraceCont(t.ID, sig) }) return } -func (t *Thread) singleStep() (err error) { +func (t *nativeThread) singleStep() (err error) { for { t.dbp.execPtraceFunc(func() { err = sys.PtraceSingleStep(t.ID) }) if err != nil { @@ -71,7 +71,7 @@ func (t *Thread) singleStep() (err error) { } } -func (t *Thread) Blocked() bool { +func (t *nativeThread) Blocked() bool { regs, err := t.Registers(false) if err != nil { return false @@ -84,7 +84,7 @@ func (t *Thread) Blocked() bool { return false } -func (t *Thread) WriteMemory(addr uintptr, data []byte) (written int, err error) { +func (t *nativeThread) WriteMemory(addr uintptr, data []byte) (written int, err error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } @@ -94,7 +94,7 @@ func (t *Thread) WriteMemory(addr uintptr, data []byte) (written int, err error) // ProcessVmWrite can't poke read-only memory like ptrace, so don't // even bother for small writes -- likely breakpoints and such. if len(data) > sys.SizeofPtr { - written, _ = ProcessVmWrite(t.ID, addr, data) + written, _ = processVmWrite(t.ID, addr, data) } if written == 0 { t.dbp.execPtraceFunc(func() { written, err = sys.PtracePokeData(t.ID, addr, data) }) @@ -102,14 +102,14 @@ func (t *Thread) WriteMemory(addr uintptr, data []byte) (written int, err error) return } -func (t *Thread) ReadMemory(data []byte, addr uintptr) (n int, err error) { +func (t *nativeThread) ReadMemory(data []byte, addr uintptr) (n int, err error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } if len(data) == 0 { return } - n, _ = ProcessVmRead(t.ID, addr, data) + n, _ = processVmRead(t.ID, addr, data) if n == 0 { t.dbp.execPtraceFunc(func() { n, err = sys.PtracePeekData(t.ID, addr, data) }) } diff --git a/pkg/proc/native/threads_linux_386.go b/pkg/proc/native/threads_linux_386.go index 02e2972f..338a166b 100644 --- a/pkg/proc/native/threads_linux_386.go +++ b/pkg/proc/native/threads_linux_386.go @@ -5,6 +5,6 @@ import ( "github.com/go-delve/delve/pkg/proc" ) -func (t *Thread) restoreRegisters(savedRegs proc.Registers) error { +func (t *nativeThread) restoreRegisters(savedRegs proc.Registers) error { return fmt.Errorf("restore regs not supported on i386") } diff --git a/pkg/proc/native/threads_linux_amd64.go b/pkg/proc/native/threads_linux_amd64.go index b02cac15..049195ad 100644 --- a/pkg/proc/native/threads_linux_amd64.go +++ b/pkg/proc/native/threads_linux_amd64.go @@ -10,7 +10,7 @@ import ( "github.com/go-delve/delve/pkg/proc/linutil" ) -func (t *Thread) restoreRegisters(savedRegs proc.Registers) error { +func (t *nativeThread) restoreRegisters(savedRegs proc.Registers) error { sr := savedRegs.(*linutil.AMD64Registers) var restoreRegistersErr error diff --git a/pkg/proc/native/threads_linux_arm64.go b/pkg/proc/native/threads_linux_arm64.go index 417c8dcb..f2f4d290 100644 --- a/pkg/proc/native/threads_linux_arm64.go +++ b/pkg/proc/native/threads_linux_arm64.go @@ -12,10 +12,10 @@ import ( "github.com/go-delve/delve/pkg/proc/linutil" ) -func (thread *Thread) fpRegisters() ([]proc.Register, []byte, error) { +func (thread *nativeThread) fpRegisters() ([]proc.Register, []byte, error) { var err error var arm_fpregs linutil.ARM64PtraceFpRegs - thread.dbp.execPtraceFunc(func() { arm_fpregs.Vregs, err = PtraceGetFpRegset(thread.ID) }) + thread.dbp.execPtraceFunc(func() { arm_fpregs.Vregs, err = ptraceGetFpRegset(thread.ID) }) fpregs := arm_fpregs.Decode() if err != nil { err = fmt.Errorf("could not get floating point registers: %v", err.Error()) @@ -23,7 +23,7 @@ func (thread *Thread) fpRegisters() ([]proc.Register, []byte, error) { return fpregs, arm_fpregs.Vregs, err } -func (t *Thread) restoreRegisters(savedRegs proc.Registers) error { +func (t *nativeThread) restoreRegisters(savedRegs proc.Registers) error { sr := savedRegs.(*linutil.ARM64Registers) var restoreRegistersErr error diff --git a/pkg/proc/native/threads_windows.go b/pkg/proc/native/threads_windows.go index 2d465f8e..9c729a66 100644 --- a/pkg/proc/native/threads_windows.go +++ b/pkg/proc/native/threads_windows.go @@ -10,16 +10,16 @@ import ( "github.com/go-delve/delve/pkg/proc/winutil" ) -// WaitStatus is a synonym for the platform-specific WaitStatus -type WaitStatus sys.WaitStatus +// waitStatus is a synonym for the platform-specific WaitStatus +type waitStatus sys.WaitStatus -// OSSpecificDetails holds information specific to the Windows +// osSpecificDetails holds information specific to the Windows // operating system / kernel. -type OSSpecificDetails struct { +type osSpecificDetails struct { hThread syscall.Handle } -func (t *Thread) singleStep() error { +func (t *nativeThread) singleStep() error { context := winutil.NewCONTEXT() context.ContextFlags = _CONTEXT_ALL @@ -101,7 +101,7 @@ func (t *Thread) singleStep() error { return _SetThreadContext(t.os.hThread, context) } -func (t *Thread) resume() error { +func (t *nativeThread) resume() error { var err error t.dbp.execPtraceFunc(func() { //TODO: Note that we are ignoring the thread we were asked to continue and are continuing the @@ -111,7 +111,7 @@ func (t *Thread) resume() error { return err } -func (t *Thread) Blocked() bool { +func (t *nativeThread) Blocked() bool { // TODO: Probably incorrect - what are the runtime functions that // indicate blocking on Windows? regs, err := t.Registers(false) @@ -133,11 +133,11 @@ func (t *Thread) Blocked() bool { // Stopped returns whether the thread is stopped at the operating system // level. On windows this always returns true. -func (t *Thread) Stopped() bool { +func (t *nativeThread) Stopped() bool { return true } -func (t *Thread) WriteMemory(addr uintptr, data []byte) (int, error) { +func (t *nativeThread) WriteMemory(addr uintptr, data []byte) (int, error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } @@ -154,7 +154,7 @@ func (t *Thread) WriteMemory(addr uintptr, data []byte) (int, error) { var ErrShortRead = errors.New("short read") -func (t *Thread) ReadMemory(buf []byte, addr uintptr) (int, error) { +func (t *nativeThread) ReadMemory(buf []byte, addr uintptr) (int, error) { if t.dbp.exited { return 0, proc.ErrProcessExited{Pid: t.dbp.pid} } @@ -169,6 +169,6 @@ func (t *Thread) ReadMemory(buf []byte, addr uintptr) (int, error) { return int(count), err } -func (t *Thread) restoreRegisters(savedRegs proc.Registers) error { +func (t *nativeThread) restoreRegisters(savedRegs proc.Registers) error { return _SetThreadContext(t.os.hThread, savedRegs.(*winutil.AMD64Registers).Context) } diff --git a/pkg/proc/proc_test.go b/pkg/proc/proc_test.go index 501fceae..562e7731 100644 --- a/pkg/proc/proc_test.go +++ b/pkg/proc/proc_test.go @@ -239,12 +239,6 @@ func TestHalt(t *testing.T) { withTestProcess("loopprog", t, func(p *proc.Target, fixture protest.Fixture) { setFunctionBreakpoint(p, t, "main.loop") assertNoError(p.Continue(), t, "Continue") - if p, ok := p.Process.(*native.Process); ok { - for _, th := range p.ThreadList() { - _, err := th.Registers(false) - assertNoError(err, t, "Registers") - } - } resumeChan := make(chan struct{}, 1) go func() { <-resumeChan @@ -258,21 +252,6 @@ func TestHalt(t *testing.T) { if err, ok := retVal.(error); ok && err != nil { t.Fatal() } - - // Loop through threads and make sure they are all - // actually stopped, err will not be nil if the process - // is still running. - if p, ok := p.Process.(*native.Process); ok { - for _, th := range p.ThreadList() { - if th, ok := th.(*native.Thread); ok { - if !th.Stopped() { - t.Fatal("expected thread to be stopped, but was not") - } - } - _, err := th.Registers(false) - assertNoError(err, t, "Registers") - } - } }) } diff --git a/pkg/proc/test/support.go b/pkg/proc/test/support.go index da56f254..3a5ef5ce 100644 --- a/pkg/proc/test/support.go +++ b/pkg/proc/test/support.go @@ -35,13 +35,13 @@ type Fixture struct { } // FixtureKey holds the name and builds flags used for a test fixture. -type FixtureKey struct { +type fixtureKey struct { Name string Flags BuildFlags } // Fixtures is a map of fixtureKey{ Fixture.Name, buildFlags } to Fixture. -var Fixtures = make(map[FixtureKey]Fixture) +var fixtures = make(map[fixtureKey]Fixture) // PathsToRemove is a list of files and directories to remove after running all the tests var PathsToRemove []string @@ -84,8 +84,8 @@ func BuildFixture(name string, flags BuildFlags) Fixture { if !runningWithFixtures { panic("RunTestsWithFixtures not called") } - fk := FixtureKey{name, flags} - if f, ok := Fixtures[fk]; ok { + fk := fixtureKey{name, flags} + if f, ok := fixtures[fk]; ok { return f } @@ -180,8 +180,8 @@ func BuildFixture(name string, flags BuildFlags) Fixture { fixture := Fixture{Name: name, Path: tmpfile, Source: source, BuildDir: absdir} - Fixtures[fk] = fixture - return Fixtures[fk] + fixtures[fk] = fixture + return fixtures[fk] } // RunTestsWithFixtures will pre-compile test fixtures before running test @@ -194,7 +194,7 @@ func RunTestsWithFixtures(m *testing.M) int { status := m.Run() // Remove the fixtures. - for _, f := range Fixtures { + for _, f := range fixtures { os.Remove(f.Path) } diff --git a/pkg/terminal/command.go b/pkg/terminal/command.go index 6030959a..41ca1caa 100644 --- a/pkg/terminal/command.go +++ b/pkg/terminal/command.go @@ -85,23 +85,23 @@ type Commands struct { } var ( - // LongLoadConfig loads more information: + // longLoadConfig loads more information: // * Follows pointers // * Loads more array values // * Does not limit struct fields - LongLoadConfig = api.LoadConfig{FollowPointers: true, MaxVariableRecurse: 1, MaxStringLen: 64, MaxArrayValues: 64, MaxStructFields: -1} + longLoadConfig = api.LoadConfig{FollowPointers: true, MaxVariableRecurse: 1, MaxStringLen: 64, MaxArrayValues: 64, MaxStructFields: -1} // ShortLoadConfig loads less information, not following pointers // and limiting struct fields loaded to 3. ShortLoadConfig = api.LoadConfig{MaxStringLen: 64, MaxStructFields: 3} ) -// ByFirstAlias will sort by the first +// byFirstAlias will sort by the first // alias of a command. -type ByFirstAlias []command +type byFirstAlias []command -func (a ByFirstAlias) Len() int { return len(a) } -func (a ByFirstAlias) Swap(i, j int) { a[i], a[j] = a[j], a[i] } -func (a ByFirstAlias) Less(i, j int) bool { return a[i].aliases[0] < a[j].aliases[0] } +func (a byFirstAlias) Len() int { return len(a) } +func (a byFirstAlias) Swap(i, j int) { a[i], a[j] = a[j], a[i] } +func (a byFirstAlias) Less(i, j int) bool { return a[i].aliases[0] < a[j].aliases[0] } // DebugCommands returns a Commands struct with default commands defined. func DebugCommands(client service.Client) *Commands { @@ -443,7 +443,7 @@ Currently, only the rev step-instruction command is supported.`, }) } - sort.Sort(ByFirstAlias(c.cmds)) + sort.Sort(byFirstAlias(c.cmds)) return c } @@ -592,7 +592,7 @@ func threads(t *Term, ctx callContext, args string) error { } if th.Function != nil { fmt.Printf("%sThread %d at %#v %s:%d %s\n", - prefix, th.ID, th.PC, ShortenFilePath(th.File), + prefix, th.ID, th.PC, shortenFilePath(th.File), th.Line, th.Function.Name()) } else { fmt.Printf("%sThread %s\n", prefix, formatThread(th)) @@ -825,7 +825,7 @@ func (c *Commands) frameCommand(t *Term, ctx callContext, argstr string, directi } printcontext(t, state) th := stack[frame] - fmt.Printf("Frame %d: %s:%d (PC: %x)\n", frame, ShortenFilePath(th.File), th.Line, th.PC) + fmt.Printf("Frame %d: %s:%d (PC: %x)\n", frame, shortenFilePath(th.File), th.Line, th.PC) printfile(t, th.File, th.Line, true) return nil } @@ -863,7 +863,7 @@ func formatThread(th *api.Thread) string { if th == nil { return "" } - return fmt.Sprintf("%d at %s:%d", th.ID, ShortenFilePath(th.File), th.Line) + return fmt.Sprintf("%d at %s:%d", th.ID, shortenFilePath(th.File), th.Line) } type formatGoroutineLoc int @@ -876,7 +876,7 @@ const ( ) func formatLocation(loc api.Location) string { - return fmt.Sprintf("%s:%d %s (%#v)", ShortenFilePath(loc.File), loc.Line, loc.Function.Name(), loc.PC) + return fmt.Sprintf("%s:%d %s (%#v)", shortenFilePath(loc.File), loc.Line, loc.Function.Name(), loc.PC) } func formatGoroutine(g *api.Goroutine, fgl formatGoroutineLoc) string { @@ -1325,19 +1325,19 @@ func clearAll(t *Term, ctx callContext, args string) error { return nil } -// ByID sorts breakpoints by ID. -type ByID []*api.Breakpoint +// byID sorts breakpoints by ID. +type byID []*api.Breakpoint -func (a ByID) Len() int { return len(a) } -func (a ByID) Swap(i, j int) { a[i], a[j] = a[j], a[i] } -func (a ByID) Less(i, j int) bool { return a[i].ID < a[j].ID } +func (a byID) Len() int { return len(a) } +func (a byID) Swap(i, j int) { a[i], a[j] = a[j], a[i] } +func (a byID) Less(i, j int) bool { return a[i].ID < a[j].ID } func breakpoints(t *Term, ctx callContext, args string) error { breakPoints, err := t.client.ListBreakpoints() if err != nil { return err } - sort.Sort(ByID(breakPoints)) + sort.Sort(byID(breakPoints)) for _, bp := range breakPoints { fmt.Printf("%s at %v (%d)\n", formatBreakpointName(bp, true), formatBreakpointLocation(bp), bp.TotalHitCount) @@ -1352,14 +1352,14 @@ func breakpoints(t *Term, ctx callContext, args string) error { attrs = append(attrs, "\tgoroutine") } if bp.LoadArgs != nil { - if *(bp.LoadArgs) == LongLoadConfig { + if *(bp.LoadArgs) == longLoadConfig { attrs = append(attrs, "\targs -v") } else { attrs = append(attrs, "\targs") } } if bp.LoadLocals != nil { - if *(bp.LoadLocals) == LongLoadConfig { + if *(bp.LoadLocals) == longLoadConfig { attrs = append(attrs, "\tlocals -v") } else { attrs = append(attrs, "\tlocals") @@ -1955,7 +1955,7 @@ func disassCommand(t *Term, ctx callContext, args string) error { return disasmErr } - DisasmPrint(disasm, os.Stdout) + disasmPrint(disasm, os.Stdout) return nil } @@ -2004,7 +2004,7 @@ func printStack(stack []api.Stackframe, ind string, offsets bool) { continue } fmt.Printf(fmtstr, ind, i, stack[i].PC, stack[i].Function.Name()) - fmt.Printf("%sat %s:%d\n", s, ShortenFilePath(stack[i].File), stack[i].Line) + fmt.Printf("%sat %s:%d\n", s, shortenFilePath(stack[i].File), stack[i].Line) if offsets { fmt.Printf("%sframe: %+#x frame pointer %+#x\n", s, stack[i].FrameOffset, stack[i].FramePointerOffset) @@ -2084,7 +2084,7 @@ func printcontext(t *Term, state *api.DebuggerState) { } func printcontextLocation(loc api.Location) { - fmt.Printf("> %s() %s:%d (PC: %#v)\n", loc.Function.Name(), ShortenFilePath(loc.File), loc.Line, loc.PC) + fmt.Printf("> %s() %s:%d (PC: %#v)\n", loc.Function.Name(), shortenFilePath(loc.File), loc.Line, loc.PC) if loc.Function != nil && loc.Function.Optimized { fmt.Println(optimizedFunctionWarning) } @@ -2137,7 +2137,7 @@ func printcontextThread(t *Term, th *api.Thread) { bpname, fn.Name(), args, - ShortenFilePath(th.File), + shortenFilePath(th.File), th.Line, th.GoroutineID, hitCount, @@ -2148,7 +2148,7 @@ func printcontextThread(t *Term, th *api.Thread) { bpname, fn.Name(), args, - ShortenFilePath(th.File), + shortenFilePath(th.File), th.Line, th.Breakpoint.TotalHitCount, th.PC) @@ -2172,14 +2172,14 @@ func printcontextThread(t *Term, th *api.Thread) { } for _, v := range bpi.Locals { - if *bp.LoadLocals == LongLoadConfig { + if *bp.LoadLocals == longLoadConfig { fmt.Printf("\t%s: %s\n", v.Name, v.MultilineString("\t")) } else { fmt.Printf("\t%s: %s\n", v.Name, v.SinglelineString()) } } - if bp.LoadArgs != nil && *bp.LoadArgs == LongLoadConfig { + if bp.LoadArgs != nil && *bp.LoadArgs == longLoadConfig { for _, v := range bpi.Arguments { fmt.Printf("\t%s: %s\n", v.Name, v.MultilineString("\t")) } @@ -2302,9 +2302,9 @@ func conditionCmd(t *Term, ctx callContext, argstr string) error { return t.client.AmendBreakpoint(bp) } -// ShortenFilePath take a full file path and attempts to shorten +// shortenFilePath take a full file path and attempts to shorten // it by replacing the current directory to './'. -func ShortenFilePath(fullPath string) string { +func shortenFilePath(fullPath string) string { workingDir, _ := os.Getwd() return strings.Replace(fullPath, workingDir, ".", 1) } @@ -2463,7 +2463,7 @@ func formatBreakpointLocation(bp *api.Breakpoint) string { fmt.Fprintf(&out, "%#x", bp.Addr) } fmt.Fprintf(&out, " for ") - p := ShortenFilePath(bp.File) + p := shortenFilePath(bp.File) if bp.FunctionName != "" { fmt.Fprintf(&out, "%s() ", bp.FunctionName) } diff --git a/pkg/terminal/disasmprint.go b/pkg/terminal/disasmprint.go index d6015ff3..8e4209b7 100644 --- a/pkg/terminal/disasmprint.go +++ b/pkg/terminal/disasmprint.go @@ -10,7 +10,7 @@ import ( "github.com/go-delve/delve/service/api" ) -func DisasmPrint(dv api.AsmInstructions, out io.Writer) { +func disasmPrint(dv api.AsmInstructions, out io.Writer) { bw := bufio.NewWriter(out) defer bw.Flush() if len(dv) > 0 && dv[0].Loc.Function != nil { -- GitLab