| // Copyright 2016 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 pprof |
| |
| import ( |
| "bytes" |
| "compress/gzip" |
| "fmt" |
| "internal/abi" |
| "io" |
| "os" |
| "runtime" |
| "strconv" |
| "strings" |
| "time" |
| "unsafe" |
| ) |
| |
| // lostProfileEvent is the function to which lost profiling |
| // events are attributed. |
| // (The name shows up in the pprof graphs.) |
| func lostProfileEvent() { lostProfileEvent() } |
| |
| // A profileBuilder writes a profile incrementally from a |
| // stream of profile samples delivered by the runtime. |
| type profileBuilder struct { |
| start time.Time |
| end time.Time |
| havePeriod bool |
| period int64 |
| m profMap |
| |
| // encoding state |
| w io.Writer |
| zw *gzip.Writer |
| pb protobuf |
| strings []string |
| stringMap map[string]int |
| locs map[uintptr]locInfo // list of locInfo starting with the given PC. |
| funcs map[string]int // Package path-qualified function name to Function.ID |
| mem []memMap |
| deck pcDeck |
| } |
| |
| type memMap struct { |
| // initialized as reading mapping |
| start uintptr // Address at which the binary (or DLL) is loaded into memory. |
| end uintptr // The limit of the address range occupied by this mapping. |
| offset uint64 // Offset in the binary that corresponds to the first mapped address. |
| file string // The object this entry is loaded from. |
| buildID string // A string that uniquely identifies a particular program version with high probability. |
| |
| funcs symbolizeFlag |
| fake bool // map entry was faked; /proc/self/maps wasn't available |
| } |
| |
| // symbolizeFlag keeps track of symbolization result. |
| // |
| // 0 : no symbol lookup was performed |
| // 1<<0 (lookupTried) : symbol lookup was performed |
| // 1<<1 (lookupFailed): symbol lookup was performed but failed |
| type symbolizeFlag uint8 |
| |
| const ( |
| lookupTried symbolizeFlag = 1 << iota |
| lookupFailed symbolizeFlag = 1 << iota |
| ) |
| |
| const ( |
| // message Profile |
| tagProfile_SampleType = 1 // repeated ValueType |
| tagProfile_Sample = 2 // repeated Sample |
| tagProfile_Mapping = 3 // repeated Mapping |
| tagProfile_Location = 4 // repeated Location |
| tagProfile_Function = 5 // repeated Function |
| tagProfile_StringTable = 6 // repeated string |
| tagProfile_DropFrames = 7 // int64 (string table index) |
| tagProfile_KeepFrames = 8 // int64 (string table index) |
| tagProfile_TimeNanos = 9 // int64 |
| tagProfile_DurationNanos = 10 // int64 |
| tagProfile_PeriodType = 11 // ValueType (really optional string???) |
| tagProfile_Period = 12 // int64 |
| tagProfile_Comment = 13 // repeated int64 |
| tagProfile_DefaultSampleType = 14 // int64 |
| |
| // message ValueType |
| tagValueType_Type = 1 // int64 (string table index) |
| tagValueType_Unit = 2 // int64 (string table index) |
| |
| // message Sample |
| tagSample_Location = 1 // repeated uint64 |
| tagSample_Value = 2 // repeated int64 |
| tagSample_Label = 3 // repeated Label |
| |
| // message Label |
| tagLabel_Key = 1 // int64 (string table index) |
| tagLabel_Str = 2 // int64 (string table index) |
| tagLabel_Num = 3 // int64 |
| |
| // message Mapping |
| tagMapping_ID = 1 // uint64 |
| tagMapping_Start = 2 // uint64 |
| tagMapping_Limit = 3 // uint64 |
| tagMapping_Offset = 4 // uint64 |
| tagMapping_Filename = 5 // int64 (string table index) |
| tagMapping_BuildID = 6 // int64 (string table index) |
| tagMapping_HasFunctions = 7 // bool |
| tagMapping_HasFilenames = 8 // bool |
| tagMapping_HasLineNumbers = 9 // bool |
| tagMapping_HasInlineFrames = 10 // bool |
| |
| // message Location |
| tagLocation_ID = 1 // uint64 |
| tagLocation_MappingID = 2 // uint64 |
| tagLocation_Address = 3 // uint64 |
| tagLocation_Line = 4 // repeated Line |
| |
| // message Line |
| tagLine_FunctionID = 1 // uint64 |
| tagLine_Line = 2 // int64 |
| |
| // message Function |
| tagFunction_ID = 1 // uint64 |
| tagFunction_Name = 2 // int64 (string table index) |
| tagFunction_SystemName = 3 // int64 (string table index) |
| tagFunction_Filename = 4 // int64 (string table index) |
| tagFunction_StartLine = 5 // int64 |
| ) |
| |
| // stringIndex adds s to the string table if not already present |
| // and returns the index of s in the string table. |
| func (b *profileBuilder) stringIndex(s string) int64 { |
| id, ok := b.stringMap[s] |
| if !ok { |
| id = len(b.strings) |
| b.strings = append(b.strings, s) |
| b.stringMap[s] = id |
| } |
| return int64(id) |
| } |
| |
| func (b *profileBuilder) flush() { |
| const dataFlush = 4096 |
| if b.pb.nest == 0 && len(b.pb.data) > dataFlush { |
| b.zw.Write(b.pb.data) |
| b.pb.data = b.pb.data[:0] |
| } |
| } |
| |
| // pbValueType encodes a ValueType message to b.pb. |
| func (b *profileBuilder) pbValueType(tag int, typ, unit string) { |
| start := b.pb.startMessage() |
| b.pb.int64(tagValueType_Type, b.stringIndex(typ)) |
| b.pb.int64(tagValueType_Unit, b.stringIndex(unit)) |
| b.pb.endMessage(tag, start) |
| } |
| |
| // pbSample encodes a Sample message to b.pb. |
| func (b *profileBuilder) pbSample(values []int64, locs []uint64, labels func()) { |
| start := b.pb.startMessage() |
| b.pb.int64s(tagSample_Value, values) |
| b.pb.uint64s(tagSample_Location, locs) |
| if labels != nil { |
| labels() |
| } |
| b.pb.endMessage(tagProfile_Sample, start) |
| b.flush() |
| } |
| |
| // pbLabel encodes a Label message to b.pb. |
| func (b *profileBuilder) pbLabel(tag int, key, str string, num int64) { |
| start := b.pb.startMessage() |
| b.pb.int64Opt(tagLabel_Key, b.stringIndex(key)) |
| b.pb.int64Opt(tagLabel_Str, b.stringIndex(str)) |
| b.pb.int64Opt(tagLabel_Num, num) |
| b.pb.endMessage(tag, start) |
| } |
| |
| // pbLine encodes a Line message to b.pb. |
| func (b *profileBuilder) pbLine(tag int, funcID uint64, line int64) { |
| start := b.pb.startMessage() |
| b.pb.uint64Opt(tagLine_FunctionID, funcID) |
| b.pb.int64Opt(tagLine_Line, line) |
| b.pb.endMessage(tag, start) |
| } |
| |
| // pbMapping encodes a Mapping message to b.pb. |
| func (b *profileBuilder) pbMapping(tag int, id, base, limit, offset uint64, file, buildID string, hasFuncs bool) { |
| start := b.pb.startMessage() |
| b.pb.uint64Opt(tagMapping_ID, id) |
| b.pb.uint64Opt(tagMapping_Start, base) |
| b.pb.uint64Opt(tagMapping_Limit, limit) |
| b.pb.uint64Opt(tagMapping_Offset, offset) |
| b.pb.int64Opt(tagMapping_Filename, b.stringIndex(file)) |
| b.pb.int64Opt(tagMapping_BuildID, b.stringIndex(buildID)) |
| // TODO: we set HasFunctions if all symbols from samples were symbolized (hasFuncs). |
| // Decide what to do about HasInlineFrames and HasLineNumbers. |
| // Also, another approach to handle the mapping entry with |
| // incomplete symbolization results is to duplicate the mapping |
| // entry (but with different Has* fields values) and use |
| // different entries for symbolized locations and unsymbolized locations. |
| if hasFuncs { |
| b.pb.bool(tagMapping_HasFunctions, true) |
| } |
| b.pb.endMessage(tag, start) |
| } |
| |
| func allFrames(addr uintptr) ([]runtime.Frame, symbolizeFlag) { |
| // Expand this one address using CallersFrames so we can cache |
| // each expansion. In general, CallersFrames takes a whole |
| // stack, but in this case we know there will be no skips in |
| // the stack and we have return PCs anyway. |
| frames := runtime.CallersFrames([]uintptr{addr}) |
| frame, more := frames.Next() |
| if frame.Function == "runtime.goexit" { |
| // Short-circuit if we see runtime.goexit so the loop |
| // below doesn't allocate a useless empty location. |
| return nil, 0 |
| } |
| |
| symbolizeResult := lookupTried |
| if frame.PC == 0 || frame.Function == "" || frame.File == "" || frame.Line == 0 { |
| symbolizeResult |= lookupFailed |
| } |
| |
| if frame.PC == 0 { |
| // If we failed to resolve the frame, at least make up |
| // a reasonable call PC. This mostly happens in tests. |
| frame.PC = addr - 1 |
| } |
| ret := []runtime.Frame{frame} |
| for frame.Function != "runtime.goexit" && more { |
| frame, more = frames.Next() |
| ret = append(ret, frame) |
| } |
| return ret, symbolizeResult |
| } |
| |
| type locInfo struct { |
| // location id assigned by the profileBuilder |
| id uint64 |
| |
| // sequence of PCs, including the fake PCs returned by the traceback |
| // to represent inlined functions |
| // https://github.com/golang/go/blob/d6f2f833c93a41ec1c68e49804b8387a06b131c5/src/runtime/traceback.go#L347-L368 |
| pcs []uintptr |
| |
| // firstPCFrames and firstPCSymbolizeResult hold the results of the |
| // allFrames call for the first (leaf-most) PC this locInfo represents |
| firstPCFrames []runtime.Frame |
| firstPCSymbolizeResult symbolizeFlag |
| } |
| |
| // newProfileBuilder returns a new profileBuilder. |
| // CPU profiling data obtained from the runtime can be added |
| // by calling b.addCPUData, and then the eventual profile |
| // can be obtained by calling b.finish. |
| func newProfileBuilder(w io.Writer) *profileBuilder { |
| zw, _ := gzip.NewWriterLevel(w, gzip.BestSpeed) |
| b := &profileBuilder{ |
| w: w, |
| zw: zw, |
| start: time.Now(), |
| strings: []string{""}, |
| stringMap: map[string]int{"": 0}, |
| locs: map[uintptr]locInfo{}, |
| funcs: map[string]int{}, |
| } |
| b.readMapping() |
| return b |
| } |
| |
| // addCPUData adds the CPU profiling data to the profile. |
| // |
| // The data must be a whole number of records, as delivered by the runtime. |
| // len(tags) must be equal to the number of records in data. |
| func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error { |
| if !b.havePeriod { |
| // first record is period |
| if len(data) < 3 { |
| return fmt.Errorf("truncated profile") |
| } |
| if data[0] != 3 || data[2] == 0 { |
| return fmt.Errorf("malformed profile") |
| } |
| // data[2] is sampling rate in Hz. Convert to sampling |
| // period in nanoseconds. |
| b.period = 1e9 / int64(data[2]) |
| b.havePeriod = true |
| data = data[3:] |
| // Consume tag slot. Note that there isn't a meaningful tag |
| // value for this record. |
| tags = tags[1:] |
| } |
| |
| // Parse CPU samples from the profile. |
| // Each sample is 3+n uint64s: |
| // data[0] = 3+n |
| // data[1] = time stamp (ignored) |
| // data[2] = count |
| // data[3:3+n] = stack |
| // If the count is 0 and the stack has length 1, |
| // that's an overflow record inserted by the runtime |
| // to indicate that stack[0] samples were lost. |
| // Otherwise the count is usually 1, |
| // but in a few special cases like lost non-Go samples |
| // there can be larger counts. |
| // Because many samples with the same stack arrive, |
| // we want to deduplicate immediately, which we do |
| // using the b.m profMap. |
| for len(data) > 0 { |
| if len(data) < 3 || data[0] > uint64(len(data)) { |
| return fmt.Errorf("truncated profile") |
| } |
| if data[0] < 3 || tags != nil && len(tags) < 1 { |
| return fmt.Errorf("malformed profile") |
| } |
| if len(tags) < 1 { |
| return fmt.Errorf("mismatched profile records and tags") |
| } |
| count := data[2] |
| stk := data[3:data[0]] |
| data = data[data[0]:] |
| tag := tags[0] |
| tags = tags[1:] |
| |
| if count == 0 && len(stk) == 1 { |
| // overflow record |
| count = uint64(stk[0]) |
| stk = []uint64{ |
| // gentraceback guarantees that PCs in the |
| // stack can be unconditionally decremented and |
| // still be valid, so we must do the same. |
| uint64(abi.FuncPCABIInternal(lostProfileEvent) + 1), |
| } |
| } |
| b.m.lookup(stk, tag).count += int64(count) |
| } |
| |
| if len(tags) != 0 { |
| return fmt.Errorf("mismatched profile records and tags") |
| } |
| return nil |
| } |
| |
| // build completes and returns the constructed profile. |
| func (b *profileBuilder) build() { |
| b.end = time.Now() |
| |
| b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano()) |
| if b.havePeriod { // must be CPU profile |
| b.pbValueType(tagProfile_SampleType, "samples", "count") |
| b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds") |
| b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds()) |
| b.pbValueType(tagProfile_PeriodType, "cpu", "nanoseconds") |
| b.pb.int64Opt(tagProfile_Period, b.period) |
| } |
| |
| values := []int64{0, 0} |
| var locs []uint64 |
| |
| for e := b.m.all; e != nil; e = e.nextAll { |
| values[0] = e.count |
| values[1] = e.count * b.period |
| |
| var labels func() |
| if e.tag != nil { |
| labels = func() { |
| for k, v := range *(*labelMap)(e.tag) { |
| b.pbLabel(tagSample_Label, k, v, 0) |
| } |
| } |
| } |
| |
| locs = b.appendLocsForStack(locs[:0], e.stk) |
| |
| b.pbSample(values, locs, labels) |
| } |
| |
| for i, m := range b.mem { |
| hasFunctions := m.funcs == lookupTried // lookupTried but not lookupFailed |
| b.pbMapping(tagProfile_Mapping, uint64(i+1), uint64(m.start), uint64(m.end), m.offset, m.file, m.buildID, hasFunctions) |
| } |
| |
| // TODO: Anything for tagProfile_DropFrames? |
| // TODO: Anything for tagProfile_KeepFrames? |
| |
| b.pb.strings(tagProfile_StringTable, b.strings) |
| b.zw.Write(b.pb.data) |
| b.zw.Close() |
| } |
| |
| // appendLocsForStack appends the location IDs for the given stack trace to the given |
| // location ID slice, locs. The addresses in the stack are return PCs or 1 + the PC of |
| // an inline marker as the runtime traceback function returns. |
| // |
| // It may return an empty slice even if locs is non-empty, for example if locs consists |
| // solely of runtime.goexit. We still count these empty stacks in profiles in order to |
| // get the right cumulative sample count. |
| // |
| // It may emit to b.pb, so there must be no message encoding in progress. |
| func (b *profileBuilder) appendLocsForStack(locs []uint64, stk []uintptr) (newLocs []uint64) { |
| b.deck.reset() |
| |
| // The last frame might be truncated. Recover lost inline frames. |
| stk = runtime_expandFinalInlineFrame(stk) |
| |
| for len(stk) > 0 { |
| addr := stk[0] |
| if l, ok := b.locs[addr]; ok { |
| // When generating code for an inlined function, the compiler adds |
| // NOP instructions to the outermost function as a placeholder for |
| // each layer of inlining. When the runtime generates tracebacks for |
| // stacks that include inlined functions, it uses the addresses of |
| // those NOPs as "fake" PCs on the stack as if they were regular |
| // function call sites. But if a profiling signal arrives while the |
| // CPU is executing one of those NOPs, its PC will show up as a leaf |
| // in the profile with its own Location entry. So, always check |
| // whether addr is a "fake" PC in the context of the current call |
| // stack by trying to add it to the inlining deck before assuming |
| // that the deck is complete. |
| if len(b.deck.pcs) > 0 { |
| if added := b.deck.tryAdd(addr, l.firstPCFrames, l.firstPCSymbolizeResult); added { |
| stk = stk[1:] |
| continue |
| } |
| } |
| |
| // first record the location if there is any pending accumulated info. |
| if id := b.emitLocation(); id > 0 { |
| locs = append(locs, id) |
| } |
| |
| // then, record the cached location. |
| locs = append(locs, l.id) |
| |
| // Skip the matching pcs. |
| // |
| // Even if stk was truncated due to the stack depth |
| // limit, expandFinalInlineFrame above has already |
| // fixed the truncation, ensuring it is long enough. |
| if len(l.pcs) > len(stk) { |
| // Temporary logging for golang.org/issues/40823 |
| dumpState(l, stk) |
| } |
| stk = stk[len(l.pcs):] |
| continue |
| } |
| |
| frames, symbolizeResult := allFrames(addr) |
| if len(frames) == 0 { // runtime.goexit. |
| if id := b.emitLocation(); id > 0 { |
| locs = append(locs, id) |
| } |
| stk = stk[1:] |
| continue |
| } |
| |
| if added := b.deck.tryAdd(addr, frames, symbolizeResult); added { |
| stk = stk[1:] |
| continue |
| } |
| // add failed because this addr is not inlined with the |
| // existing PCs in the deck. Flush the deck and retry handling |
| // this pc. |
| if id := b.emitLocation(); id > 0 { |
| locs = append(locs, id) |
| } |
| |
| // check cache again - previous emitLocation added a new entry |
| if l, ok := b.locs[addr]; ok { |
| locs = append(locs, l.id) |
| stk = stk[len(l.pcs):] // skip the matching pcs. |
| } else { |
| b.deck.tryAdd(addr, frames, symbolizeResult) // must succeed. |
| stk = stk[1:] |
| } |
| } |
| if id := b.emitLocation(); id > 0 { // emit remaining location. |
| locs = append(locs, id) |
| } |
| return locs |
| } |
| |
| func dumpState(l locInfo, stk []uintptr) { |
| buf := new(bytes.Buffer) |
| buf.WriteString("stk:") |
| printStackRecord(buf, stk, true) |
| buf.WriteString("\n") |
| buf.WriteString("l.pcs:") |
| printStackRecord(buf, l.pcs, true) |
| fmt.Fprintln(os.Stderr, buf.String()) |
| } |
| |
| // Here's an example of how Go 1.17 writes out inlined functions, compiled for |
| // linux/amd64. The disassembly of main.main shows two levels of inlining: main |
| // calls b, b calls a, a does some work. |
| // |
| // inline.go:9 0x4553ec 90 NOPL // func main() { b(v) } |
| // inline.go:6 0x4553ed 90 NOPL // func b(v *int) { a(v) } |
| // inline.go:5 0x4553ee 48c7002a000000 MOVQ $0x2a, 0(AX) // func a(v *int) { *v = 42 } |
| // |
| // If a profiling signal arrives while executing the MOVQ at 0x4553ee (for line |
| // 5), the runtime will report the stack as the MOVQ frame being called by the |
| // NOPL at 0x4553ed (for line 6) being called by the NOPL at 0x4553ec (for line |
| // 9). |
| // |
| // The role of pcDeck is to collapse those three frames back into a single |
| // location at 0x4553ee, with file/line/function symbolization info representing |
| // the three layers of calls. It does that via sequential calls to pcDeck.tryAdd |
| // starting with the leaf-most address. The fourth call to pcDeck.tryAdd will be |
| // for the caller of main.main. Because main.main was not inlined in its caller, |
| // the deck will reject the addition, and the fourth PC on the stack will get |
| // its own location. |
| |
| // pcDeck is a helper to detect a sequence of inlined functions from |
| // a stack trace returned by the runtime. |
| // |
| // The stack traces returned by runtime's trackback functions are fully |
| // expanded (at least for Go functions) and include the fake pcs representing |
| // inlined functions. The profile proto expects the inlined functions to be |
| // encoded in one Location message. |
| // https://github.com/google/pprof/blob/5e965273ee43930341d897407202dd5e10e952cb/proto/profile.proto#L177-L184 |
| // |
| // Runtime does not directly expose whether a frame is for an inlined function |
| // and looking up debug info is not ideal, so we use a heuristic to filter |
| // the fake pcs and restore the inlined and entry functions. Inlined functions |
| // have the following properties: |
| // |
| // Frame's Func is nil (note: also true for non-Go functions), and |
| // Frame's Entry matches its entry function frame's Entry (note: could also be true for recursive calls and non-Go functions), and |
| // Frame's Name does not match its entry function frame's name (note: inlined functions cannot be directly recursive). |
| // |
| // As reading and processing the pcs in a stack trace one by one (from leaf to the root), |
| // we use pcDeck to temporarily hold the observed pcs and their expanded frames |
| // until we observe the entry function frame. |
| type pcDeck struct { |
| pcs []uintptr |
| frames []runtime.Frame |
| symbolizeResult symbolizeFlag |
| |
| // firstPCFrames indicates the number of frames associated with the first |
| // (leaf-most) PC in the deck |
| firstPCFrames int |
| // firstPCSymbolizeResult holds the results of the allFrames call for the |
| // first (leaf-most) PC in the deck |
| firstPCSymbolizeResult symbolizeFlag |
| } |
| |
| func (d *pcDeck) reset() { |
| d.pcs = d.pcs[:0] |
| d.frames = d.frames[:0] |
| d.symbolizeResult = 0 |
| d.firstPCFrames = 0 |
| d.firstPCSymbolizeResult = 0 |
| } |
| |
| // tryAdd tries to add the pc and Frames expanded from it (most likely one, |
| // since the stack trace is already fully expanded) and the symbolizeResult |
| // to the deck. If it fails the caller needs to flush the deck and retry. |
| func (d *pcDeck) tryAdd(pc uintptr, frames []runtime.Frame, symbolizeResult symbolizeFlag) (success bool) { |
| if existing := len(d.frames); existing > 0 { |
| // 'd.frames' are all expanded from one 'pc' and represent all |
| // inlined functions so we check only the last one. |
| newFrame := frames[0] |
| last := d.frames[existing-1] |
| if last.Func != nil { // the last frame can't be inlined. Flush. |
| return false |
| } |
| if last.Entry == 0 || newFrame.Entry == 0 { // Possibly not a Go function. Don't try to merge. |
| return false |
| } |
| |
| if last.Entry != newFrame.Entry { // newFrame is for a different function. |
| return false |
| } |
| if last.Function == newFrame.Function { // maybe recursion. |
| return false |
| } |
| } |
| d.pcs = append(d.pcs, pc) |
| d.frames = append(d.frames, frames...) |
| d.symbolizeResult |= symbolizeResult |
| if len(d.pcs) == 1 { |
| d.firstPCFrames = len(d.frames) |
| d.firstPCSymbolizeResult = symbolizeResult |
| } |
| return true |
| } |
| |
| // emitLocation emits the new location and function information recorded in the deck |
| // and returns the location ID encoded in the profile protobuf. |
| // It emits to b.pb, so there must be no message encoding in progress. |
| // It resets the deck. |
| func (b *profileBuilder) emitLocation() uint64 { |
| if len(b.deck.pcs) == 0 { |
| return 0 |
| } |
| defer b.deck.reset() |
| |
| addr := b.deck.pcs[0] |
| firstFrame := b.deck.frames[0] |
| |
| // We can't write out functions while in the middle of the |
| // Location message, so record new functions we encounter and |
| // write them out after the Location. |
| type newFunc struct { |
| id uint64 |
| name, file string |
| startLine int64 |
| } |
| newFuncs := make([]newFunc, 0, 8) |
| |
| id := uint64(len(b.locs)) + 1 |
| b.locs[addr] = locInfo{ |
| id: id, |
| pcs: append([]uintptr{}, b.deck.pcs...), |
| firstPCSymbolizeResult: b.deck.firstPCSymbolizeResult, |
| firstPCFrames: append([]runtime.Frame{}, b.deck.frames[:b.deck.firstPCFrames]...), |
| } |
| |
| start := b.pb.startMessage() |
| b.pb.uint64Opt(tagLocation_ID, id) |
| b.pb.uint64Opt(tagLocation_Address, uint64(firstFrame.PC)) |
| for _, frame := range b.deck.frames { |
| // Write out each line in frame expansion. |
| funcName := runtime_FrameSymbolName(&frame) |
| funcID := uint64(b.funcs[funcName]) |
| if funcID == 0 { |
| funcID = uint64(len(b.funcs)) + 1 |
| b.funcs[funcName] = int(funcID) |
| newFuncs = append(newFuncs, newFunc{ |
| id: funcID, |
| name: funcName, |
| file: frame.File, |
| startLine: int64(runtime_FrameStartLine(&frame)), |
| }) |
| } |
| b.pbLine(tagLocation_Line, funcID, int64(frame.Line)) |
| } |
| for i := range b.mem { |
| if b.mem[i].start <= addr && addr < b.mem[i].end || b.mem[i].fake { |
| b.pb.uint64Opt(tagLocation_MappingID, uint64(i+1)) |
| |
| m := b.mem[i] |
| m.funcs |= b.deck.symbolizeResult |
| b.mem[i] = m |
| break |
| } |
| } |
| b.pb.endMessage(tagProfile_Location, start) |
| |
| // Write out functions we found during frame expansion. |
| for _, fn := range newFuncs { |
| start := b.pb.startMessage() |
| b.pb.uint64Opt(tagFunction_ID, fn.id) |
| b.pb.int64Opt(tagFunction_Name, b.stringIndex(fn.name)) |
| b.pb.int64Opt(tagFunction_SystemName, b.stringIndex(fn.name)) |
| b.pb.int64Opt(tagFunction_Filename, b.stringIndex(fn.file)) |
| b.pb.int64Opt(tagFunction_StartLine, fn.startLine) |
| b.pb.endMessage(tagProfile_Function, start) |
| } |
| |
| b.flush() |
| return id |
| } |
| |
| var space = []byte(" ") |
| var newline = []byte("\n") |
| |
| func parseProcSelfMaps(data []byte, addMapping func(lo, hi, offset uint64, file, buildID string)) { |
| // $ cat /proc/self/maps |
| // 00400000-0040b000 r-xp 00000000 fc:01 787766 /bin/cat |
| // 0060a000-0060b000 r--p 0000a000 fc:01 787766 /bin/cat |
| // 0060b000-0060c000 rw-p 0000b000 fc:01 787766 /bin/cat |
| // 014ab000-014cc000 rw-p 00000000 00:00 0 [heap] |
| // 7f7d76af8000-7f7d7797c000 r--p 00000000 fc:01 1318064 /usr/lib/locale/locale-archive |
| // 7f7d7797c000-7f7d77b36000 r-xp 00000000 fc:01 1180226 /lib/x86_64-linux-gnu/libc-2.19.so |
| // 7f7d77b36000-7f7d77d36000 ---p 001ba000 fc:01 1180226 /lib/x86_64-linux-gnu/libc-2.19.so |
| // 7f7d77d36000-7f7d77d3a000 r--p 001ba000 fc:01 1180226 /lib/x86_64-linux-gnu/libc-2.19.so |
| // 7f7d77d3a000-7f7d77d3c000 rw-p 001be000 fc:01 1180226 /lib/x86_64-linux-gnu/libc-2.19.so |
| // 7f7d77d3c000-7f7d77d41000 rw-p 00000000 00:00 0 |
| // 7f7d77d41000-7f7d77d64000 r-xp 00000000 fc:01 1180217 /lib/x86_64-linux-gnu/ld-2.19.so |
| // 7f7d77f3f000-7f7d77f42000 rw-p 00000000 00:00 0 |
| // 7f7d77f61000-7f7d77f63000 rw-p 00000000 00:00 0 |
| // 7f7d77f63000-7f7d77f64000 r--p 00022000 fc:01 1180217 /lib/x86_64-linux-gnu/ld-2.19.so |
| // 7f7d77f64000-7f7d77f65000 rw-p 00023000 fc:01 1180217 /lib/x86_64-linux-gnu/ld-2.19.so |
| // 7f7d77f65000-7f7d77f66000 rw-p 00000000 00:00 0 |
| // 7ffc342a2000-7ffc342c3000 rw-p 00000000 00:00 0 [stack] |
| // 7ffc34343000-7ffc34345000 r-xp 00000000 00:00 0 [vdso] |
| // ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall] |
| |
| var line []byte |
| // next removes and returns the next field in the line. |
| // It also removes from line any spaces following the field. |
| next := func() []byte { |
| var f []byte |
| f, line, _ = bytes.Cut(line, space) |
| line = bytes.TrimLeft(line, " ") |
| return f |
| } |
| |
| for len(data) > 0 { |
| line, data, _ = bytes.Cut(data, newline) |
| addr := next() |
| loStr, hiStr, ok := strings.Cut(string(addr), "-") |
| if !ok { |
| continue |
| } |
| lo, err := strconv.ParseUint(loStr, 16, 64) |
| if err != nil { |
| continue |
| } |
| hi, err := strconv.ParseUint(hiStr, 16, 64) |
| if err != nil { |
| continue |
| } |
| perm := next() |
| if len(perm) < 4 || perm[2] != 'x' { |
| // Only interested in executable mappings. |
| continue |
| } |
| offset, err := strconv.ParseUint(string(next()), 16, 64) |
| if err != nil { |
| continue |
| } |
| next() // dev |
| inode := next() // inode |
| if line == nil { |
| continue |
| } |
| file := string(line) |
| |
| // Trim deleted file marker. |
| deletedStr := " (deleted)" |
| deletedLen := len(deletedStr) |
| if len(file) >= deletedLen && file[len(file)-deletedLen:] == deletedStr { |
| file = file[:len(file)-deletedLen] |
| } |
| |
| if len(inode) == 1 && inode[0] == '0' && file == "" { |
| // Huge-page text mappings list the initial fragment of |
| // mapped but unpopulated memory as being inode 0. |
| // Don't report that part. |
| // But [vdso] and [vsyscall] are inode 0, so let non-empty file names through. |
| continue |
| } |
| |
| // TODO: pprof's remapMappingIDs makes one adjustment: |
| // 1. If there is an /anon_hugepage mapping first and it is |
| // consecutive to a next mapping, drop the /anon_hugepage. |
| // There's no indication why this is needed. |
| // Let's try not doing this and see what breaks. |
| // If we do need it, it would go here, before we |
| // enter the mappings into b.mem in the first place. |
| |
| buildID, _ := elfBuildID(file) |
| addMapping(lo, hi, offset, file, buildID) |
| } |
| } |
| |
| func (b *profileBuilder) addMapping(lo, hi, offset uint64, file, buildID string) { |
| b.addMappingEntry(lo, hi, offset, file, buildID, false) |
| } |
| |
| func (b *profileBuilder) addMappingEntry(lo, hi, offset uint64, file, buildID string, fake bool) { |
| b.mem = append(b.mem, memMap{ |
| start: uintptr(lo), |
| end: uintptr(hi), |
| offset: offset, |
| file: file, |
| buildID: buildID, |
| fake: fake, |
| }) |
| } |