cmd/trace: init goroutine info entries with GoCreate event

golang.org/cl/81315 attempted to distinguish system goroutines
by examining the function name in the goroutine stack. It assumes that
the information would be available when GoSysBlock or GoInSyscall
events are processed, but it turned out the stack information is
set too late (when the goroutine gets a chance to run).

This change initializes the goroutine information entry when
processing GoCreate event which should be one of the very first
events for the every goroutine in trace.

Fixes #22574

Change-Id: I1ed37087ce2e78ed27c9b419b7d942eb4140cc69
Reviewed-on: https://go-review.googlesource.com/83595
Reviewed-by: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

1 files changed, 20 insertions, 12 deletions

diff --git a/src/internal/trace/parser.go b/src/internal/trace/parser.go
index a774bf14c9..c7954f0d03 100644
--- a/src/internal/trace/parser.go
+++ b/src/internal/trace/parser.go
@@ -75,36 +75,44 @@ const (
 	GCP      // depicts GC state
 )
 
+// ParseResult is the result of Parse.
+type ParseResult struct {
+	// Events is the sorted list of Events in the trace.
+	Events []*Event
+	// Stacks is the stack traces keyed by stack IDs from the trace.
+	Stacks map[uint64][]*Frame
+}
+
 // Parse parses, post-processes and verifies the trace.
-func Parse(r io.Reader, bin string) ([]*Event, error) {
-	ver, events, err := parse(r, bin)
+func Parse(r io.Reader, bin string) (ParseResult, error) {
+	ver, res, err := parse(r, bin)
 	if err != nil {
-		return nil, err
+		return ParseResult{}, err
 	}
 	if ver < 1007 && bin == "" {
-		return nil, fmt.Errorf("for traces produced by go 1.6 or below, the binary argument must be provided")
+		return ParseResult{}, fmt.Errorf("for traces produced by go 1.6 or below, the binary argument must be provided")
 	}
-	return events, nil
+	return res, nil
 }
 
 // parse parses, post-processes and verifies the trace. It returns the
 // trace version and the list of events.
-func parse(r io.Reader, bin string) (int, []*Event, error) {
+func parse(r io.Reader, bin string) (int, ParseResult, error) {
 	ver, rawEvents, strings, err := readTrace(r)
 	if err != nil {
-		return 0, nil, err
+		return 0, ParseResult{}, err
 	}
 	events, stacks, err := parseEvents(ver, rawEvents, strings)
 	if err != nil {
-		return 0, nil, err
+		return 0, ParseResult{}, err
 	}
 	events, err = removeFutile(events)
 	if err != nil {
-		return 0, nil, err
+		return 0, ParseResult{}, err
 	}
 	err = postProcessTrace(ver, events)
 	if err != nil {
-		return 0, nil, err
+		return 0, ParseResult{}, err
 	}
 	// Attach stack traces.
 	for _, ev := range events {
@@ -114,10 +122,10 @@ func parse(r io.Reader, bin string) (int, []*Event, error) {
 	}
 	if ver < 1007 && bin != "" {
 		if err := symbolize(events, bin); err != nil {
-			return 0, nil, err
+			return 0, ParseResult{}, err
 		}
 	}
-	return ver, events, nil
+	return ver, ParseResult{Events: events, Stacks: stacks}, nil
 }
 
 // rawEvent is a helper type used during parsing.