Skip to content

G
golang
Commit ffe83e58 authored by Austin Clements's avatar Austin Clements
Browse files
Options

Switch ogle over to the in-tree debug/proc package. Fix 

debug/proc to install to the right place.  Delete the old
ptrace package.  The diff looks huge, but it's mostly
s/ptrace/proc/.

R=rsc
APPROVED=rsc
DELTA=1940  (10 added, 1835 deleted, 95 changed)
OCL=34966
CL=34968
parent 495b3db8
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 100 additions and 626 deletions
src/pkg/debug/proc/Makefile
View file @ ffe83e58
......@@ -4,7 +4,7 @@
include $(GOROOT)/src/Make.$(GOARCH)
TARG=ptrace
TARG=debug/proc
GOFILES=\
proc.go\
proc_$(GOOS).go\
......
usr/austin/ogle/arch.go
View file @ ffe83e58
......@@ -5,17 +5,17 @@
package ogle
import (
"debug/proc";
"math";
"ptrace";
)
type Arch interface {
// ToWord converts an array of up to 8 bytes in memory order
// to a word.
ToWord(data []byte) ptrace.Word;
ToWord(data []byte) proc.Word;
// FromWord converts a word to an array of up to 8 bytes in
// memory order.
FromWord(v ptrace.Word, out []byte);
FromWord(v proc.Word, out []byte);
// ToFloat32 converts a word to a float. The order of this
// word will be the order returned by ToWord on the memory
// representation of a float, and thus may require reversing.
......@@ -40,7 +40,7 @@ type Arch interface {
Align(offset, width int) int;
// G returns the current G pointer.
G(regs ptrace.Regs) ptrace.Word;
G(regs proc.Regs) proc.Word;
// ClosureSize returns the number of bytes expected by
// ParseClosure.
......@@ -53,15 +53,15 @@ type Arch interface {
type ArchLSB struct {}
func (ArchLSB) ToWord(data []byte) ptrace.Word {
var v ptrace.Word;
func (ArchLSB) ToWord(data []byte) proc.Word {
var v proc.Word;
for i, b := range data {
v |= ptrace.Word(b) << (uint(i)*8);
v |= proc.Word(b) << (uint(i)*8);
}
return v;
}
func (ArchLSB) FromWord(v ptrace.Word, out []byte) {
func (ArchLSB) FromWord(v proc.Word, out []byte) {
for i := range out {
out[i] = byte(v);
v >>= 8;
......@@ -110,7 +110,7 @@ func (a *amd64) FloatSize() int {
return 4;
}
func (a *amd64) G(regs ptrace.Regs) ptrace.Word {
func (a *amd64) G(regs proc.Regs) proc.Word {
// See src/pkg/runtime/mkasmh
if a.gReg == -1 {
ns := regs.Names();
......
usr/austin/ogle/cmd.go
View file @ ffe83e58
......@@ -6,12 +6,12 @@ package ogle
import (
"bufio";
"debug/proc";
"eval";
"fmt";
"go/scanner";
"go/token";
"os";
"ptrace";
"strconv";
"strings";
"sym";
......@@ -139,7 +139,7 @@ func cmdLoad(args []byte) os.Error {
// Parse argument and start or attach to process
var fname string;
var proc ptrace.Process;
var tproc proc.Process;
if len(path) >= 4 && path[0:4] == "pid:" {
pid, err := strconv.Atoi(path[4:len(path)]);
if err != nil {
......@@ -149,7 +149,7 @@ func cmdLoad(args []byte) os.Error {
if err != nil {
return err;
}
proc, err = ptrace.Attach(pid);
tproc, err = proc.Attach(pid);
if err != nil {
return err;
}
......@@ -161,30 +161,30 @@ func cmdLoad(args []byte) os.Error {
} else {
fname = parts[0];
}
proc, err = ptrace.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr});
tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr});
if err != nil {
return err;
}
println("Started", path);
// TODO(austin) If we fail after this point, kill proc
// TODO(austin) If we fail after this point, kill tproc
// before detaching.
}
// Get symbols
f, err := os.Open(fname, os.O_RDONLY, 0);
if err != nil {
proc.Detach();
tproc.Detach();
return err;
}
defer f.Close();
elf, err := sym.NewElf(f);
if err != nil {
proc.Detach();
tproc.Detach();
return err;
}
curProc, err = NewProcessElf(proc, elf);
curProc, err = NewProcessElf(tproc, elf);
if err != nil {
proc.Detach();
tproc.Detach();
return err;
}
......@@ -194,7 +194,7 @@ func cmdLoad(args []byte) os.Error {
err = curProc.populateWorld(world);
if err != nil {
proc.Detach();
tproc.Detach();
return err;
}
......@@ -374,5 +374,5 @@ func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) {
if !ok {
t.Abort(UsageError("symbol " + name + " is not a function"));
}
curProc.OnBreakpoint(ptrace.Word(fn.Entry())).AddHandler(EventStop);
curProc.OnBreakpoint(proc.Word(fn.Entry())).AddHandler(EventStop);
}
usr/austin/ogle/event.go
View file @ ffe83e58
......@@ -5,9 +5,9 @@
package ogle
import (
"debug/proc";
"fmt";
"os";
"ptrace";
)
/*
......@@ -183,7 +183,7 @@ func EventStop(ev Event) (EventAction, os.Error) {
type breakpointHook struct {
commonHook;
p *Process;
pc ptrace.Word;
pc proc.Word;
}
// A Breakpoint event occurs when a process reaches a particular
......@@ -191,8 +191,8 @@ type breakpointHook struct {
// will be the goroutine that reached the program counter.
type Breakpoint struct {
commonEvent;
osThread ptrace.Thread;
pc ptrace.Word;
osThread proc.Thread;
pc proc.Word;
}
func (h *breakpointHook) AddHandler(eh EventHandler) {
......@@ -229,7 +229,7 @@ func (h *breakpointHook) String() string {
return fmt.Sprintf("breakpoint at %#x", h.pc);
}
func (b *Breakpoint) PC() ptrace.Word {
func (b *Breakpoint) PC() proc.Word {
return b.pc;
}
......
usr/austin/ogle/frame.go
View file @ ffe83e58
......@@ -5,9 +5,9 @@
package ogle
import (
"debug/proc";
"fmt";
"os";
"ptrace";
"sym";
)
......@@ -16,7 +16,7 @@ type Frame struct {
// pc is the PC of the next instruction that will execute in
// this frame. For lower frames, this is the instruction
// following the CALL instruction.
pc, sp, fp ptrace.Word;
pc, sp, fp proc.Word;
// The runtime.Stktop of the active stack segment
stk remoteStruct;
// The function this stack frame is in
......@@ -39,7 +39,7 @@ func newFrame(g remoteStruct) (*Frame, os.Error) {
func aNewFrame(a aborter, g remoteStruct) *Frame {
p := g.r.p;
var pc, sp ptrace.Word;
var pc, sp proc.Word;
// Is this G alive?
switch g.field(p.f.G.Status).(remoteInt).aGet(a) {
......@@ -79,8 +79,8 @@ func aNewFrame(a aborter, g remoteStruct) *Frame {
// G is not mapped to an OS thread. Use the
// scheduler's stored PC and SP.
sched := g.field(p.f.G.Sched).(remoteStruct);
pc = ptrace.Word(sched.field(p.f.Gobuf.Pc).(remoteUint).aGet(a));
sp = ptrace.Word(sched.field(p.f.Gobuf.Sp).(remoteUint).aGet(a));
pc = proc.Word(sched.field(p.f.Gobuf.Pc).(remoteUint).aGet(a));
sp = proc.Word(sched.field(p.f.Gobuf.Sp).(remoteUint).aGet(a));
}
// Get Stktop
......@@ -92,7 +92,7 @@ func aNewFrame(a aborter, g remoteStruct) *Frame {
// prepareFrame creates a Frame from the PC and SP within that frame,
// as well as the active stack segment. This function takes care of
// traversing stack breaks and unwinding closures.
func prepareFrame(a aborter, pc, sp ptrace.Word, stk remoteStruct, inner *Frame) *Frame {
func prepareFrame(a aborter, pc, sp proc.Word, stk remoteStruct, inner *Frame) *Frame {
// Based on src/pkg/runtime/amd64/traceback.c:traceback
p := stk.r.p;
top := inner == nil;
......@@ -104,11 +104,11 @@ func prepareFrame(a aborter, pc, sp ptrace.Word, stk remoteStruct, inner *Frame)
for i := 0; i < 100; i++ {
// Traverse segmented stack breaks
if p.sys.lessstack != nil && pc == ptrace.Word(p.sys.lessstack.Value) {
if p.sys.lessstack != nil && pc == proc.Word(p.sys.lessstack.Value) {
// Get stk->gobuf.pc
pc = ptrace.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Pc).(remoteUint).aGet(a));
pc = proc.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Pc).(remoteUint).aGet(a));
// Get stk->gobuf.sp
sp = ptrace.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Sp).(remoteUint).aGet(a));
sp = proc.Word(stk.field(p.f.Stktop.Gobuf).(remoteStruct).field(p.f.Gobuf.Sp).(remoteUint).aGet(a));
// Get stk->stackbase
stk = stk.field(p.f.Stktop.Stackbase).(remotePtr).aGet(a).(remoteStruct);
continue;
......@@ -116,7 +116,7 @@ func prepareFrame(a aborter, pc, sp ptrace.Word, stk remoteStruct, inner *Frame)
// Get the PC of the call instruction
callpc := pc;
if !top && (p.sys.goexit == nil || pc != ptrace.Word(p.sys.goexit.Value)) {
if !top && (p.sys.goexit == nil || pc != proc.Word(p.sys.goexit.Value)) {
callpc--;
}
......@@ -133,8 +133,8 @@ func prepareFrame(a aborter, pc, sp ptrace.Word, stk remoteStruct, inner *Frame)
}
spdelta, ok := p.ParseClosure(buf);
if ok {
sp += ptrace.Word(spdelta);
pc = p.peekUintptr(a, sp - ptrace.Word(p.PtrSize()));
sp += proc.Word(spdelta);
pc = p.peekUintptr(a, sp - proc.Word(p.PtrSize()));
}
}
if fn == nil {
......@@ -142,11 +142,11 @@ func prepareFrame(a aborter, pc, sp ptrace.Word, stk remoteStruct, inner *Frame)
}
// Compute frame pointer
var fp ptrace.Word;
var fp proc.Word;
if fn.FrameSize < p.PtrSize() {
fp = sp + ptrace.Word(p.PtrSize());
fp = sp + proc.Word(p.PtrSize());
} else {
fp = sp + ptrace.Word(fn.FrameSize);
fp = sp + proc.Word(fn.FrameSize);
}
// TODO(austin) To really figure out if we're in the prologue,
// we need to disassemble the function and look for the call
......@@ -154,10 +154,10 @@ func prepareFrame(a aborter, pc, sp ptrace.Word, stk remoteStruct, inner *Frame)
//
// TODO(austin) What if we're in the call to morestack in the
// prologue? Then top == false.
if top && pc == ptrace.Word(fn.Entry()) {
if top && pc == proc.Word(fn.Entry()) {
// We're in the function prologue, before SP
// has been adjusted for the frame.
fp -= ptrace.Word(fn.FrameSize - p.PtrSize());
fp -= proc.Word(fn.FrameSize - p.PtrSize());
}
return &Frame{pc, sp, fp, stk, fn, path, line, inner, nil};
......@@ -185,10 +185,10 @@ func (f *Frame) aOuter(a aborter) *Frame {
// around calls to go and defer. Russ says this
// should get fixed in the compiler, but we account
// for it for now.
sp += ptrace.Word(2 * p.PtrSize());
sp += proc.Word(2 * p.PtrSize());
}
pc := p.peekUintptr(a, f.fp - ptrace.Word(p.PtrSize()));
pc := p.peekUintptr(a, f.fp - proc.Word(p.PtrSize()));
if pc < 0x1000 {
return nil;
}
......@@ -207,8 +207,8 @@ func (f *Frame) Inner() *Frame {
func (f *Frame) String() string {
res := f.fn.Name;
if f.pc > ptrace.Word(f.fn.Value) {
res += fmt.Sprintf("+%#x", f.pc - ptrace.Word(f.fn.Entry()));
if f.pc > proc.Word(f.fn.Value) {
res += fmt.Sprintf("+%#x", f.pc - proc.Word(f.fn.Entry()));
}
return res + fmt.Sprintf(" %s:%d", f.path, f.line);
}
usr/austin/ogle/goroutine.go
View file @ ffe83e58
......@@ -5,10 +5,10 @@
package ogle
import (
"debug/proc";
"eval";
"fmt";
"os";
"ptrace";
)
// A Goroutine represents a goroutine in a remote process.
......@@ -68,7 +68,7 @@ func readylockedBP(ev Event) (EventAction, os.Error) {
return EAStop, err;
}
sp := regs.SP();
addr := sp + ptrace.Word(p.PtrSize());
addr := sp + proc.Word(p.PtrSize());
arg := remotePtr{remote{addr, p}, p.runtime.G};
var gp eval.Value;
err = try(func(a aborter) { gp = arg.aGet(a) });
......
usr/austin/ogle/process.go
View file @ ffe83e58
......@@ -5,11 +5,11 @@
package ogle
import (
"debug/proc";
"eval";
"fmt";
"log";
"os";
"ptrace";
"reflect";
"sym";
)
......@@ -42,8 +42,8 @@ func (e ProcessNotStopped) String() string {
// An UnknownGoroutine error is an internal error representing an
// unrecognized G structure pointer.
type UnknownGoroutine struct {
OSThread ptrace.Thread;
Goroutine ptrace.Word;
OSThread proc.Thread;
Goroutine proc.Word;
}
func (e UnknownGoroutine) String() string {
......@@ -62,16 +62,16 @@ func (e NoCurrentGoroutine) String() string {
// A Process represents a remote attached process.
type Process struct {
Arch;
proc ptrace.Process;
proc proc.Process;
// The symbol table of this process
syms *sym.GoSymTable;
// A possibly-stopped OS thread, or nil
threadCache ptrace.Thread;
threadCache proc.Thread;
// Types parsed from the remote process
types map[ptrace.Word] *remoteType;
types map[proc.Word] *remoteType;
// Types and values from the remote runtime package
runtime runtimeValues;
......@@ -92,7 +92,7 @@ type Process struct {
event Event;
// Event hooks
breakpointHooks map[ptrace.Word] *breakpointHook;
breakpointHooks map[proc.Word] *breakpointHook;
goroutineCreateHook *goroutineCreateHook;
goroutineExitHook *goroutineExitHook;
......@@ -100,25 +100,25 @@ type Process struct {
curGoroutine *Goroutine;
// Goroutines by the address of their G structure
goroutines map[ptrace.Word] *Goroutine;
goroutines map[proc.Word] *Goroutine;
}
/*
* Process creation
*/
// NewProcess constructs a new remote process around a ptrace'd
// NewProcess constructs a new remote process around a traced
// process, an architecture, and a symbol table.
func NewProcess(proc ptrace.Process, arch Arch, syms *sym.GoSymTable) (*Process, os.Error) {
func NewProcess(tproc proc.Process, arch Arch, syms *sym.GoSymTable) (*Process, os.Error) {
p := &Process{
Arch: arch,
proc: proc,
proc: tproc,
syms: syms,
types: make(map[ptrace.Word] *remoteType),
breakpointHooks: make(map[ptrace.Word] *breakpointHook),
types: make(map[proc.Word] *remoteType),
breakpointHooks: make(map[proc.Word] *breakpointHook),
goroutineCreateHook: new(goroutineCreateHook),
goroutineExitHook: new(goroutineExitHook),
goroutines: make(map[ptrace.Word] *Goroutine),
goroutines: make(map[proc.Word] *Goroutine),
};
// Fill in remote runtime
......@@ -151,8 +151,8 @@ func NewProcess(proc ptrace.Process, arch Arch, syms *sym.GoSymTable) (*Process,
}
// Create internal breakpoints to catch new and exited goroutines
p.OnBreakpoint(ptrace.Word(p.sys.newprocreadylocked.Entry())).(*breakpointHook).addHandler(readylockedBP, true);
p.OnBreakpoint(ptrace.Word(p.sys.goexit.Entry())).(*breakpointHook).addHandler(goexitBP, true);
p.OnBreakpoint(proc.Word(p.sys.newprocreadylocked.Entry())).(*breakpointHook).addHandler(readylockedBP, true);
p.OnBreakpoint(proc.Word(p.sys.goexit.Entry())).(*breakpointHook).addHandler(goexitBP, true);
// Select current frames
for _, g := range p.goroutines {
......@@ -164,9 +164,9 @@ func NewProcess(proc ptrace.Process, arch Arch, syms *sym.GoSymTable) (*Process,
return p, nil;
}
// NewProcessElf constructs a new remote process around a ptrace'd
// NewProcessElf constructs a new remote process around a traced
// process and the process' ELF object.
func NewProcessElf(proc ptrace.Process, elf *sym.Elf) (*Process, os.Error) {
func NewProcessElf(tproc proc.Process, elf *sym.Elf) (*Process, os.Error) {
syms, err := sym.ElfGoSyms(elf);
if err != nil {
return nil, err;
......@@ -181,7 +181,7 @@ func NewProcessElf(proc ptrace.Process, elf *sym.Elf) (*Process, os.Error) {
default:
return nil, UnknownArchitecture(elf.Machine);
}
return NewProcess(proc, arch, syms);
return NewProcess(tproc, arch, syms);
}
// bootstrap constructs the runtime structure of a remote process.
......@@ -238,10 +238,10 @@ func (p *Process) bootstrap() {
p.sys.deferproc = globalFn("sys·deferproc");
p.sys.newprocreadylocked = globalFn("newprocreadylocked");
if allg := p.syms.SymFromName("allg"); allg != nil {
p.sys.allg = remotePtr{remote{ptrace.Word(allg.Common().Value), p}, p.runtime.G};
p.sys.allg = remotePtr{remote{proc.Word(allg.Common().Value), p}, p.runtime.G};
}
if g0 := p.syms.SymFromName("g0"); g0 != nil {
p.sys.g0 = p.runtime.G.mk(remote{ptrace.Word(g0.Common().Value), p}).(remoteStruct);
p.sys.g0 = p.runtime.G.mk(remote{proc.Word(g0.Common().Value), p}).(remoteStruct);
}
}
......@@ -261,7 +261,7 @@ func (p *Process) selectSomeGoroutine() {
* Process memory
*/
func (p *Process) someStoppedOSThread() ptrace.Thread {
func (p *Process) someStoppedOSThread() proc.Thread {
if p.threadCache != nil {
if _, err := p.threadCache.Stopped(); err == nil {
return p.threadCache;
......@@ -277,7 +277,7 @@ func (p *Process) someStoppedOSThread() ptrace.Thread {
return nil;
}
func (p *Process) Peek(addr ptrace.Word, out []byte) (int, os.Error) {
func (p *Process) Peek(addr proc.Word, out []byte) (int, os.Error) {
thr := p.someStoppedOSThread();
if thr == nil {
return 0, ProcessNotStopped{};
......@@ -285,7 +285,7 @@ func (p *Process) Peek(addr ptrace.Word, out []byte) (int, os.Error) {
return thr.Peek(addr, out);
}
func (p *Process) Poke(addr ptrace.Word, b []byte) (int, os.Error) {
func (p *Process) Poke(addr proc.Word, b []byte) (int, os.Error) {
thr := p.someStoppedOSThread();
if thr == nil {
return 0, ProcessNotStopped{};
......@@ -293,8 +293,8 @@ func (p *Process) Poke(addr ptrace.Word, b []byte) (int, os.Error) {
return thr.Poke(addr, b);
}
func (p *Process) peekUintptr(a aborter, addr ptrace.Word) ptrace.Word {
return ptrace.Word(mkUintptr(remote{addr, p}).(remoteUint).aGet(a));
func (p *Process) peekUintptr(a aborter, addr proc.Word) proc.Word {
return proc.Word(mkUintptr(remote{addr, p}).(remoteUint).aGet(a));
}
/*
......@@ -303,7 +303,7 @@ func (p *Process) peekUintptr(a aborter, addr ptrace.Word) ptrace.Word {
// OnBreakpoint returns the hook that is run when the program reaches
// the given program counter.
func (p *Process) OnBreakpoint(pc ptrace.Word) EventHook {
func (p *Process) OnBreakpoint(pc proc.Word) EventHook {
if bp, ok := p.breakpointHooks[pc]; ok {
return bp;
}
......@@ -322,7 +322,7 @@ func (p *Process) OnGoroutineExit() EventHook {
}
// osThreadToGoroutine looks up the goroutine running on an OS thread.
func (p *Process) osThreadToGoroutine(t ptrace.Thread) (*Goroutine, os.Error) {
func (p *Process) osThreadToGoroutine(t proc.Thread) (*Goroutine, os.Error) {
regs, err := t.Regs();
if err != nil {
return nil, err;
......@@ -343,9 +343,9 @@ func (p *Process) causesToEvents() ([]Event, os.Error) {
for _, t := range p.proc.Threads() {
if c, err := t.Stopped(); err == nil {
switch c := c.(type) {
case ptrace.Breakpoint:
case proc.Breakpoint:
nev++;
case ptrace.Signal:
case proc.Signal:
// TODO(austin)
//nev++;
}
......@@ -358,14 +358,14 @@ func (p *Process) causesToEvents() ([]Event, os.Error) {
for _, t := range p.proc.Threads() {
if c, err := t.Stopped(); err == nil {
switch c := c.(type) {
case ptrace.Breakpoint:
case proc.Breakpoint:
gt, err := p.osThreadToGoroutine(t);
if err != nil {
return nil, err;
}
events[i] = &Breakpoint{commonEvent{p, gt}, t, ptrace.Word(c)};
events[i] = &Breakpoint{commonEvent{p, gt}, t, proc.Word(c)};
i++;
case ptrace.Signal:
case proc.Signal:
// TODO(austin)
}
}
......
usr/austin/ogle/rruntime.go
View file @ ffe83e58
......@@ -5,8 +5,8 @@
package ogle
import (
"debug/proc";
"eval";
"ptrace";
"reflect";
)
......@@ -227,7 +227,7 @@ type runtimeValues struct {
PFloat32Type, PFloat64Type, PFloatType,
PArrayType, PStringType, PStructType, PPtrType, PFuncType,
PInterfaceType, PSliceType, PMapType, PChanType,
PDotDotDotType, PUnsafePointerType ptrace.Word;
PDotDotDotType, PUnsafePointerType proc.Word;
// G status values
runtimeGStatus;
}
......
usr/austin/ogle/rtype.go
View file @ ffe83e58
......@@ -5,10 +5,10 @@
package ogle
import (
"debug/proc";
"eval";
"fmt";
"log";
"ptrace";
)
const debugParseRemoteType = false
......@@ -156,7 +156,7 @@ func parseRemoteType(a aborter, rs remoteStruct) *remoteType {
}
// Get Type header
itype := ptrace.Word(rs.field(p.f.Type.Typ).(remoteUint).aGet(a));
itype := proc.Word(rs.field(p.f.Type.Typ).(remoteUint).aGet(a));
typ := rs.field(p.f.Type.Ptr).(remotePtr).aGet(a).(remoteStruct);
// Is this a named type?
......
usr/austin/ogle/rvalue.go
View file @ ffe83e58
......@@ -5,9 +5,9 @@
package ogle
import (
"debug/proc";
"eval";
"fmt";
"ptrace";
)
// A RemoteMismatchError occurs when an operation that requires two
......@@ -38,7 +38,7 @@ type remoteValue interface {
// remote represents an address in a remote process.
type remote struct {
base ptrace.Word;
base proc.Word;
p *Process;
}
......@@ -71,14 +71,14 @@ func (v remote) Get(a aborter, size int) uint64 {
func (v remote) Set(a aborter, size int, x uint64) {
var arr [8]byte;
buf := arr[0:size];
v.p.FromWord(ptrace.Word(x), buf);
v.p.FromWord(proc.Word(x), buf);
_, err := v.p.Poke(v.base, buf);
if err != nil {
a.Abort(err);
}
}
func (v remote) plus(x ptrace.Word) remote {
func (v remote) plus(x proc.Word) remote {
return remote{v.base + x, v.p};
}
......@@ -340,9 +340,9 @@ func (v remoteString) Get(t *eval.Thread) string {
func (v remoteString) aGet(a aborter) string {
rs := v.r.p.runtime.String.mk(v.r).(remoteStruct);
str := ptrace.Word(rs.field(v.r.p.f.String.Str).(remoteUint).aGet(a));
str := proc.Word(rs.field(v.r.p.f.String.Str).(remoteUint).aGet(a));
len := rs.field(v.r.p.f.String.Len).(remoteInt).aGet(a);
bytes := make([]uint8, len);
_, err := v.r.p.Peek(str, bytes);
if err != nil {
......@@ -404,11 +404,11 @@ func (v remoteArray) Elem(t *eval.Thread, i int64) eval.Value {
}
func (v remoteArray) elem(i int64) eval.Value {
return v.elemType.mk(v.r.plus(ptrace.Word(int64(v.elemType.size) * i)));
return v.elemType.mk(v.r.plus(proc.Word(int64(v.elemType.size) * i)));
}
func (v remoteArray) Sub(i int64, len int64) eval.ArrayValue {
return remoteArray{v.r.plus(ptrace.Word(int64(v.elemType.size) * i)), len, v.elemType};
return remoteArray{v.r.plus(proc.Word(int64(v.elemType.size) * i)), len, v.elemType};
}
/*
......@@ -455,7 +455,7 @@ func (v remoteStruct) Field(t *eval.Thread, i int) eval.Value {
func (v remoteStruct) field(i int) eval.Value {
f := &v.layout[i];
return f.fieldType.mk(v.r.plus(ptrace.Word(f.offset)));
return f.fieldType.mk(v.r.plus(proc.Word(f.offset)));
}
func (v remoteStruct) addr() remote {
......@@ -494,7 +494,7 @@ func (v remotePtr) Get(t *eval.Thread) eval.Value {
}
func (v remotePtr) aGet(a aborter) eval.Value {
addr := ptrace.Word(v.r.Get(a, v.r.p.PtrSize()));
addr := proc.Word(v.r.Get(a, v.r.p.PtrSize()));
if addr == 0 {
return nil;
}
......@@ -550,7 +550,7 @@ func (v remoteSlice) Get(t *eval.Thread) eval.Slice {
func (v remoteSlice) aGet(a aborter) eval.Slice {
rs := v.r.p.runtime.Slice.mk(v.r).(remoteStruct);
base := ptrace.Word(rs.field(v.r.p.f.Slice.Array).(remoteUint).aGet(a));
base := proc.Word(rs.field(v.r.p.f.Slice.Array).(remoteUint).aGet(a));
nel := rs.field(v.r.p.f.Slice.Len).(remoteInt).aGet(a);
cap := rs.field(v.r.p.f.Slice.Cap).(remoteInt).aGet(a);
if base == 0 {
......
usr/austin/ogle/vars.go
View file @ ffe83e58
......@@ -5,10 +5,10 @@
package ogle
import (
"debug/proc";
"eval";
"log";
"os";
"ptrace";
"sym";
)
......@@ -160,7 +160,7 @@ func (p *Process) populateWorld(w *eval.World) os.Error {
if rt == nil {
continue;
}
pkg[name] = def{rt.Type, rt.mk(remote{ptrace.Word(sc.Value), p})};
pkg[name] = def{rt.Type, rt.mk(remote{proc.Word(sc.Value), p})};
case 'T', 't', 'L', 'l':
// Function
......@@ -207,7 +207,7 @@ func (p *Process) typeOfSym(s *sym.CommonSym) (*remoteType, os.Error) {
if s.GoType == 0 {
return nil, nil;
}
addr := ptrace.Word(s.GoType);
addr := proc.Word(s.GoType);
var rt *remoteType;
err := try(func(a aborter) {
rt = parseRemoteType(a, p.runtime.Type.mk(remote{addr, p}).(remoteStruct));
......
usr/austin/ptrace/Makefile deleted 100644 → 0
View file @ 495b3db8
# Copyright 2009 The Go Authors. All rights reserved.
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
include $(GOROOT)/src/Make.$(GOARCH)
TARG=ptrace
GOFILES=\
process.go\
ptrace_linux.go\
regs_$(GOOS)_$(GOARCH).go\
include $(GOROOT)/src/Make.pkg
usr/austin/ptrace/process.go deleted 100644 → 0
View file @ 495b3db8
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package ptrace provides a platform-independent interface for
// tracing and controlling running processes. It supports
// multi-threaded processes and provides typical low-level debugging
// controls such as breakpoints, single stepping, and manipulating
// memory and registers.
package ptrace
import (
"os";
"strconv";
)
type Word uint64
// A Cause explains why a thread is stopped.
type Cause interface {
String() string;
}
// Regs is a set of named machine registers, including a program
// counter, link register, and stack pointer.
//
// TODO(austin) There's quite a proliferation of methods here. We
// could make a Reg interface with Get and Set and make this just PC,
// Link, SP, Names, and Reg. We could also put Index in Reg and that
// makes it easy to get the index of things like the PC (currently
// there's just no way to know that). This would also let us include
// other per-register information like how to print it.
type Regs interface {
// PC returns the value of the program counter.
PC() Word;
// SetPC sets the program counter to val.
SetPC(val Word) os.Error;
// Link returns the link register, if any.
Link() Word;
// SetLink sets the link register to val.
SetLink(val Word) os.Error;
// SP returns the value of the stack pointer.
SP() Word;
// SetSP sets the stack pointer register to val.
SetSP(val Word) os.Error;
// Names returns the names of all of the registers.
Names() []string;
// Get returns the value of a register, where i corresponds to
// the index of the register's name in the array returned by
// Names.
Get(i int) Word;
// Set sets the value of a register.
Set(i int, val Word) os.Error;
}
// Thread is a thread in the process being traced.
type Thread interface {
// Step steps this thread by a single instruction. The thread
// must be stopped. If the thread is currently stopped on a
// breakpoint, this will step over the breakpoint.
//
// XXX What if it's stopped because of a signal?
Step() os.Error;
// Stopped returns the reason that this thread is stopped. It
// is an error is the thread not stopped.
Stopped() (Cause, os.Error);
// Regs retrieves the current register values from this
// thread. The thread must be stopped.
Regs() (Regs, os.Error);
// Peek reads len(out) bytes from the address addr in this
// thread into out. The thread must be stopped. It returns
// the number of bytes successfully read. If an error occurs,
// such as attempting to read unmapped memory, this count
// could be short and an error will be returned. If this does
// encounter unmapped memory, it will read up to the byte
// preceding the unmapped area.
Peek(addr Word, out []byte) (int, os.Error);
// Poke writes b to the address addr in this thread. The
// thread must be stopped. It returns the number of bytes
// successfully written. If an error occurs, such as
// attempting to write to unmapped memory, this count could be
// short and an error will be returned. If this does
// encounter unmapped memory, it will write up to the byte
// preceding the unmapped area.
Poke(addr Word, b []byte) (int, os.Error);
}
// Process is a process being traced. It consists of a set of
// threads. A process can be running, stopped, or terminated. The
// process's state extends to all of its threads.
type Process interface {
// Threads returns an array of all threads in this process.
Threads() []Thread;
// AddBreakpoint creates a new breakpoint at program counter
// pc. Breakpoints can only be created when the process is
// stopped. It is an error if a breakpoint already exists at
// pc.
AddBreakpoint(pc Word) os.Error;
// RemoveBreakpoint removes the breakpoint at the program
// counter pc. It is an error if no breakpoint exists at pc.
RemoveBreakpoint(pc Word) os.Error;
// Stop stops all running threads in this process before
// returning.
Stop() os.Error;
// Continue resumes execution of all threads in this process.
// Any thread that is stopped on a breakpoint will be stepped
// over that breakpoint. Any thread that is stopped because
// of a signal (other than SIGSTOP or SIGTRAP) will receive
// the pending signal.
Continue() os.Error;
// WaitStop waits until all threads in process p are stopped
// as a result of some thread hitting a breakpoint, receiving
// a signal, creating a new thread, or exiting.
WaitStop() os.Error;
// Detach detaches from this process. All stopped threads
// will be resumed.
Detach() os.Error;
}
// Stopped is a stop cause used for threads that are stopped either by
// user request (e.g., from the Stop method or after single stepping),
// or that are stopped because some other thread caused the program to
// stop.
type Stopped struct {}
func (c Stopped) String() string {
return "stopped";
}
// Breakpoint is a stop cause resulting from a thread reaching a set
// breakpoint.
type Breakpoint Word
// PC returns the program counter that the program is stopped at.
func (c Breakpoint) PC() Word {
return Word(c);
}
func (c Breakpoint) String() string {
return "breakpoint at 0x" + strconv.Uitob64(uint64(c.PC()), 16);
}
// Signal is a stop cause resulting from a thread receiving a signal.
// When the process is continued, the signal will be delivered.
type Signal string
// Signal returns the signal being delivered to the thread.
func (c Signal) Name() string {
return string(c);
}
func (c Signal) String() string {
return c.Name();
}
// ThreadCreate is a stop cause returned from an existing thread when
// it creates a new thread. The new thread exists in a primordial
// form at this point and will begin executing in earnest when the
// process is continued.
type ThreadCreate struct {
thread Thread;
}
func (c *ThreadCreate) NewThread() Thread {
return c.thread;
}
func (c *ThreadCreate) String() string {
return "thread create";
}
// ThreadExit is a stop cause resulting from a thread exiting. When
// this cause first arises, the thread will still be in the list of
// process threads and its registers and memory will still be
// accessible.
type ThreadExit struct {
exitStatus int;
signal string;
}
// Exited returns true if the thread exited normally.
func (c *ThreadExit) Exited() bool {
return c.exitStatus != -1;
}
// ExitStatus returns the exit status of the thread if it exited
// normally or -1 otherwise.
func (c *ThreadExit) ExitStatus() int {
return c.exitStatus;
}
// Signaled returns true if the thread was terminated by a signal.
func (c *ThreadExit) Signaled() bool {
return c.exitStatus == -1;
}
// StopSignal returns the signal that terminated the thread, or "" if
// it was not terminated by a signal.
func (c *ThreadExit) StopSignal() string {
return c.signal;
}
func (c *ThreadExit) String() string {
res := "thread exited ";
switch {
case c.Exited():
res += "with status " + strconv.Itoa(c.ExitStatus());
case c.Signaled():
res += "from signal " + c.StopSignal();
default:
res += "from unknown cause";
}
return res;
}
usr/austin/ptrace/ptrace-nptl.txt deleted 100644 → 0
View file @ 495b3db8
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
ptrace and NTPL, the missing manpage
== Signals ==
A signal sent to a ptrace'd process or thread causes only the thread
that receives it to stop and report to the attached process.
Use tgkill to target a signal (for example, SIGSTOP) at a particular
thread. If you use kill, the signal could be delivered to another
thread in the same process.
Note that SIGSTOP differs from its usual behavior when a process is
being traced. Usually, a SIGSTOP sent to any thread in a thread group
will stop all threads in the thread group. When a thread is traced,
however, a SIGSTOP affects only the receiving thread (and any other
threads in the thread group that are not traced).
SIGKILL behaves like it does for non-traced processes. It affects all
threads in the process and terminates them without the WSTOPSIG event
generated by other signals. However, if PTRACE_O_TRACEEXIT is set,
the attached process will still receive PTRACE_EVENT_EXIT events
before receiving WIFSIGNALED events.
See "Following thread death" for a caveat regarding signal delivery to
zombie threads.
== Waiting on threads ==
Cloned threads in ptrace'd processes are treated similarly to cloned
threads in your own process. Thus, you must use the __WALL option in
order to receive notifications from threads created by the child
process. Similarly, the __WCLONE option will wait only on
notifications from threads created by the child process and *not* on
notifications from the initial child thread.
Even when waiting on a specific thread's PID using waitpid or similar,
__WALL or __WCLONE is necessary or waitpid will return ECHILD.
== Attaching to existing threads ==
libthread_db (which gdb uses), attaches to existing threads by pulling
the pthread data structures out of the traced process. The much
easier way is to traverse the /proc/PID/task directory, though it's
unclear how the semantics of these two approaches differ.
Unfortunately, if the main thread has exited (but the overall process
has not), it sticks around as a zombie process. This zombie will
appear in the /proc/PID/task directory, but trying to attach to it
will yield EPERM. In this case, the third field of the
/proc/PID/task/PID/stat file will be "Z". Attempting to open the stat
file is also a convenient way to detect races between listing the task
directory and the thread exiting. Coincidentally, gdb will simply
fail to attach to a process whose main thread is a zombie.
Because new threads may be created while the debugger is in the
process of attaching to existing threads, the debugger must repeatedly
re-list the task directory until it has attached to (and thus stopped)
every thread listed.
In order to follow new threads created by existing threads,
PTRACE_O_TRACECLONE must be set on each thread attached to.
== Following new threads ==
With the child process stopped, use PTRACE_SETOPTIONS to set the
PTRACE_O_TRACECLONE option. This option is per-thread, and thus must
be set on each existing thread individually. When an existing thread
with PTRACE_O_TRACECLONE set spawns a new thread, the existing thread
will stop with (SIGTRAP | PTRACE_EVENT_CLONE << 8) and the PID of the
new thread can be retrieved with PTRACE_GETEVENTMSG on the creating
thread. At this time, the new thread will exist, but will initially
be stopped with a SIGSTOP. The new thread will automatically be
traced and will inherit the PTRACE_O_TRACECLONE option from its
parent. The attached process should wait on the new thread to receive
the SIGSTOP notification.
When using waitpid(-1, ...), don't rely on the parent thread reporting
a SIGTRAP before receiving the SIGSTOP from the new child thread.
Without PTRACE_O_TRACECLONE, newly cloned threads will not be
ptrace'd. As a result, signals received by new threads will be
handled in the usual way, which may affect the parent and in turn
appear to the attached process, but attributed to the parent (possibly
in unexpected ways).
== Following thread death ==
If any thread with the PTRACE_O_TRACEEXIT option set exits (either by
returning or pthread_exit'ing), the tracing process will receive an
immediate PTRACE_EVENT_EXIT. At this point, the thread will still
exist. The exit status, encoded as for wait, can be queried using
PTRACE_GETEVENTMSG on the exiting thread's PID. The thread should be
continued so it can actually exit, after which its wait behavior is
the same as for a thread without the PTRACE_O_TRACEEXIT option.
If a non-main thread exits (either by returning or pthread_exit'ing),
its corresponding process will also exit, producing a WIFEXITED event
(after the process is continued from a possible PTRACE_EVENT_EXIT
event). It is *not* necessary for another thread to ptrace_join for
this to happen.
If the main thread exits by returning, then all threads will exit,
first generating a PTRACE_EVENT_EXIT event for each thread if
appropriate, then producing a WIFEXITED event for each thread.
If the main thread exits using pthread_exit, then it enters a
non-waitable zombie state. It will still produce an immediate
PTRACE_O_TRACEEXIT event, but the WIFEXITED event will be delayed
until the entire process exits. This state exists so that shells
don't think the process is done until all of the threads have exited.
Unfortunately, signals cannot be delivered to non-waitable zombies.
Most notably, SIGSTOP cannot be delivered; as a result, when you
broadcast SIGSTOP to all of the threads, you must not wait for
non-waitable zombies to stop. Furthermore, any ptrace command on a
non-waitable zombie, including PTRACE_DETACH, will return ESRCH.
== Multi-threaded debuggers ==
If the debugger itself is multi-threaded, ptrace calls must come from
the same thread that originally attached to the remote thread. The
kernel simply compares the PID of the caller of ptrace against the
tracer PID of the process passed to ptrace. Because each debugger
thread has a different PID, calling ptrace from a different thread
might as well be calling it from a different process and the kernel
will return ESRCH.
wait, on the other hand, does not have this restriction. Any debugger
thread can wait on any thread in the attached process.
usr/austin/ptrace/ptrace_linux.go deleted 100644 → 0
View file @ 495b3db8
This diff is collapsed.
usr/austin/ptrace/regs_linux_amd64.go deleted 100644 → 0
View file @ 495b3db8
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package ptrace
import (
"os";
"strconv";
"syscall";
)
type amd64Regs struct {
syscall.PtraceRegs;
setter func (*syscall.PtraceRegs) os.Error;
}
var names = [...]string {
"rax",
"rbx",
"rcx",
"rdx",
"rsi",
"rdi",
"rbp",
"rsp",
"r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
"rip",
"eflags",
"cs",
"ss",
"ds",
"es",
"fs",
"gs",
// PtraceRegs contains these registers, but I don't think
// they're actually meaningful.
//"orig_rax",
//"fs_base",
//"gs_base",
}
func (r *amd64Regs) PC() Word {
return Word(r.Rip);
}
func (r *amd64Regs) SetPC(val Word) os.Error {
r.Rip = uint64(val);
return r.setter(&r.PtraceRegs);
}
func (r *amd64Regs) Link() Word {
// TODO(austin)
panic("No link register");
}
func (r *amd64Regs) SetLink(val Word) os.Error {
panic("No link register");
}
func (r *amd64Regs) SP() Word {
return Word(r.Rsp);
}
func (r *amd64Regs) SetSP(val Word) os.Error {
r.Rsp = uint64(val);
return r.setter(&r.PtraceRegs);
}
func (r *amd64Regs) Names() []string {
return &names;
}
func (r *amd64Regs) Get(i int) Word {
switch i {
case 0: return Word(r.Rax);
case 1: return Word(r.Rbx);
case 2: return Word(r.Rcx);
case 3: return Word(r.Rdx);
case 4: return Word(r.Rsi);
case 5: return Word(r.Rdi);
case 6: return Word(r.Rbp);
case 7: return Word(r.Rsp);
case 8: return Word(r.R8);
case 9: return Word(r.R9);
case 10: return Word(r.R10);
case 11: return Word(r.R11);
case 12: return Word(r.R12);
case 13: return Word(r.R13);
case 14: return Word(r.R14);
case 15: return Word(r.R15);
case 16: return Word(r.Rip);
case 17: return Word(r.Eflags);
case 18: return Word(r.Cs);
case 19: return Word(r.Ss);
case 20: return Word(r.Ds);
case 21: return Word(r.Es);
case 22: return Word(r.Fs);
case 23: return Word(r.Gs);
}
panic("invalid register index ", strconv.Itoa(i));
}
func (r *amd64Regs) Set(i int, val Word) os.Error {
switch i {
case 0: r.Rax = uint64(val);
case 1: r.Rbx = uint64(val);
case 2: r.Rcx = uint64(val);
case 3: r.Rdx = uint64(val);
case 4: r.Rsi = uint64(val);
case 5: r.Rdi = uint64(val);
case 6: r.Rbp = uint64(val);
case 7: r.Rsp = uint64(val);
case 8: r.R8 = uint64(val);
case 9: r.R9 = uint64(val);
case 10: r.R10 = uint64(val);
case 11: r.R11 = uint64(val);
case 12: r.R12 = uint64(val);
case 13: r.R13 = uint64(val);
case 14: r.R14 = uint64(val);
case 15: r.R15 = uint64(val);
case 16: r.Rip = uint64(val);
case 17: r.Eflags = uint64(val);
case 18: r.Cs = uint64(val);
case 19: r.Ss = uint64(val);
case 20: r.Ds = uint64(val);
case 21: r.Es = uint64(val);
case 22: r.Fs = uint64(val);
case 23: r.Gs = uint64(val);
default:
panic("invalid register index ", strconv.Itoa(i));
}
return r.setter(&r.PtraceRegs);
}
func newRegs(regs *syscall.PtraceRegs, setter func (*syscall.PtraceRegs) os.Error) Regs {
res := amd64Regs{};
res.PtraceRegs = *regs;
res.setter = setter;
return &res;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment