|
|
|
|
@ -1,3 +1,5 @@ |
|
|
|
|
// +build go1.7
|
|
|
|
|
|
|
|
|
|
// Package stack implements utilities to capture, manipulate, and format call
|
|
|
|
|
// stacks. It provides a simpler API than package runtime.
|
|
|
|
|
//
|
|
|
|
|
@ -21,29 +23,31 @@ import ( |
|
|
|
|
|
|
|
|
|
// Call records a single function invocation from a goroutine stack.
|
|
|
|
|
type Call struct { |
|
|
|
|
fn *runtime.Func |
|
|
|
|
pc uintptr |
|
|
|
|
frame runtime.Frame |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Caller returns a Call from the stack of the current goroutine. The argument
|
|
|
|
|
// skip is the number of stack frames to ascend, with 0 identifying the
|
|
|
|
|
// calling function.
|
|
|
|
|
func Caller(skip int) Call { |
|
|
|
|
var pcs [2]uintptr |
|
|
|
|
// As of Go 1.9 we need room for up to three PC entries.
|
|
|
|
|
//
|
|
|
|
|
// 0. An entry for the stack frame prior to the target to check for
|
|
|
|
|
// special handling needed if that prior entry is runtime.sigpanic.
|
|
|
|
|
// 1. A possible second entry to hold metadata about skipped inlined
|
|
|
|
|
// functions. If inline functions were not skipped the target frame
|
|
|
|
|
// PC will be here.
|
|
|
|
|
// 2. A third entry for the target frame PC when the second entry
|
|
|
|
|
// is used for skipped inline functions.
|
|
|
|
|
var pcs [3]uintptr |
|
|
|
|
n := runtime.Callers(skip+1, pcs[:]) |
|
|
|
|
frames := runtime.CallersFrames(pcs[:n]) |
|
|
|
|
frame, _ := frames.Next() |
|
|
|
|
frame, _ = frames.Next() |
|
|
|
|
|
|
|
|
|
var c Call |
|
|
|
|
|
|
|
|
|
if n < 2 { |
|
|
|
|
return c |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
c.pc = pcs[1] |
|
|
|
|
if runtime.FuncForPC(pcs[0]) != sigpanic { |
|
|
|
|
c.pc-- |
|
|
|
|
return Call{ |
|
|
|
|
frame: frame, |
|
|
|
|
} |
|
|
|
|
c.fn = runtime.FuncForPC(c.pc) |
|
|
|
|
return c |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// String implements fmt.Stinger. It is equivalent to fmt.Sprintf("%v", c).
|
|
|
|
|
@ -54,9 +58,10 @@ func (c Call) String() string { |
|
|
|
|
// MarshalText implements encoding.TextMarshaler. It formats the Call the same
|
|
|
|
|
// as fmt.Sprintf("%v", c).
|
|
|
|
|
func (c Call) MarshalText() ([]byte, error) { |
|
|
|
|
if c.fn == nil { |
|
|
|
|
if c.frame == (runtime.Frame{}) { |
|
|
|
|
return nil, ErrNoFunc |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
buf := bytes.Buffer{} |
|
|
|
|
fmt.Fprint(&buf, c) |
|
|
|
|
return buf.Bytes(), nil |
|
|
|
|
@ -71,6 +76,7 @@ var ErrNoFunc = errors.New("no call stack information") |
|
|
|
|
// %s source file
|
|
|
|
|
// %d line number
|
|
|
|
|
// %n function name
|
|
|
|
|
// %k last segment of the package path
|
|
|
|
|
// %v equivalent to %s:%d
|
|
|
|
|
//
|
|
|
|
|
// It accepts the '+' and '#' flags for most of the verbs as follows.
|
|
|
|
|
@ -78,22 +84,23 @@ var ErrNoFunc = errors.New("no call stack information") |
|
|
|
|
// %+s path of source file relative to the compile time GOPATH
|
|
|
|
|
// %#s full path of source file
|
|
|
|
|
// %+n import path qualified function name
|
|
|
|
|
// %+k full package path
|
|
|
|
|
// %+v equivalent to %+s:%d
|
|
|
|
|
// %#v equivalent to %#s:%d
|
|
|
|
|
func (c Call) Format(s fmt.State, verb rune) { |
|
|
|
|
if c.fn == nil { |
|
|
|
|
if c.frame == (runtime.Frame{}) { |
|
|
|
|
fmt.Fprintf(s, "%%!%c(NOFUNC)", verb) |
|
|
|
|
return |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
switch verb { |
|
|
|
|
case 's', 'v': |
|
|
|
|
file, line := c.fn.FileLine(c.pc) |
|
|
|
|
file := c.frame.File |
|
|
|
|
switch { |
|
|
|
|
case s.Flag('#'): |
|
|
|
|
// done
|
|
|
|
|
case s.Flag('+'): |
|
|
|
|
file = file[pkgIndex(file, c.fn.Name()):] |
|
|
|
|
file = file[pkgIndex(file, c.frame.Function):] |
|
|
|
|
default: |
|
|
|
|
const sep = "/" |
|
|
|
|
if i := strings.LastIndex(file, sep); i != -1 { |
|
|
|
|
@ -103,16 +110,31 @@ func (c Call) Format(s fmt.State, verb rune) { |
|
|
|
|
io.WriteString(s, file) |
|
|
|
|
if verb == 'v' { |
|
|
|
|
buf := [7]byte{':'} |
|
|
|
|
s.Write(strconv.AppendInt(buf[:1], int64(line), 10)) |
|
|
|
|
s.Write(strconv.AppendInt(buf[:1], int64(c.frame.Line), 10)) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
case 'd': |
|
|
|
|
_, line := c.fn.FileLine(c.pc) |
|
|
|
|
buf := [6]byte{} |
|
|
|
|
s.Write(strconv.AppendInt(buf[:0], int64(line), 10)) |
|
|
|
|
s.Write(strconv.AppendInt(buf[:0], int64(c.frame.Line), 10)) |
|
|
|
|
|
|
|
|
|
case 'k': |
|
|
|
|
name := c.frame.Function |
|
|
|
|
const pathSep = "/" |
|
|
|
|
start, end := 0, len(name) |
|
|
|
|
if i := strings.LastIndex(name, pathSep); i != -1 { |
|
|
|
|
start = i + len(pathSep) |
|
|
|
|
} |
|
|
|
|
const pkgSep = "." |
|
|
|
|
if i := strings.Index(name[start:], pkgSep); i != -1 { |
|
|
|
|
end = start + i |
|
|
|
|
} |
|
|
|
|
if s.Flag('+') { |
|
|
|
|
start = 0 |
|
|
|
|
} |
|
|
|
|
io.WriteString(s, name[start:end]) |
|
|
|
|
|
|
|
|
|
case 'n': |
|
|
|
|
name := c.fn.Name() |
|
|
|
|
name := c.frame.Function |
|
|
|
|
if !s.Flag('+') { |
|
|
|
|
const pathSep = "/" |
|
|
|
|
if i := strings.LastIndex(name, pathSep); i != -1 { |
|
|
|
|
@ -127,35 +149,17 @@ func (c Call) Format(s fmt.State, verb rune) { |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Frame returns the call frame infomation for the Call.
|
|
|
|
|
func (c Call) Frame() runtime.Frame { |
|
|
|
|
return c.frame |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// PC returns the program counter for this call frame; multiple frames may
|
|
|
|
|
// have the same PC value.
|
|
|
|
|
//
|
|
|
|
|
// Deprecated: Use Call.Frame instead.
|
|
|
|
|
func (c Call) PC() uintptr { |
|
|
|
|
return c.pc |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// name returns the import path qualified name of the function containing the
|
|
|
|
|
// call.
|
|
|
|
|
func (c Call) name() string { |
|
|
|
|
if c.fn == nil { |
|
|
|
|
return "???" |
|
|
|
|
} |
|
|
|
|
return c.fn.Name() |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (c Call) file() string { |
|
|
|
|
if c.fn == nil { |
|
|
|
|
return "???" |
|
|
|
|
} |
|
|
|
|
file, _ := c.fn.FileLine(c.pc) |
|
|
|
|
return file |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (c Call) line() int { |
|
|
|
|
if c.fn == nil { |
|
|
|
|
return 0 |
|
|
|
|
} |
|
|
|
|
_, line := c.fn.FileLine(c.pc) |
|
|
|
|
return line |
|
|
|
|
return c.frame.PC |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// CallStack records a sequence of function invocations from a goroutine
|
|
|
|
|
@ -179,9 +183,6 @@ func (cs CallStack) MarshalText() ([]byte, error) { |
|
|
|
|
buf := bytes.Buffer{} |
|
|
|
|
buf.Write(openBracketBytes) |
|
|
|
|
for i, pc := range cs { |
|
|
|
|
if pc.fn == nil { |
|
|
|
|
return nil, ErrNoFunc |
|
|
|
|
} |
|
|
|
|
if i > 0 { |
|
|
|
|
buf.Write(spaceBytes) |
|
|
|
|
} |
|
|
|
|
@ -205,49 +206,22 @@ func (cs CallStack) Format(s fmt.State, verb rune) { |
|
|
|
|
s.Write(closeBracketBytes) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// findSigpanic intentionally executes faulting code to generate a stack trace
|
|
|
|
|
// containing an entry for runtime.sigpanic.
|
|
|
|
|
func findSigpanic() *runtime.Func { |
|
|
|
|
var fn *runtime.Func |
|
|
|
|
var p *int |
|
|
|
|
func() int { |
|
|
|
|
defer func() { |
|
|
|
|
if p := recover(); p != nil { |
|
|
|
|
var pcs [512]uintptr |
|
|
|
|
n := runtime.Callers(2, pcs[:]) |
|
|
|
|
for _, pc := range pcs[:n] { |
|
|
|
|
f := runtime.FuncForPC(pc) |
|
|
|
|
if f.Name() == "runtime.sigpanic" { |
|
|
|
|
fn = f |
|
|
|
|
break |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
}() |
|
|
|
|
// intentional nil pointer dereference to trigger sigpanic
|
|
|
|
|
return *p |
|
|
|
|
}() |
|
|
|
|
return fn |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
var sigpanic = findSigpanic() |
|
|
|
|
|
|
|
|
|
// Trace returns a CallStack for the current goroutine with element 0
|
|
|
|
|
// identifying the calling function.
|
|
|
|
|
func Trace() CallStack { |
|
|
|
|
var pcs [512]uintptr |
|
|
|
|
n := runtime.Callers(2, pcs[:]) |
|
|
|
|
cs := make([]Call, n) |
|
|
|
|
n := runtime.Callers(1, pcs[:]) |
|
|
|
|
|
|
|
|
|
for i, pc := range pcs[:n] { |
|
|
|
|
pcFix := pc |
|
|
|
|
if i > 0 && cs[i-1].fn != sigpanic { |
|
|
|
|
pcFix-- |
|
|
|
|
} |
|
|
|
|
cs[i] = Call{ |
|
|
|
|
fn: runtime.FuncForPC(pcFix), |
|
|
|
|
pc: pcFix, |
|
|
|
|
} |
|
|
|
|
frames := runtime.CallersFrames(pcs[:n]) |
|
|
|
|
cs := make(CallStack, 0, n) |
|
|
|
|
|
|
|
|
|
// Skip extra frame retrieved just to make sure the runtime.sigpanic
|
|
|
|
|
// special case is handled.
|
|
|
|
|
frame, more := frames.Next() |
|
|
|
|
|
|
|
|
|
for more { |
|
|
|
|
frame, more = frames.Next() |
|
|
|
|
cs = append(cs, Call{frame: frame}) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return cs |
|
|
|
|
@ -256,7 +230,7 @@ func Trace() CallStack { |
|
|
|
|
// TrimBelow returns a slice of the CallStack with all entries below c
|
|
|
|
|
// removed.
|
|
|
|
|
func (cs CallStack) TrimBelow(c Call) CallStack { |
|
|
|
|
for len(cs) > 0 && cs[0].pc != c.pc { |
|
|
|
|
for len(cs) > 0 && cs[0] != c { |
|
|
|
|
cs = cs[1:] |
|
|
|
|
} |
|
|
|
|
return cs |
|
|
|
|
@ -265,7 +239,7 @@ func (cs CallStack) TrimBelow(c Call) CallStack { |
|
|
|
|
// TrimAbove returns a slice of the CallStack with all entries above c
|
|
|
|
|
// removed.
|
|
|
|
|
func (cs CallStack) TrimAbove(c Call) CallStack { |
|
|
|
|
for len(cs) > 0 && cs[len(cs)-1].pc != c.pc { |
|
|
|
|
for len(cs) > 0 && cs[len(cs)-1] != c { |
|
|
|
|
cs = cs[:len(cs)-1] |
|
|
|
|
} |
|
|
|
|
return cs |
|
|
|
|
@ -314,12 +288,13 @@ func pkgIndex(file, funcName string) int { |
|
|
|
|
var runtimePath string |
|
|
|
|
|
|
|
|
|
func init() { |
|
|
|
|
var pcs [1]uintptr |
|
|
|
|
var pcs [3]uintptr |
|
|
|
|
runtime.Callers(0, pcs[:]) |
|
|
|
|
fn := runtime.FuncForPC(pcs[0]) |
|
|
|
|
file, _ := fn.FileLine(pcs[0]) |
|
|
|
|
frames := runtime.CallersFrames(pcs[:]) |
|
|
|
|
frame, _ := frames.Next() |
|
|
|
|
file := frame.File |
|
|
|
|
|
|
|
|
|
idx := pkgIndex(file, fn.Name()) |
|
|
|
|
idx := pkgIndex(frame.File, frame.Function) |
|
|
|
|
|
|
|
|
|
runtimePath = file[:idx] |
|
|
|
|
if runtime.GOOS == "windows" { |
|
|
|
|
@ -328,7 +303,7 @@ func init() { |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func inGoroot(c Call) bool { |
|
|
|
|
file := c.file() |
|
|
|
|
file := c.frame.File |
|
|
|
|
if len(file) == 0 || file[0] == '?' { |
|
|
|
|
return true |
|
|
|
|
} |
|
|
|
|
|
Leonard Gram
8 years ago