Black Lives Matter. Support the Equal Justice Initiative.

Source file src/runtime/pprof/proto.go

Documentation: runtime/pprof

     1  // Copyright 2016 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package pprof
     6  
     7  import (
     8  	"bytes"
     9  	"compress/gzip"
    10  	"fmt"
    11  	"io"
    12  	"io/ioutil"
    13  	"runtime"
    14  	"strconv"
    15  	"time"
    16  	"unsafe"
    17  )
    18  
    19  // lostProfileEvent is the function to which lost profiling
    20  // events are attributed.
    21  // (The name shows up in the pprof graphs.)
    22  func lostProfileEvent() { lostProfileEvent() }
    23  
    24  // funcPC returns the PC for the func value f.
    25  func funcPC(f interface{}) uintptr {
    26  	return *(*[2]*uintptr)(unsafe.Pointer(&f))[1]
    27  }
    28  
    29  // A profileBuilder writes a profile incrementally from a
    30  // stream of profile samples delivered by the runtime.
    31  type profileBuilder struct {
    32  	start      time.Time
    33  	end        time.Time
    34  	havePeriod bool
    35  	period     int64
    36  	m          profMap
    37  
    38  	// encoding state
    39  	w         io.Writer
    40  	zw        *gzip.Writer
    41  	pb        protobuf
    42  	strings   []string
    43  	stringMap map[string]int
    44  	locs      map[uintptr]locInfo // list of locInfo starting with the given PC.
    45  	funcs     map[string]int      // Package path-qualified function name to Function.ID
    46  	mem       []memMap
    47  	deck      pcDeck
    48  }
    49  
    50  type memMap struct {
    51  	// initialized as reading mapping
    52  	start         uintptr
    53  	end           uintptr
    54  	offset        uint64
    55  	file, buildID string
    56  
    57  	funcs symbolizeFlag
    58  	fake  bool // map entry was faked; /proc/self/maps wasn't available
    59  }
    60  
    61  // symbolizeFlag keeps track of symbolization result.
    62  //   0                  : no symbol lookup was performed
    63  //   1<<0 (lookupTried) : symbol lookup was performed
    64  //   1<<1 (lookupFailed): symbol lookup was performed but failed
    65  type symbolizeFlag uint8
    66  
    67  const (
    68  	lookupTried  symbolizeFlag = 1 << iota
    69  	lookupFailed symbolizeFlag = 1 << iota
    70  )
    71  
    72  const (
    73  	// message Profile
    74  	tagProfile_SampleType        = 1  // repeated ValueType
    75  	tagProfile_Sample            = 2  // repeated Sample
    76  	tagProfile_Mapping           = 3  // repeated Mapping
    77  	tagProfile_Location          = 4  // repeated Location
    78  	tagProfile_Function          = 5  // repeated Function
    79  	tagProfile_StringTable       = 6  // repeated string
    80  	tagProfile_DropFrames        = 7  // int64 (string table index)
    81  	tagProfile_KeepFrames        = 8  // int64 (string table index)
    82  	tagProfile_TimeNanos         = 9  // int64
    83  	tagProfile_DurationNanos     = 10 // int64
    84  	tagProfile_PeriodType        = 11 // ValueType (really optional string???)
    85  	tagProfile_Period            = 12 // int64
    86  	tagProfile_Comment           = 13 // repeated int64
    87  	tagProfile_DefaultSampleType = 14 // int64
    88  
    89  	// message ValueType
    90  	tagValueType_Type = 1 // int64 (string table index)
    91  	tagValueType_Unit = 2 // int64 (string table index)
    92  
    93  	// message Sample
    94  	tagSample_Location = 1 // repeated uint64
    95  	tagSample_Value    = 2 // repeated int64
    96  	tagSample_Label    = 3 // repeated Label
    97  
    98  	// message Label
    99  	tagLabel_Key = 1 // int64 (string table index)
   100  	tagLabel_Str = 2 // int64 (string table index)
   101  	tagLabel_Num = 3 // int64
   102  
   103  	// message Mapping
   104  	tagMapping_ID              = 1  // uint64
   105  	tagMapping_Start           = 2  // uint64
   106  	tagMapping_Limit           = 3  // uint64
   107  	tagMapping_Offset          = 4  // uint64
   108  	tagMapping_Filename        = 5  // int64 (string table index)
   109  	tagMapping_BuildID         = 6  // int64 (string table index)
   110  	tagMapping_HasFunctions    = 7  // bool
   111  	tagMapping_HasFilenames    = 8  // bool
   112  	tagMapping_HasLineNumbers  = 9  // bool
   113  	tagMapping_HasInlineFrames = 10 // bool
   114  
   115  	// message Location
   116  	tagLocation_ID        = 1 // uint64
   117  	tagLocation_MappingID = 2 // uint64
   118  	tagLocation_Address   = 3 // uint64
   119  	tagLocation_Line      = 4 // repeated Line
   120  
   121  	// message Line
   122  	tagLine_FunctionID = 1 // uint64
   123  	tagLine_Line       = 2 // int64
   124  
   125  	// message Function
   126  	tagFunction_ID         = 1 // uint64
   127  	tagFunction_Name       = 2 // int64 (string table index)
   128  	tagFunction_SystemName = 3 // int64 (string table index)
   129  	tagFunction_Filename   = 4 // int64 (string table index)
   130  	tagFunction_StartLine  = 5 // int64
   131  )
   132  
   133  // stringIndex adds s to the string table if not already present
   134  // and returns the index of s in the string table.
   135  func (b *profileBuilder) stringIndex(s string) int64 {
   136  	id, ok := b.stringMap[s]
   137  	if !ok {
   138  		id = len(b.strings)
   139  		b.strings = append(b.strings, s)
   140  		b.stringMap[s] = id
   141  	}
   142  	return int64(id)
   143  }
   144  
   145  func (b *profileBuilder) flush() {
   146  	const dataFlush = 4096
   147  	if b.pb.nest == 0 && len(b.pb.data) > dataFlush {
   148  		b.zw.Write(b.pb.data)
   149  		b.pb.data = b.pb.data[:0]
   150  	}
   151  }
   152  
   153  // pbValueType encodes a ValueType message to b.pb.
   154  func (b *profileBuilder) pbValueType(tag int, typ, unit string) {
   155  	start := b.pb.startMessage()
   156  	b.pb.int64(tagValueType_Type, b.stringIndex(typ))
   157  	b.pb.int64(tagValueType_Unit, b.stringIndex(unit))
   158  	b.pb.endMessage(tag, start)
   159  }
   160  
   161  // pbSample encodes a Sample message to b.pb.
   162  func (b *profileBuilder) pbSample(values []int64, locs []uint64, labels func()) {
   163  	start := b.pb.startMessage()
   164  	b.pb.int64s(tagSample_Value, values)
   165  	b.pb.uint64s(tagSample_Location, locs)
   166  	if labels != nil {
   167  		labels()
   168  	}
   169  	b.pb.endMessage(tagProfile_Sample, start)
   170  	b.flush()
   171  }
   172  
   173  // pbLabel encodes a Label message to b.pb.
   174  func (b *profileBuilder) pbLabel(tag int, key, str string, num int64) {
   175  	start := b.pb.startMessage()
   176  	b.pb.int64Opt(tagLabel_Key, b.stringIndex(key))
   177  	b.pb.int64Opt(tagLabel_Str, b.stringIndex(str))
   178  	b.pb.int64Opt(tagLabel_Num, num)
   179  	b.pb.endMessage(tag, start)
   180  }
   181  
   182  // pbLine encodes a Line message to b.pb.
   183  func (b *profileBuilder) pbLine(tag int, funcID uint64, line int64) {
   184  	start := b.pb.startMessage()
   185  	b.pb.uint64Opt(tagLine_FunctionID, funcID)
   186  	b.pb.int64Opt(tagLine_Line, line)
   187  	b.pb.endMessage(tag, start)
   188  }
   189  
   190  // pbMapping encodes a Mapping message to b.pb.
   191  func (b *profileBuilder) pbMapping(tag int, id, base, limit, offset uint64, file, buildID string, hasFuncs bool) {
   192  	start := b.pb.startMessage()
   193  	b.pb.uint64Opt(tagMapping_ID, id)
   194  	b.pb.uint64Opt(tagMapping_Start, base)
   195  	b.pb.uint64Opt(tagMapping_Limit, limit)
   196  	b.pb.uint64Opt(tagMapping_Offset, offset)
   197  	b.pb.int64Opt(tagMapping_Filename, b.stringIndex(file))
   198  	b.pb.int64Opt(tagMapping_BuildID, b.stringIndex(buildID))
   199  	// TODO: we set HasFunctions if all symbols from samples were symbolized (hasFuncs).
   200  	// Decide what to do about HasInlineFrames and HasLineNumbers.
   201  	// Also, another approach to handle the mapping entry with
   202  	// incomplete symbolization results is to dupliace the mapping
   203  	// entry (but with different Has* fields values) and use
   204  	// different entries for symbolized locations and unsymbolized locations.
   205  	if hasFuncs {
   206  		b.pb.bool(tagMapping_HasFunctions, true)
   207  	}
   208  	b.pb.endMessage(tag, start)
   209  }
   210  
   211  func allFrames(addr uintptr) ([]runtime.Frame, symbolizeFlag) {
   212  	// Expand this one address using CallersFrames so we can cache
   213  	// each expansion. In general, CallersFrames takes a whole
   214  	// stack, but in this case we know there will be no skips in
   215  	// the stack and we have return PCs anyway.
   216  	frames := runtime.CallersFrames([]uintptr{addr})
   217  	frame, more := frames.Next()
   218  	if frame.Function == "runtime.goexit" {
   219  		// Short-circuit if we see runtime.goexit so the loop
   220  		// below doesn't allocate a useless empty location.
   221  		return nil, 0
   222  	}
   223  
   224  	symbolizeResult := lookupTried
   225  	if frame.PC == 0 || frame.Function == "" || frame.File == "" || frame.Line == 0 {
   226  		symbolizeResult |= lookupFailed
   227  	}
   228  
   229  	if frame.PC == 0 {
   230  		// If we failed to resolve the frame, at least make up
   231  		// a reasonable call PC. This mostly happens in tests.
   232  		frame.PC = addr - 1
   233  	}
   234  	ret := []runtime.Frame{frame}
   235  	for frame.Function != "runtime.goexit" && more == true {
   236  		frame, more = frames.Next()
   237  		ret = append(ret, frame)
   238  	}
   239  	return ret, symbolizeResult
   240  }
   241  
   242  type locInfo struct {
   243  	// location id assigned by the profileBuilder
   244  	id uint64
   245  
   246  	// sequence of PCs, including the fake PCs returned by the traceback
   247  	// to represent inlined functions
   248  	// https://github.com/golang/go/blob/d6f2f833c93a41ec1c68e49804b8387a06b131c5/src/runtime/traceback.go#L347-L368
   249  	pcs []uintptr
   250  }
   251  
   252  // newProfileBuilder returns a new profileBuilder.
   253  // CPU profiling data obtained from the runtime can be added
   254  // by calling b.addCPUData, and then the eventual profile
   255  // can be obtained by calling b.finish.
   256  func newProfileBuilder(w io.Writer) *profileBuilder {
   257  	zw, _ := gzip.NewWriterLevel(w, gzip.BestSpeed)
   258  	b := &profileBuilder{
   259  		w:         w,
   260  		zw:        zw,
   261  		start:     time.Now(),
   262  		strings:   []string{""},
   263  		stringMap: map[string]int{"": 0},
   264  		locs:      map[uintptr]locInfo{},
   265  		funcs:     map[string]int{},
   266  	}
   267  	b.readMapping()
   268  	return b
   269  }
   270  
   271  // addCPUData adds the CPU profiling data to the profile.
   272  // The data must be a whole number of records,
   273  // as delivered by the runtime.
   274  func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error {
   275  	if !b.havePeriod {
   276  		// first record is period
   277  		if len(data) < 3 {
   278  			return fmt.Errorf("truncated profile")
   279  		}
   280  		if data[0] != 3 || data[2] == 0 {
   281  			return fmt.Errorf("malformed profile")
   282  		}
   283  		// data[2] is sampling rate in Hz. Convert to sampling
   284  		// period in nanoseconds.
   285  		b.period = 1e9 / int64(data[2])
   286  		b.havePeriod = true
   287  		data = data[3:]
   288  	}
   289  
   290  	// Parse CPU samples from the profile.
   291  	// Each sample is 3+n uint64s:
   292  	//	data[0] = 3+n
   293  	//	data[1] = time stamp (ignored)
   294  	//	data[2] = count
   295  	//	data[3:3+n] = stack
   296  	// If the count is 0 and the stack has length 1,
   297  	// that's an overflow record inserted by the runtime
   298  	// to indicate that stack[0] samples were lost.
   299  	// Otherwise the count is usually 1,
   300  	// but in a few special cases like lost non-Go samples
   301  	// there can be larger counts.
   302  	// Because many samples with the same stack arrive,
   303  	// we want to deduplicate immediately, which we do
   304  	// using the b.m profMap.
   305  	for len(data) > 0 {
   306  		if len(data) < 3 || data[0] > uint64(len(data)) {
   307  			return fmt.Errorf("truncated profile")
   308  		}
   309  		if data[0] < 3 || tags != nil && len(tags) < 1 {
   310  			return fmt.Errorf("malformed profile")
   311  		}
   312  		count := data[2]
   313  		stk := data[3:data[0]]
   314  		data = data[data[0]:]
   315  		var tag unsafe.Pointer
   316  		if tags != nil {
   317  			tag = tags[0]
   318  			tags = tags[1:]
   319  		}
   320  
   321  		if count == 0 && len(stk) == 1 {
   322  			// overflow record
   323  			count = uint64(stk[0])
   324  			stk = []uint64{
   325  				// gentraceback guarantees that PCs in the
   326  				// stack can be unconditionally decremented and
   327  				// still be valid, so we must do the same.
   328  				uint64(funcPC(lostProfileEvent)+1),
   329  			}
   330  		}
   331  		b.m.lookup(stk, tag).count += int64(count)
   332  	}
   333  	return nil
   334  }
   335  
   336  // build completes and returns the constructed profile.
   337  func (b *profileBuilder) build() {
   338  	b.end = time.Now()
   339  
   340  	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
   341  	if b.havePeriod { // must be CPU profile
   342  		b.pbValueType(tagProfile_SampleType, "samples", "count")
   343  		b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds")
   344  		b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds())
   345  		b.pbValueType(tagProfile_PeriodType, "cpu", "nanoseconds")
   346  		b.pb.int64Opt(tagProfile_Period, b.period)
   347  	}
   348  
   349  	values := []int64{0, 0}
   350  	var locs []uint64
   351  
   352  	for e := b.m.all; e != nil; e = e.nextAll {
   353  		values[0] = e.count
   354  		values[1] = e.count * b.period
   355  
   356  		var labels func()
   357  		if e.tag != nil {
   358  			labels = func() {
   359  				for k, v := range *(*labelMap)(e.tag) {
   360  					b.pbLabel(tagSample_Label, k, v, 0)
   361  				}
   362  			}
   363  		}
   364  
   365  		locs = b.appendLocsForStack(locs[:0], e.stk)
   366  
   367  		b.pbSample(values, locs, labels)
   368  	}
   369  
   370  	for i, m := range b.mem {
   371  		hasFunctions := m.funcs == lookupTried // lookupTried but not lookupFailed
   372  		b.pbMapping(tagProfile_Mapping, uint64(i+1), uint64(m.start), uint64(m.end), m.offset, m.file, m.buildID, hasFunctions)
   373  	}
   374  
   375  	// TODO: Anything for tagProfile_DropFrames?
   376  	// TODO: Anything for tagProfile_KeepFrames?
   377  
   378  	b.pb.strings(tagProfile_StringTable, b.strings)
   379  	b.zw.Write(b.pb.data)
   380  	b.zw.Close()
   381  }
   382  
   383  // appendLocsForStack appends the location IDs for the given stack trace to the given
   384  // location ID slice, locs. The addresses in the stack are return PCs or 1 + the PC of
   385  // an inline marker as the runtime traceback function returns.
   386  //
   387  // It may emit to b.pb, so there must be no message encoding in progress.
   388  func (b *profileBuilder) appendLocsForStack(locs []uint64, stk []uintptr) (newLocs []uint64) {
   389  	b.deck.reset()
   390  
   391  	// The last frame might be truncated. Recover lost inline frames.
   392  	stk = runtime_expandFinalInlineFrame(stk)
   393  
   394  	for len(stk) > 0 {
   395  		addr := stk[0]
   396  		if l, ok := b.locs[addr]; ok {
   397  			// first record the location if there is any pending accumulated info.
   398  			if id := b.emitLocation(); id > 0 {
   399  				locs = append(locs, id)
   400  			}
   401  
   402  			// then, record the cached location.
   403  			locs = append(locs, l.id)
   404  
   405  			// Skip the matching pcs.
   406  			//
   407  			// Even if stk was truncated due to the stack depth
   408  			// limit, expandFinalInlineFrame above has already
   409  			// fixed the truncation, ensuring it is long enough.
   410  			stk = stk[len(l.pcs):]
   411  			continue
   412  		}
   413  
   414  		frames, symbolizeResult := allFrames(addr)
   415  		if len(frames) == 0 { // runtime.goexit.
   416  			if id := b.emitLocation(); id > 0 {
   417  				locs = append(locs, id)
   418  			}
   419  			stk = stk[1:]
   420  			continue
   421  		}
   422  
   423  		if added := b.deck.tryAdd(addr, frames, symbolizeResult); added {
   424  			stk = stk[1:]
   425  			continue
   426  		}
   427  		// add failed because this addr is not inlined with the
   428  		// existing PCs in the deck. Flush the deck and retry handling
   429  		// this pc.
   430  		if id := b.emitLocation(); id > 0 {
   431  			locs = append(locs, id)
   432  		}
   433  
   434  		// check cache again - previous emitLocation added a new entry
   435  		if l, ok := b.locs[addr]; ok {
   436  			locs = append(locs, l.id)
   437  			stk = stk[len(l.pcs):] // skip the matching pcs.
   438  		} else {
   439  			b.deck.tryAdd(addr, frames, symbolizeResult) // must succeed.
   440  			stk = stk[1:]
   441  		}
   442  	}
   443  	if id := b.emitLocation(); id > 0 { // emit remaining location.
   444  		locs = append(locs, id)
   445  	}
   446  	return locs
   447  }
   448  
   449  // pcDeck is a helper to detect a sequence of inlined functions from
   450  // a stack trace returned by the runtime.
   451  //
   452  // The stack traces returned by runtime's trackback functions are fully
   453  // expanded (at least for Go functions) and include the fake pcs representing
   454  // inlined functions. The profile proto expects the inlined functions to be
   455  // encoded in one Location message.
   456  // https://github.com/google/pprof/blob/5e965273ee43930341d897407202dd5e10e952cb/proto/profile.proto#L177-L184
   457  //
   458  // Runtime does not directly expose whether a frame is for an inlined function
   459  // and looking up debug info is not ideal, so we use a heuristic to filter
   460  // the fake pcs and restore the inlined and entry functions. Inlined functions
   461  // have the following properties:
   462  //   Frame's Func is nil (note: also true for non-Go functions), and
   463  //   Frame's Entry matches its entry function frame's Entry (note: could also be true for recursive calls and non-Go functions), and
   464  //   Frame's Name does not match its entry function frame's name (note: inlined functions cannot be recursive).
   465  //
   466  // As reading and processing the pcs in a stack trace one by one (from leaf to the root),
   467  // we use pcDeck to temporarily hold the observed pcs and their expanded frames
   468  // until we observe the entry function frame.
   469  type pcDeck struct {
   470  	pcs             []uintptr
   471  	frames          []runtime.Frame
   472  	symbolizeResult symbolizeFlag
   473  }
   474  
   475  func (d *pcDeck) reset() {
   476  	d.pcs = d.pcs[:0]
   477  	d.frames = d.frames[:0]
   478  	d.symbolizeResult = 0
   479  }
   480  
   481  // tryAdd tries to add the pc and Frames expanded from it (most likely one,
   482  // since the stack trace is already fully expanded) and the symbolizeResult
   483  // to the deck. If it fails the caller needs to flush the deck and retry.
   484  func (d *pcDeck) tryAdd(pc uintptr, frames []runtime.Frame, symbolizeResult symbolizeFlag) (success bool) {
   485  	if existing := len(d.pcs); existing > 0 {
   486  		// 'd.frames' are all expanded from one 'pc' and represent all
   487  		// inlined functions so we check only the last one.
   488  		newFrame := frames[0]
   489  		last := d.frames[existing-1]
   490  		if last.Func != nil { // the last frame can't be inlined. Flush.
   491  			return false
   492  		}
   493  		if last.Entry == 0 || newFrame.Entry == 0 { // Possibly not a Go function. Don't try to merge.
   494  			return false
   495  		}
   496  
   497  		if last.Entry != newFrame.Entry { // newFrame is for a different function.
   498  			return false
   499  		}
   500  		if last.Function == newFrame.Function { // maybe recursion.
   501  			return false
   502  		}
   503  	}
   504  	d.pcs = append(d.pcs, pc)
   505  	d.frames = append(d.frames, frames...)
   506  	d.symbolizeResult |= symbolizeResult
   507  	return true
   508  }
   509  
   510  // emitLocation emits the new location and function information recorded in the deck
   511  // and returns the location ID encoded in the profile protobuf.
   512  // It emits to b.pb, so there must be no message encoding in progress.
   513  // It resets the deck.
   514  func (b *profileBuilder) emitLocation() uint64 {
   515  	if len(b.deck.pcs) == 0 {
   516  		return 0
   517  	}
   518  	defer b.deck.reset()
   519  
   520  	addr := b.deck.pcs[0]
   521  	firstFrame := b.deck.frames[0]
   522  
   523  	// We can't write out functions while in the middle of the
   524  	// Location message, so record new functions we encounter and
   525  	// write them out after the Location.
   526  	type newFunc struct {
   527  		id         uint64
   528  		name, file string
   529  	}
   530  	newFuncs := make([]newFunc, 0, 8)
   531  
   532  	id := uint64(len(b.locs)) + 1
   533  	b.locs[addr] = locInfo{id: id, pcs: append([]uintptr{}, b.deck.pcs...)}
   534  
   535  	start := b.pb.startMessage()
   536  	b.pb.uint64Opt(tagLocation_ID, id)
   537  	b.pb.uint64Opt(tagLocation_Address, uint64(firstFrame.PC))
   538  	for _, frame := range b.deck.frames {
   539  		// Write out each line in frame expansion.
   540  		funcID := uint64(b.funcs[frame.Function])
   541  		if funcID == 0 {
   542  			funcID = uint64(len(b.funcs)) + 1
   543  			b.funcs[frame.Function] = int(funcID)
   544  			newFuncs = append(newFuncs, newFunc{funcID, frame.Function, frame.File})
   545  		}
   546  		b.pbLine(tagLocation_Line, funcID, int64(frame.Line))
   547  	}
   548  	for i := range b.mem {
   549  		if b.mem[i].start <= addr && addr < b.mem[i].end || b.mem[i].fake {
   550  			b.pb.uint64Opt(tagLocation_MappingID, uint64(i+1))
   551  
   552  			m := b.mem[i]
   553  			m.funcs |= b.deck.symbolizeResult
   554  			b.mem[i] = m
   555  			break
   556  		}
   557  	}
   558  	b.pb.endMessage(tagProfile_Location, start)
   559  
   560  	// Write out functions we found during frame expansion.
   561  	for _, fn := range newFuncs {
   562  		start := b.pb.startMessage()
   563  		b.pb.uint64Opt(tagFunction_ID, fn.id)
   564  		b.pb.int64Opt(tagFunction_Name, b.stringIndex(fn.name))
   565  		b.pb.int64Opt(tagFunction_SystemName, b.stringIndex(fn.name))
   566  		b.pb.int64Opt(tagFunction_Filename, b.stringIndex(fn.file))
   567  		b.pb.endMessage(tagProfile_Function, start)
   568  	}
   569  
   570  	b.flush()
   571  	return id
   572  }
   573  
   574  // readMapping reads /proc/self/maps and writes mappings to b.pb.
   575  // It saves the address ranges of the mappings in b.mem for use
   576  // when emitting locations.
   577  func (b *profileBuilder) readMapping() {
   578  	data, _ := ioutil.ReadFile("/proc/self/maps")
   579  	parseProcSelfMaps(data, b.addMapping)
   580  	if len(b.mem) == 0 { // pprof expects a map entry, so fake one.
   581  		b.addMappingEntry(0, 0, 0, "", "", true)
   582  		// TODO(hyangah): make addMapping return *memMap or
   583  		// take a memMap struct, and get rid of addMappingEntry
   584  		// that takes a bunch of positional arguments.
   585  	}
   586  }
   587  
   588  func parseProcSelfMaps(data []byte, addMapping func(lo, hi, offset uint64, file, buildID string)) {
   589  	// $ cat /proc/self/maps
   590  	// 00400000-0040b000 r-xp 00000000 fc:01 787766                             /bin/cat
   591  	// 0060a000-0060b000 r--p 0000a000 fc:01 787766                             /bin/cat
   592  	// 0060b000-0060c000 rw-p 0000b000 fc:01 787766                             /bin/cat
   593  	// 014ab000-014cc000 rw-p 00000000 00:00 0                                  [heap]
   594  	// 7f7d76af8000-7f7d7797c000 r--p 00000000 fc:01 1318064                    /usr/lib/locale/locale-archive
   595  	// 7f7d7797c000-7f7d77b36000 r-xp 00000000 fc:01 1180226                    /lib/x86_64-linux-gnu/libc-2.19.so
   596  	// 7f7d77b36000-7f7d77d36000 ---p 001ba000 fc:01 1180226                    /lib/x86_64-linux-gnu/libc-2.19.so
   597  	// 7f7d77d36000-7f7d77d3a000 r--p 001ba000 fc:01 1180226                    /lib/x86_64-linux-gnu/libc-2.19.so
   598  	// 7f7d77d3a000-7f7d77d3c000 rw-p 001be000 fc:01 1180226                    /lib/x86_64-linux-gnu/libc-2.19.so
   599  	// 7f7d77d3c000-7f7d77d41000 rw-p 00000000 00:00 0
   600  	// 7f7d77d41000-7f7d77d64000 r-xp 00000000 fc:01 1180217                    /lib/x86_64-linux-gnu/ld-2.19.so
   601  	// 7f7d77f3f000-7f7d77f42000 rw-p 00000000 00:00 0
   602  	// 7f7d77f61000-7f7d77f63000 rw-p 00000000 00:00 0
   603  	// 7f7d77f63000-7f7d77f64000 r--p 00022000 fc:01 1180217                    /lib/x86_64-linux-gnu/ld-2.19.so
   604  	// 7f7d77f64000-7f7d77f65000 rw-p 00023000 fc:01 1180217                    /lib/x86_64-linux-gnu/ld-2.19.so
   605  	// 7f7d77f65000-7f7d77f66000 rw-p 00000000 00:00 0
   606  	// 7ffc342a2000-7ffc342c3000 rw-p 00000000 00:00 0                          [stack]
   607  	// 7ffc34343000-7ffc34345000 r-xp 00000000 00:00 0                          [vdso]
   608  	// ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
   609  
   610  	var line []byte
   611  	// next removes and returns the next field in the line.
   612  	// It also removes from line any spaces following the field.
   613  	next := func() []byte {
   614  		j := bytes.IndexByte(line, ' ')
   615  		if j < 0 {
   616  			f := line
   617  			line = nil
   618  			return f
   619  		}
   620  		f := line[:j]
   621  		line = line[j+1:]
   622  		for len(line) > 0 && line[0] == ' ' {
   623  			line = line[1:]
   624  		}
   625  		return f
   626  	}
   627  
   628  	for len(data) > 0 {
   629  		i := bytes.IndexByte(data, '\n')
   630  		if i < 0 {
   631  			line, data = data, nil
   632  		} else {
   633  			line, data = data[:i], data[i+1:]
   634  		}
   635  		addr := next()
   636  		i = bytes.IndexByte(addr, '-')
   637  		if i < 0 {
   638  			continue
   639  		}
   640  		lo, err := strconv.ParseUint(string(addr[:i]), 16, 64)
   641  		if err != nil {
   642  			continue
   643  		}
   644  		hi, err := strconv.ParseUint(string(addr[i+1:]), 16, 64)
   645  		if err != nil {
   646  			continue
   647  		}
   648  		perm := next()
   649  		if len(perm) < 4 || perm[2] != 'x' {
   650  			// Only interested in executable mappings.
   651  			continue
   652  		}
   653  		offset, err := strconv.ParseUint(string(next()), 16, 64)
   654  		if err != nil {
   655  			continue
   656  		}
   657  		next()          // dev
   658  		inode := next() // inode
   659  		if line == nil {
   660  			continue
   661  		}
   662  		file := string(line)
   663  
   664  		// Trim deleted file marker.
   665  		deletedStr := " (deleted)"
   666  		deletedLen := len(deletedStr)
   667  		if len(file) >= deletedLen && file[len(file)-deletedLen:] == deletedStr {
   668  			file = file[:len(file)-deletedLen]
   669  		}
   670  
   671  		if len(inode) == 1 && inode[0] == '0' && file == "" {
   672  			// Huge-page text mappings list the initial fragment of
   673  			// mapped but unpopulated memory as being inode 0.
   674  			// Don't report that part.
   675  			// But [vdso] and [vsyscall] are inode 0, so let non-empty file names through.
   676  			continue
   677  		}
   678  
   679  		// TODO: pprof's remapMappingIDs makes two adjustments:
   680  		// 1. If there is an /anon_hugepage mapping first and it is
   681  		// consecutive to a next mapping, drop the /anon_hugepage.
   682  		// 2. If start-offset = 0x400000, change start to 0x400000 and offset to 0.
   683  		// There's no indication why either of these is needed.
   684  		// Let's try not doing these and see what breaks.
   685  		// If we do need them, they would go here, before we
   686  		// enter the mappings into b.mem in the first place.
   687  
   688  		buildID, _ := elfBuildID(file)
   689  		addMapping(lo, hi, offset, file, buildID)
   690  	}
   691  }
   692  
   693  func (b *profileBuilder) addMapping(lo, hi, offset uint64, file, buildID string) {
   694  	b.addMappingEntry(lo, hi, offset, file, buildID, false)
   695  }
   696  
   697  func (b *profileBuilder) addMappingEntry(lo, hi, offset uint64, file, buildID string, fake bool) {
   698  	b.mem = append(b.mem, memMap{
   699  		start:   uintptr(lo),
   700  		end:     uintptr(hi),
   701  		offset:  offset,
   702  		file:    file,
   703  		buildID: buildID,
   704  		fake:    fake,
   705  	})
   706  }
   707  

View as plain text