symbolizer.go

     1  // Copyright 2014 Google Inc. All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // Package symbolizer provides a routine to populate a profile with
    16  // symbol, file and line number information. It relies on the
    17  // addr2liner and demangle packages to do the actual work.
    18  package symbolizer
    19  
    20  import (
    21  	"fmt"
    22  	"io/ioutil"
    23  	"net/http"
    24  	"net/url"
    25  	"path/filepath"
    26  	"strings"
    27  
    28  	"github.com/google/pprof/internal/binutils"
    29  	"github.com/google/pprof/internal/plugin"
    30  	"github.com/google/pprof/internal/symbolz"
    31  	"github.com/google/pprof/profile"
    32  	"github.com/ianlancetaylor/demangle"
    33  )
    34  
    35  // Symbolizer implements the plugin.Symbolize interface.
    36  type Symbolizer struct {
    37  	Obj       plugin.ObjTool
    38  	UI        plugin.UI
    39  	Transport http.RoundTripper
    40  }
    41  
    42  // test taps for dependency injection
    43  var symbolzSymbolize = symbolz.Symbolize
    44  var localSymbolize = doLocalSymbolize
    45  var demangleFunction = Demangle
    46  
    47  // Symbolize attempts to symbolize profile p. First uses binutils on
    48  // local binaries; if the source is a URL it attempts to get any
    49  // missed entries using symbolz.
    50  func (s *Symbolizer) Symbolize(mode string, sources plugin.MappingSources, p *profile.Profile) error {
    51  	remote, local, fast, force, demanglerMode := true, true, false, false, ""
    52  	for _, o := range strings.Split(strings.ToLower(mode), ":") {
    53  		switch o {
    54  		case "":
    55  			continue
    56  		case "none", "no":
    57  			return nil
    58  		case "local":
    59  			remote, local = false, true
    60  		case "fastlocal":
    61  			remote, local, fast = false, true, true
    62  		case "remote":
    63  			remote, local = true, false
    64  		case "force":
    65  			force = true
    66  		default:
    67  			switch d := strings.TrimPrefix(o, "demangle="); d {
    68  			case "full", "none", "templates":
    69  				demanglerMode = d
    70  				force = true
    71  				continue
    72  			case "default":
    73  				continue
    74  			}
    75  			s.UI.PrintErr("ignoring unrecognized symbolization option: " + mode)
    76  			s.UI.PrintErr("expecting -symbolize=[local|fastlocal|remote|none][:force][:demangle=[none|full|templates|default]")
    77  		}
    78  	}
    79  
    80  	var err error
    81  	if local {
    82  		// Symbolize locally using binutils.
    83  		if err = localSymbolize(p, fast, force, s.Obj, s.UI); err != nil {
    84  			s.UI.PrintErr("local symbolization: " + err.Error())
    85  		}
    86  	}
    87  	if remote {
    88  		post := func(source, post string) ([]byte, error) {
    89  			return postURL(source, post, s.Transport)
    90  		}
    91  		if err = symbolzSymbolize(p, force, sources, post, s.UI); err != nil {
    92  			return err // Ran out of options.
    93  		}
    94  	}
    95  
    96  	demangleFunction(p, force, demanglerMode)
    97  	return nil
    98  }
    99  
   100  // postURL issues a POST to a URL over HTTP.
   101  func postURL(source, post string, tr http.RoundTripper) ([]byte, error) {
   102  	client := &http.Client{
   103  		Transport: tr,
   104  	}
   105  	resp, err := client.Post(source, "application/octet-stream", strings.NewReader(post))
   106  	if err != nil {
   107  		return nil, fmt.Errorf("http post %s: %v", source, err)
   108  	}
   109  	defer resp.Body.Close()
   110  	if resp.StatusCode != http.StatusOK {
   111  		return nil, fmt.Errorf("http post %s: %v", source, statusCodeError(resp))
   112  	}
   113  	return ioutil.ReadAll(resp.Body)
   114  }
   115  
   116  func statusCodeError(resp *http.Response) error {
   117  	if resp.Header.Get("X-Go-Pprof") != "" && strings.Contains(resp.Header.Get("Content-Type"), "text/plain") {
   118  		// error is from pprof endpoint
   119  		if body, err := ioutil.ReadAll(resp.Body); err == nil {
   120  			return fmt.Errorf("server response: %s - %s", resp.Status, body)
   121  		}
   122  	}
   123  	return fmt.Errorf("server response: %s", resp.Status)
   124  }
   125  
   126  // doLocalSymbolize adds symbol and line number information to all locations
   127  // in a profile. mode enables some options to control
   128  // symbolization.
   129  func doLocalSymbolize(prof *profile.Profile, fast, force bool, obj plugin.ObjTool, ui plugin.UI) error {
   130  	if fast {
   131  		if bu, ok := obj.(*binutils.Binutils); ok {
   132  			bu.SetFastSymbolization(true)
   133  		}
   134  	}
   135  
   136  	mt, err := newMapping(prof, obj, ui, force)
   137  	if err != nil {
   138  		return err
   139  	}
   140  	defer mt.close()
   141  
   142  	functions := make(map[profile.Function]*profile.Function)
   143  	for _, l := range mt.prof.Location {
   144  		m := l.Mapping
   145  		segment := mt.segments[m]
   146  		if segment == nil {
   147  			// Nothing to do.
   148  			continue
   149  		}
   150  
   151  		stack, err := segment.SourceLine(l.Address)
   152  		if err != nil || len(stack) == 0 {
   153  			// No answers from addr2line.
   154  			continue
   155  		}
   156  
   157  		l.Line = make([]profile.Line, len(stack))
   158  		l.IsFolded = false
   159  		for i, frame := range stack {
   160  			if frame.Func != "" {
   161  				m.HasFunctions = true
   162  			}
   163  			if frame.File != "" {
   164  				m.HasFilenames = true
   165  			}
   166  			if frame.Line != 0 {
   167  				m.HasLineNumbers = true
   168  			}
   169  			f := &profile.Function{
   170  				Name:       frame.Func,
   171  				SystemName: frame.Func,
   172  				Filename:   frame.File,
   173  			}
   174  			if fp := functions[*f]; fp != nil {
   175  				f = fp
   176  			} else {
   177  				functions[*f] = f
   178  				f.ID = uint64(len(mt.prof.Function)) + 1
   179  				mt.prof.Function = append(mt.prof.Function, f)
   180  			}
   181  			l.Line[i] = profile.Line{
   182  				Function: f,
   183  				Line:     int64(frame.Line),
   184  			}
   185  		}
   186  
   187  		if len(stack) > 0 {
   188  			m.HasInlineFrames = true
   189  		}
   190  	}
   191  
   192  	return nil
   193  }
   194  
   195  // Demangle updates the function names in a profile with demangled C++
   196  // names, simplified according to demanglerMode. If force is set,
   197  // overwrite any names that appear already demangled.
   198  func Demangle(prof *profile.Profile, force bool, demanglerMode string) {
   199  	if force {
   200  		// Remove the current demangled names to force demangling
   201  		for _, f := range prof.Function {
   202  			if f.Name != "" && f.SystemName != "" {
   203  				f.Name = f.SystemName
   204  			}
   205  		}
   206  	}
   207  
   208  	var options []demangle.Option
   209  	switch demanglerMode {
   210  	case "": // demangled, simplified: no parameters, no templates, no return type
   211  		options = []demangle.Option{demangle.NoParams, demangle.NoTemplateParams}
   212  	case "templates": // demangled, simplified: no parameters, no return type
   213  		options = []demangle.Option{demangle.NoParams}
   214  	case "full":
   215  		options = []demangle.Option{demangle.NoClones}
   216  	case "none": // no demangling
   217  		return
   218  	}
   219  
   220  	// Copy the options because they may be updated by the call.
   221  	o := make([]demangle.Option, len(options))
   222  	for _, fn := range prof.Function {
   223  		if fn.Name != "" && fn.SystemName != fn.Name {
   224  			continue // Already demangled.
   225  		}
   226  		copy(o, options)
   227  		if demangled := demangle.Filter(fn.SystemName, o...); demangled != fn.SystemName {
   228  			fn.Name = demangled
   229  			continue
   230  		}
   231  		// Could not demangle. Apply heuristics in case the name is
   232  		// already demangled.
   233  		name := fn.SystemName
   234  		if looksLikeDemangledCPlusPlus(name) {
   235  			if demanglerMode == "" || demanglerMode == "templates" {
   236  				name = removeMatching(name, '(', ')')
   237  			}
   238  			if demanglerMode == "" {
   239  				name = removeMatching(name, '<', '>')
   240  			}
   241  		}
   242  		fn.Name = name
   243  	}
   244  }
   245  
   246  // looksLikeDemangledCPlusPlus is a heuristic to decide if a name is
   247  // the result of demangling C++. If so, further heuristics will be
   248  // applied to simplify the name.
   249  func looksLikeDemangledCPlusPlus(demangled string) bool {
   250  	if strings.Contains(demangled, ".<") { // Skip java names of the form "class.<init>"
   251  		return false
   252  	}
   253  	return strings.ContainsAny(demangled, "<>[]") || strings.Contains(demangled, "::")
   254  }
   255  
   256  // removeMatching removes nested instances of start..end from name.
   257  func removeMatching(name string, start, end byte) string {
   258  	s := string(start) + string(end)
   259  	var nesting, first, current int
   260  	for index := strings.IndexAny(name[current:], s); index != -1; index = strings.IndexAny(name[current:], s) {
   261  		switch current += index; name[current] {
   262  		case start:
   263  			nesting++
   264  			if nesting == 1 {
   265  				first = current
   266  			}
   267  		case end:
   268  			nesting--
   269  			switch {
   270  			case nesting < 0:
   271  				return name // Mismatch, abort
   272  			case nesting == 0:
   273  				name = name[:first] + name[current+1:]
   274  				current = first - 1
   275  			}
   276  		}
   277  		current++
   278  	}
   279  	return name
   280  }
   281  
   282  // newMapping creates a mappingTable for a profile.
   283  func newMapping(prof *profile.Profile, obj plugin.ObjTool, ui plugin.UI, force bool) (*mappingTable, error) {
   284  	mt := &mappingTable{
   285  		prof:     prof,
   286  		segments: make(map[*profile.Mapping]plugin.ObjFile),
   287  	}
   288  
   289  	// Identify used mappings
   290  	mappings := make(map[*profile.Mapping]bool)
   291  	for _, l := range prof.Location {
   292  		mappings[l.Mapping] = true
   293  	}
   294  
   295  	missingBinaries := false
   296  	for midx, m := range prof.Mapping {
   297  		if !mappings[m] {
   298  			continue
   299  		}
   300  
   301  		// Do not attempt to re-symbolize a mapping that has already been symbolized.
   302  		if !force && (m.HasFunctions || m.HasFilenames || m.HasLineNumbers) {
   303  			continue
   304  		}
   305  
   306  		if m.File == "" {
   307  			if midx == 0 {
   308  				ui.PrintErr("Main binary filename not available.")
   309  				continue
   310  			}
   311  			missingBinaries = true
   312  			continue
   313  		}
   314  
   315  		// Skip well-known system mappings
   316  		if m.Unsymbolizable() {
   317  			continue
   318  		}
   319  
   320  		// Skip mappings pointing to a source URL
   321  		if m.BuildID == "" {
   322  			if u, err := url.Parse(m.File); err == nil && u.IsAbs() && strings.Contains(strings.ToLower(u.Scheme), "http") {
   323  				continue
   324  			}
   325  		}
   326  
   327  		name := filepath.Base(m.File)
   328  		f, err := obj.Open(m.File, m.Start, m.Limit, m.Offset)
   329  		if err != nil {
   330  			ui.PrintErr("Local symbolization failed for ", name, ": ", err)
   331  			missingBinaries = true
   332  			continue
   333  		}
   334  		if fid := f.BuildID(); m.BuildID != "" && fid != "" && fid != m.BuildID {
   335  			ui.PrintErr("Local symbolization failed for ", name, ": build ID mismatch")
   336  			f.Close()
   337  			continue
   338  		}
   339  
   340  		mt.segments[m] = f
   341  	}
   342  	if missingBinaries {
   343  		ui.PrintErr("Some binary filenames not available. Symbolization may be incomplete.\n" +
   344  			"Try setting PPROF_BINARY_PATH to the search path for local binaries.")
   345  	}
   346  	return mt, nil
   347  }
   348  
   349  // mappingTable contains the mechanisms for symbolization of a
   350  // profile.
   351  type mappingTable struct {
   352  	prof     *profile.Profile
   353  	segments map[*profile.Mapping]plugin.ObjFile
   354  }
   355  
   356  // Close releases any external processes being used for the mapping.
   357  func (mt *mappingTable) close() {
   358  	for _, segment := range mt.segments {
   359  		segment.Close()
   360  	}
   361  }
   362
View as plain text