x/debug: add a function for reading the current (not-dead) goroutines from a target program.
Moves some string-reading code from print.go into a separate function in
peek.go. Also adds functions for reading string fields in structs, and
C-style NUL-terminated strings,
Change-Id: I399960891ce7d3ab0c989b94021db284dc095a59
Reviewed-on: https://go-review.googlesource.com/19248
Reviewed-by: Dave Day <djd@golang.org>
diff --git a/ogle/demo/ogler/ogler_test.go b/ogle/demo/ogler/ogler_test.go
index cab7f94..1e44705 100644
--- a/ogle/demo/ogler/ogler_test.go
+++ b/ogle/demo/ogler/ogler_test.go
@@ -458,6 +458,14 @@
log.Fatalf("Resume: %v", err)
}
+ gs, err := prog.Goroutines()
+ if err != nil {
+ t.Fatalf("Goroutines(): got error %s", err)
+ }
+ for _, g := range gs {
+ fmt.Println(g)
+ }
+
frames, err := prog.Frames(100)
if err != nil {
log.Fatalf("prog.Frames error: %v", err)
diff --git a/ogle/program/client/client.go b/ogle/program/client/client.go
index 6083d04..51bf1a5 100644
--- a/ogle/program/client/client.go
+++ b/ogle/program/client/client.go
@@ -241,6 +241,13 @@
return resp.Frames, err
}
+func (p *Program) Goroutines() ([]*program.Goroutine, error) {
+ req := proxyrpc.GoroutinesRequest{}
+ var resp proxyrpc.GoroutinesResponse
+ err := p.client.Call("Server.Goroutines", &req, &resp)
+ return resp.Goroutines, err
+}
+
func (p *Program) VarByName(name string) (program.Var, error) {
req := proxyrpc.VarByNameRequest{Name: name}
var resp proxyrpc.VarByNameResponse
diff --git a/ogle/program/local/local.go b/ogle/program/local/local.go
index 55f8c12..ed9bdc8 100644
--- a/ogle/program/local/local.go
+++ b/ogle/program/local/local.go
@@ -126,6 +126,13 @@
return resp.Frames, err
}
+func (l *Local) Goroutines() ([]*program.Goroutine, error) {
+ req := proxyrpc.GoroutinesRequest{}
+ var resp proxyrpc.GoroutinesResponse
+ err := l.s.Goroutines(&req, &resp)
+ return resp.Goroutines, err
+}
+
func (l *Local) VarByName(name string) (program.Var, error) {
req := proxyrpc.VarByNameRequest{Name: name}
var resp proxyrpc.VarByNameResponse
diff --git a/ogle/program/program.go b/ogle/program/program.go
index b7feb20..6ac49c9 100644
--- a/ogle/program/program.go
+++ b/ogle/program/program.go
@@ -6,6 +6,7 @@
package program // import "golang.org/x/debug/ogle/program"
import (
+ "fmt"
"io"
)
@@ -105,6 +106,41 @@
// MapElement returns Vars for the key and value of a map element specified by
// a 0-based index.
MapElement(m Map, index uint64) (Var, Var, error)
+
+ // Goroutines gets the current goroutines.
+ Goroutines() ([]*Goroutine, error)
+}
+
+type Goroutine struct {
+ ID int64
+ Status GoroutineStatus
+ StatusString string // A human-readable string explaining the status in more detail.
+ Function string // Name of the goroutine function.
+ Caller string // Name of the function that created this goroutine.
+}
+
+type GoroutineStatus byte
+
+const (
+ Running GoroutineStatus = iota
+ Queued
+ Blocked
+)
+
+func (g GoroutineStatus) String() string {
+ switch g {
+ case Running:
+ return "running"
+ case Queued:
+ return "queued"
+ case Blocked:
+ return "blocked"
+ }
+ return "invalid status"
+}
+
+func (g *Goroutine) String() string {
+ return fmt.Sprintf("goroutine %d [%s] %s -> %s", g.ID, g.StatusString, g.Caller, g.Function)
}
// A reference to a variable in a program.
diff --git a/ogle/program/proxyrpc/proxyrpc.go b/ogle/program/proxyrpc/proxyrpc.go
index 8ed02b4..b6636f8 100644
--- a/ogle/program/proxyrpc/proxyrpc.go
+++ b/ogle/program/proxyrpc/proxyrpc.go
@@ -156,3 +156,10 @@
Key program.Var
Value program.Var
}
+
+type GoroutinesRequest struct {
+}
+
+type GoroutinesResponse struct {
+ Goroutines []*program.Goroutine
+}
diff --git a/ogle/program/server/peek.go b/ogle/program/server/peek.go
index e61a974..936b3ab 100644
--- a/ogle/program/server/peek.go
+++ b/ogle/program/server/peek.go
@@ -54,6 +54,50 @@
return s.arch.UintN(buf), nil
}
+// peekString reads a string of the given type at the given address.
+// At most byteLimit bytes will be read. If the string is longer, "..." is appended.
+func (s *Server) peekString(typ *dwarf.StringType, a uint64, byteLimit uint64) (string, error) {
+ ptr, err := s.peekPtrStructField(&typ.StructType, a, "str")
+ if err != nil {
+ return "", err
+ }
+ length, err := s.peekUintOrIntStructField(&typ.StructType, a, "len")
+ if err != nil {
+ return "", err
+ }
+ if length > byteLimit {
+ buf := make([]byte, byteLimit, byteLimit+3)
+ if err := s.peekBytes(ptr, buf); err != nil {
+ return "", err
+ } else {
+ buf = append(buf, '.', '.', '.')
+ return string(buf), nil
+ }
+ } else {
+ buf := make([]byte, length)
+ if err := s.peekBytes(ptr, buf); err != nil {
+ return "", err
+ } else {
+ return string(buf), nil
+ }
+ }
+}
+
+// peekCString reads a NUL-terminated string at the given address.
+// At most byteLimit bytes will be read. If the string is longer, "..." is appended.
+// peekCString never returns errors; if an error occurs, the string will be truncated in some way.
+func (s *Server) peekCString(a uint64, byteLimit uint64) string {
+ buf := make([]byte, byteLimit, byteLimit+3)
+ s.peekBytes(a, buf)
+ for i, c := range buf {
+ if c == 0 {
+ return string(buf[0:i])
+ }
+ }
+ buf = append(buf, '.', '.', '.')
+ return string(buf)
+}
+
// peekPtrStructField reads a pointer in the field fieldName of the struct
// of type t at addr.
func (s *Server) peekPtrStructField(t *dwarf.StructType, addr uint64, fieldName string) (uint64, error) {
@@ -122,6 +166,21 @@
return s.peekInt(addr+uint64(f.ByteOffset), it.ByteSize)
}
+// peekStringStructField reads a string field from the struct of the given type
+// at the given address.
+// At most byteLimit bytes will be read. If the string is longer, "..." is appended.
+func (s *Server) peekStringStructField(t *dwarf.StructType, addr uint64, fieldName string, byteLimit uint64) (string, error) {
+ f, err := getField(t, fieldName)
+ if err != nil {
+ return "", fmt.Errorf("reading field %s: %s", fieldName, err)
+ }
+ st, ok := followTypedefs(f.Type).(*dwarf.StringType)
+ if !ok {
+ return "", fmt.Errorf("field %s is not a string", fieldName)
+ }
+ return s.peekString(st, addr+uint64(f.ByteOffset), byteLimit)
+}
+
// peekMapLocationAndType returns the address and DWARF type of the underlying
// struct of a map variable.
func (s *Server) peekMapLocationAndType(t *dwarf.MapType, a uint64) (uint64, *dwarf.StructType, error) {
diff --git a/ogle/program/server/print.go b/ogle/program/server/print.go
index 6c4be72..0ec0e5c 100644
--- a/ogle/program/server/print.go
+++ b/ogle/program/server/print.go
@@ -490,32 +490,11 @@
}
func (p *Printer) printStringAt(typ *dwarf.StringType, a uint64) {
- // BUG: String header appears to have fields with ByteSize == 0
- ptr, err := p.server.peekPtrStructField(&typ.StructType, a, "str")
- if err != nil {
- p.errorf("reading string: %s", err)
- return
- }
- length, err := p.server.peekUintOrIntStructField(&typ.StructType, a, "len")
- if err != nil {
- p.errorf("reading string: %s", err)
- return
- }
const maxStringSize = 100
- if length > maxStringSize {
- buf := make([]byte, maxStringSize)
- if err := p.server.peekBytes(ptr, buf); err != nil {
- p.errorf("reading string: %s", err)
- } else {
- p.printf("%q...", string(buf))
- }
+ if s, err := p.server.peekString(typ, a, maxStringSize); err != nil {
+ p.errorf("reading string: %s", err)
} else {
- buf := make([]byte, length)
- if err := p.server.peekBytes(ptr, buf); err != nil {
- p.errorf("reading string: %s", err)
- } else {
- p.printf("%q", string(buf))
- }
+ p.printf("%q", s)
}
}
diff --git a/ogle/program/server/server.go b/ogle/program/server/server.go
index ecffc18..ffa72c3 100644
--- a/ogle/program/server/server.go
+++ b/ogle/program/server/server.go
@@ -10,6 +10,7 @@
import (
"bytes"
+ "errors"
"fmt"
"os"
"regexp"
@@ -178,6 +179,8 @@
c.errc <- s.handleValue(req, c.resp.(*proxyrpc.ValueResponse))
case *proxyrpc.MapElementRequest:
c.errc <- s.handleMapElement(req, c.resp.(*proxyrpc.MapElementResponse))
+ case *proxyrpc.GoroutinesRequest:
+ c.errc <- s.handleGoroutines(req, c.resp.(*proxyrpc.GoroutinesResponse))
default:
panic(fmt.Sprintf("unexpected call request type %T", c.req))
}
@@ -833,3 +836,192 @@
}
return nil
}
+
+func (s *Server) Goroutines(req *proxyrpc.GoroutinesRequest, resp *proxyrpc.GoroutinesResponse) error {
+ return s.call(s.otherc, req, resp)
+}
+
+const invalidStatus program.GoroutineStatus = 99
+
+var (
+ gStatus = [...]program.GoroutineStatus{
+ 0: program.Queued, // _Gidle
+ 1: program.Queued, // _Grunnable
+ 2: program.Running, // _Grunning
+ 3: program.Blocked, // _Gsyscall
+ 4: program.Blocked, // _Gwaiting
+ 5: invalidStatus, // _Gmoribund_unused
+ 6: invalidStatus, // _Gdead
+ 7: invalidStatus, // _Genqueue
+ 8: program.Running, // _Gcopystack
+ }
+ gScanStatus = [...]program.GoroutineStatus{
+ 0: invalidStatus, // _Gscan + _Gidle
+ 1: program.Queued, // _Gscanrunnable
+ 2: program.Running, // _Gscanrunning
+ 3: program.Blocked, // _Gscansyscall
+ 4: program.Blocked, // _Gscanwaiting
+ 5: invalidStatus, // _Gscan + _Gmoribund_unused
+ 6: invalidStatus, // _Gscan + _Gdead
+ 7: program.Queued, // _Gscanenqueue
+ }
+ gStatusString = [...]string{
+ 0: "idle",
+ 1: "runnable",
+ 2: "running",
+ 3: "syscall",
+ 4: "waiting",
+ 8: "copystack",
+ }
+ gScanStatusString = [...]string{
+ 1: "scanrunnable",
+ 2: "scanrunning",
+ 3: "scansyscall",
+ 4: "scanwaiting",
+ 7: "scanenqueue",
+ }
+)
+
+func (s *Server) handleGoroutines(req *proxyrpc.GoroutinesRequest, resp *proxyrpc.GoroutinesResponse) error {
+ // Get DWARF type information for runtime.g.
+ ge, err := s.dwarfData.LookupEntry("runtime.g")
+ if err != nil {
+ return err
+ }
+ t, err := s.dwarfData.Type(ge.Offset)
+ if err != nil {
+ return err
+ }
+ gType, ok := followTypedefs(t).(*dwarf.StructType)
+ if !ok {
+ return errors.New("runtime.g is not a struct")
+ }
+
+ // Read runtime.allg.
+ allgEntry, err := s.dwarfData.LookupEntry("runtime.allg")
+ if err != nil {
+ return err
+ }
+ allgAddr, err := s.dwarfData.EntryLocation(allgEntry)
+ if err != nil {
+ return err
+ }
+ allg, err := s.peekPtr(allgAddr)
+ if err != nil {
+ return fmt.Errorf("reading allg: %v", err)
+ }
+
+ // Read runtime.allglen.
+ allglenEntry, err := s.dwarfData.LookupEntry("runtime.allglen")
+ if err != nil {
+ return err
+ }
+ off, err := s.dwarfData.EntryTypeOffset(allglenEntry)
+ if err != nil {
+ return err
+ }
+ allglenType, err := s.dwarfData.Type(off)
+ if err != nil {
+ return err
+ }
+ allglenAddr, err := s.dwarfData.EntryLocation(allglenEntry)
+ if err != nil {
+ return err
+ }
+ var allglen uint64
+ switch followTypedefs(allglenType).(type) {
+ case *dwarf.UintType, *dwarf.IntType:
+ allglen, err = s.peekUint(allglenAddr, allglenType.Common().ByteSize)
+ if err != nil {
+ return fmt.Errorf("reading allglen: %v", err)
+ }
+ default:
+ // Some runtimes don't specify the type for allglen. Assume it's uint32.
+ allglen, err = s.peekUint(allglenAddr, 4)
+ if err != nil {
+ return fmt.Errorf("reading allglen: %v", err)
+ }
+ if allglen != 0 {
+ break
+ }
+ // Zero? Let's try uint64.
+ allglen, err = s.peekUint(allglenAddr, 8)
+ if err != nil {
+ return fmt.Errorf("reading allglen: %v", err)
+ }
+ }
+
+ for i := uint64(0); i < allglen; i++ {
+ // allg is an array of pointers to g structs. Read allg[i].
+ g, err := s.peekPtr(allg + i*uint64(s.arch.PointerSize))
+ if err != nil {
+ return err
+ }
+ gr := program.Goroutine{}
+
+ // Read status from the field named "atomicstatus" or "status".
+ status, err := s.peekUintStructField(gType, g, "atomicstatus")
+ if err != nil {
+ status, err = s.peekUintOrIntStructField(gType, g, "status")
+ }
+ if err != nil {
+ return err
+ }
+ if status == 6 {
+ // _Gdead.
+ continue
+ }
+ gr.Status = invalidStatus
+ if status < uint64(len(gStatus)) {
+ gr.Status = gStatus[status]
+ gr.StatusString = gStatusString[status]
+ } else if status^0x1000 < uint64(len(gScanStatus)) {
+ gr.Status = gScanStatus[status^0x1000]
+ gr.StatusString = gScanStatusString[status^0x1000]
+ }
+ if gr.Status == invalidStatus {
+ return fmt.Errorf("unexpected goroutine status 0x%x", status)
+ }
+ if status == 4 || status == 0x1004 {
+ // _Gwaiting or _Gscanwaiting.
+ // Try reading waitreason to get a better value for StatusString.
+ // Depending on the runtime, waitreason may be a Go string or a C string.
+ if waitreason, err := s.peekStringStructField(gType, g, "waitreason", 80); err == nil {
+ if waitreason != "" {
+ gr.StatusString = waitreason
+ }
+ } else if ptr, err := s.peekPtrStructField(gType, g, "waitreason"); err == nil {
+ waitreason := s.peekCString(ptr, 80)
+ if waitreason != "" {
+ gr.StatusString = waitreason
+ }
+ }
+ }
+
+ gr.ID, err = s.peekIntStructField(gType, g, "goid")
+ if err != nil {
+ return err
+ }
+
+ // Best-effort attempt to get the names of the goroutine function and the
+ // function that created the goroutine. They aren't always available.
+ functionName := func(pc uint64) string {
+ entry, _, err := s.dwarfData.EntryForPC(pc)
+ if err != nil {
+ return ""
+ }
+ name, _ := entry.Val(dwarf.AttrName).(string)
+ return name
+ }
+ if startpc, err := s.peekUintStructField(gType, g, "startpc"); err == nil {
+ gr.Function = functionName(startpc)
+ }
+ if gopc, err := s.peekUintStructField(gType, g, "gopc"); err == nil {
+ gr.Caller = functionName(gopc)
+ }
+
+ resp.Goroutines = append(resp.Goroutines, &gr)
+ }
+
+ return nil
+}
