podman

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 profile provides a representation of profile.proto and
16
// methods to encode/decode profiles in this format.
17
package profile
18

19
import (
20
	"bytes"
21
	"compress/gzip"
22
	"fmt"
23
	"io"
24
	"io/ioutil"
25
	"math"
26
	"path/filepath"
27
	"regexp"
28
	"sort"
29
	"strings"
30
	"sync"
31
	"time"
32
)
33

34
// Profile is an in-memory representation of profile.proto.
35
type Profile struct {
36
	SampleType        []*ValueType
37
	DefaultSampleType string
38
	Sample            []*Sample
39
	Mapping           []*Mapping
40
	Location          []*Location
41
	Function          []*Function
42
	Comments          []string
43

44
	DropFrames string
45
	KeepFrames string
46

47
	TimeNanos     int64
48
	DurationNanos int64
49
	PeriodType    *ValueType
50
	Period        int64
51

52
	// The following fields are modified during encoding and copying,
53
	// so are protected by a Mutex.
54
	encodeMu sync.Mutex
55

56
	commentX           []int64
57
	dropFramesX        int64
58
	keepFramesX        int64
59
	stringTable        []string
60
	defaultSampleTypeX int64
61
}
62

63
// ValueType corresponds to Profile.ValueType
64
type ValueType struct {
65
	Type string // cpu, wall, inuse_space, etc
66
	Unit string // seconds, nanoseconds, bytes, etc
67

68
	typeX int64
69
	unitX int64
70
}
71

72
// Sample corresponds to Profile.Sample
73
type Sample struct {
74
	Location []*Location
75
	Value    []int64
76
	Label    map[string][]string
77
	NumLabel map[string][]int64
78
	NumUnit  map[string][]string
79

80
	locationIDX []uint64
81
	labelX      []label
82
}
83

84
// label corresponds to Profile.Label
85
type label struct {
86
	keyX int64
87
	// Exactly one of the two following values must be set
88
	strX int64
89
	numX int64 // Integer value for this label
90
	// can be set if numX has value
91
	unitX int64
92
}
93

94
// Mapping corresponds to Profile.Mapping
95
type Mapping struct {
96
	ID              uint64
97
	Start           uint64
98
	Limit           uint64
99
	Offset          uint64
100
	File            string
101
	BuildID         string
102
	HasFunctions    bool
103
	HasFilenames    bool
104
	HasLineNumbers  bool
105
	HasInlineFrames bool
106

107
	fileX    int64
108
	buildIDX int64
109
}
110

111
// Location corresponds to Profile.Location
112
type Location struct {
113
	ID       uint64
114
	Mapping  *Mapping
115
	Address  uint64
116
	Line     []Line
117
	IsFolded bool
118

119
	mappingIDX uint64
120
}
121

122
// Line corresponds to Profile.Line
123
type Line struct {
124
	Function *Function
125
	Line     int64
126

127
	functionIDX uint64
128
}
129

130
// Function corresponds to Profile.Function
131
type Function struct {
132
	ID         uint64
133
	Name       string
134
	SystemName string
135
	Filename   string
136
	StartLine  int64
137

138
	nameX       int64
139
	systemNameX int64
140
	filenameX   int64
141
}
142

143
// Parse parses a profile and checks for its validity. The input
144
// may be a gzip-compressed encoded protobuf or one of many legacy
145
// profile formats which may be unsupported in the future.
146
func Parse(r io.Reader) (*Profile, error) {
147
	data, err := ioutil.ReadAll(r)
148
	if err != nil {
149
		return nil, err
150
	}
151
	return ParseData(data)
152
}
153

154
// ParseData parses a profile from a buffer and checks for its
155
// validity.
156
func ParseData(data []byte) (*Profile, error) {
157
	var p *Profile
158
	var err error
159
	if len(data) >= 2 && data[0] == 0x1f && data[1] == 0x8b {
160
		gz, err := gzip.NewReader(bytes.NewBuffer(data))
161
		if err == nil {
162
			data, err = ioutil.ReadAll(gz)
163
		}
164
		if err != nil {
165
			return nil, fmt.Errorf("decompressing profile: %v", err)
166
		}
167
	}
168
	if p, err = ParseUncompressed(data); err != nil && err != errNoData && err != errConcatProfile {
169
		p, err = parseLegacy(data)
170
	}
171

172
	if err != nil {
173
		return nil, fmt.Errorf("parsing profile: %v", err)
174
	}
175

176
	if err := p.CheckValid(); err != nil {
177
		return nil, fmt.Errorf("malformed profile: %v", err)
178
	}
179
	return p, nil
180
}
181

182
var errUnrecognized = fmt.Errorf("unrecognized profile format")
183
var errMalformed = fmt.Errorf("malformed profile format")
184
var errNoData = fmt.Errorf("empty input file")
185
var errConcatProfile = fmt.Errorf("concatenated profiles detected")
186

187
func parseLegacy(data []byte) (*Profile, error) {
188
	parsers := []func([]byte) (*Profile, error){
189
		parseCPU,
190
		parseHeap,
191
		parseGoCount, // goroutine, threadcreate
192
		parseThread,
193
		parseContention,
194
		parseJavaProfile,
195
	}
196

197
	for _, parser := range parsers {
198
		p, err := parser(data)
199
		if err == nil {
200
			p.addLegacyFrameInfo()
201
			return p, nil
202
		}
203
		if err != errUnrecognized {
204
			return nil, err
205
		}
206
	}
207
	return nil, errUnrecognized
208
}
209

210
// ParseUncompressed parses an uncompressed protobuf into a profile.
211
func ParseUncompressed(data []byte) (*Profile, error) {
212
	if len(data) == 0 {
213
		return nil, errNoData
214
	}
215
	p := &Profile{}
216
	if err := unmarshal(data, p); err != nil {
217
		return nil, err
218
	}
219

220
	if err := p.postDecode(); err != nil {
221
		return nil, err
222
	}
223

224
	return p, nil
225
}
226

227
var libRx = regexp.MustCompile(`([.]so$|[.]so[._][0-9]+)`)
228

229
// massageMappings applies heuristic-based changes to the profile
230
// mappings to account for quirks of some environments.
231
func (p *Profile) massageMappings() {
232
	// Merge adjacent regions with matching names, checking that the offsets match
233
	if len(p.Mapping) > 1 {
234
		mappings := []*Mapping{p.Mapping[0]}
235
		for _, m := range p.Mapping[1:] {
236
			lm := mappings[len(mappings)-1]
237
			if adjacent(lm, m) {
238
				lm.Limit = m.Limit
239
				if m.File != "" {
240
					lm.File = m.File
241
				}
242
				if m.BuildID != "" {
243
					lm.BuildID = m.BuildID
244
				}
245
				p.updateLocationMapping(m, lm)
246
				continue
247
			}
248
			mappings = append(mappings, m)
249
		}
250
		p.Mapping = mappings
251
	}
252

253
	// Use heuristics to identify main binary and move it to the top of the list of mappings
254
	for i, m := range p.Mapping {
255
		file := strings.TrimSpace(strings.Replace(m.File, "(deleted)", "", -1))
256
		if len(file) == 0 {
257
			continue
258
		}
259
		if len(libRx.FindStringSubmatch(file)) > 0 {
260
			continue
261
		}
262
		if file[0] == '[' {
263
			continue
264
		}
265
		// Swap what we guess is main to position 0.
266
		p.Mapping[0], p.Mapping[i] = p.Mapping[i], p.Mapping[0]
267
		break
268
	}
269

270
	// Keep the mapping IDs neatly sorted
271
	for i, m := range p.Mapping {
272
		m.ID = uint64(i + 1)
273
	}
274
}
275

276
// adjacent returns whether two mapping entries represent the same
277
// mapping that has been split into two. Check that their addresses are adjacent,
278
// and if the offsets match, if they are available.
279
func adjacent(m1, m2 *Mapping) bool {
280
	if m1.File != "" && m2.File != "" {
281
		if m1.File != m2.File {
282
			return false
283
		}
284
	}
285
	if m1.BuildID != "" && m2.BuildID != "" {
286
		if m1.BuildID != m2.BuildID {
287
			return false
288
		}
289
	}
290
	if m1.Limit != m2.Start {
291
		return false
292
	}
293
	if m1.Offset != 0 && m2.Offset != 0 {
294
		offset := m1.Offset + (m1.Limit - m1.Start)
295
		if offset != m2.Offset {
296
			return false
297
		}
298
	}
299
	return true
300
}
301

302
func (p *Profile) updateLocationMapping(from, to *Mapping) {
303
	for _, l := range p.Location {
304
		if l.Mapping == from {
305
			l.Mapping = to
306
		}
307
	}
308
}
309

310
func serialize(p *Profile) []byte {
311
	p.encodeMu.Lock()
312
	p.preEncode()
313
	b := marshal(p)
314
	p.encodeMu.Unlock()
315
	return b
316
}
317

318
// Write writes the profile as a gzip-compressed marshaled protobuf.
319
func (p *Profile) Write(w io.Writer) error {
320
	zw := gzip.NewWriter(w)
321
	defer zw.Close()
322
	_, err := zw.Write(serialize(p))
323
	return err
324
}
325

326
// WriteUncompressed writes the profile as a marshaled protobuf.
327
func (p *Profile) WriteUncompressed(w io.Writer) error {
328
	_, err := w.Write(serialize(p))
329
	return err
330
}
331

332
// CheckValid tests whether the profile is valid. Checks include, but are
333
// not limited to:
334
//   - len(Profile.Sample[n].value) == len(Profile.value_unit)
335
//   - Sample.id has a corresponding Profile.Location
336
func (p *Profile) CheckValid() error {
337
	// Check that sample values are consistent
338
	sampleLen := len(p.SampleType)
339
	if sampleLen == 0 && len(p.Sample) != 0 {
340
		return fmt.Errorf("missing sample type information")
341
	}
342
	for _, s := range p.Sample {
343
		if s == nil {
344
			return fmt.Errorf("profile has nil sample")
345
		}
346
		if len(s.Value) != sampleLen {
347
			return fmt.Errorf("mismatch: sample has %d values vs. %d types", len(s.Value), len(p.SampleType))
348
		}
349
		for _, l := range s.Location {
350
			if l == nil {
351
				return fmt.Errorf("sample has nil location")
352
			}
353
		}
354
	}
355

356
	// Check that all mappings/locations/functions are in the tables
357
	// Check that there are no duplicate ids
358
	mappings := make(map[uint64]*Mapping, len(p.Mapping))
359
	for _, m := range p.Mapping {
360
		if m == nil {
361
			return fmt.Errorf("profile has nil mapping")
362
		}
363
		if m.ID == 0 {
364
			return fmt.Errorf("found mapping with reserved ID=0")
365
		}
366
		if mappings[m.ID] != nil {
367
			return fmt.Errorf("multiple mappings with same id: %d", m.ID)
368
		}
369
		mappings[m.ID] = m
370
	}
371
	functions := make(map[uint64]*Function, len(p.Function))
372
	for _, f := range p.Function {
373
		if f == nil {
374
			return fmt.Errorf("profile has nil function")
375
		}
376
		if f.ID == 0 {
377
			return fmt.Errorf("found function with reserved ID=0")
378
		}
379
		if functions[f.ID] != nil {
380
			return fmt.Errorf("multiple functions with same id: %d", f.ID)
381
		}
382
		functions[f.ID] = f
383
	}
384
	locations := make(map[uint64]*Location, len(p.Location))
385
	for _, l := range p.Location {
386
		if l == nil {
387
			return fmt.Errorf("profile has nil location")
388
		}
389
		if l.ID == 0 {
390
			return fmt.Errorf("found location with reserved id=0")
391
		}
392
		if locations[l.ID] != nil {
393
			return fmt.Errorf("multiple locations with same id: %d", l.ID)
394
		}
395
		locations[l.ID] = l
396
		if m := l.Mapping; m != nil {
397
			if m.ID == 0 || mappings[m.ID] != m {
398
				return fmt.Errorf("inconsistent mapping %p: %d", m, m.ID)
399
			}
400
		}
401
		for _, ln := range l.Line {
402
			f := ln.Function
403
			if f == nil {
404
				return fmt.Errorf("location id: %d has a line with nil function", l.ID)
405
			}
406
			if f.ID == 0 || functions[f.ID] != f {
407
				return fmt.Errorf("inconsistent function %p: %d", f, f.ID)
408
			}
409
		}
410
	}
411
	return nil
412
}
413

414
// Aggregate merges the locations in the profile into equivalence
415
// classes preserving the request attributes. It also updates the
416
// samples to point to the merged locations.
417
func (p *Profile) Aggregate(inlineFrame, function, filename, linenumber, address bool) error {
418
	for _, m := range p.Mapping {
419
		m.HasInlineFrames = m.HasInlineFrames && inlineFrame
420
		m.HasFunctions = m.HasFunctions && function
421
		m.HasFilenames = m.HasFilenames && filename
422
		m.HasLineNumbers = m.HasLineNumbers && linenumber
423
	}
424

425
	// Aggregate functions
426
	if !function || !filename {
427
		for _, f := range p.Function {
428
			if !function {
429
				f.Name = ""
430
				f.SystemName = ""
431
			}
432
			if !filename {
433
				f.Filename = ""
434
			}
435
		}
436
	}
437

438
	// Aggregate locations
439
	if !inlineFrame || !address || !linenumber {
440
		for _, l := range p.Location {
441
			if !inlineFrame && len(l.Line) > 1 {
442
				l.Line = l.Line[len(l.Line)-1:]
443
			}
444
			if !linenumber {
445
				for i := range l.Line {
446
					l.Line[i].Line = 0
447
				}
448
			}
449
			if !address {
450
				l.Address = 0
451
			}
452
		}
453
	}
454

455
	return p.CheckValid()
456
}
457

458
// NumLabelUnits returns a map of numeric label keys to the units
459
// associated with those keys and a map of those keys to any units
460
// that were encountered but not used.
461
// Unit for a given key is the first encountered unit for that key. If multiple
462
// units are encountered for values paired with a particular key, then the first
463
// unit encountered is used and all other units are returned in sorted order
464
// in map of ignored units.
465
// If no units are encountered for a particular key, the unit is then inferred
466
// based on the key.
467
func (p *Profile) NumLabelUnits() (map[string]string, map[string][]string) {
468
	numLabelUnits := map[string]string{}
469
	ignoredUnits := map[string]map[string]bool{}
470
	encounteredKeys := map[string]bool{}
471

472
	// Determine units based on numeric tags for each sample.
473
	for _, s := range p.Sample {
474
		for k := range s.NumLabel {
475
			encounteredKeys[k] = true
476
			for _, unit := range s.NumUnit[k] {
477
				if unit == "" {
478
					continue
479
				}
480
				if wantUnit, ok := numLabelUnits[k]; !ok {
481
					numLabelUnits[k] = unit
482
				} else if wantUnit != unit {
483
					if v, ok := ignoredUnits[k]; ok {
484
						v[unit] = true
485
					} else {
486
						ignoredUnits[k] = map[string]bool{unit: true}
487
					}
488
				}
489
			}
490
		}
491
	}
492
	// Infer units for keys without any units associated with
493
	// numeric tag values.
494
	for key := range encounteredKeys {
495
		unit := numLabelUnits[key]
496
		if unit == "" {
497
			switch key {
498
			case "alignment", "request":
499
				numLabelUnits[key] = "bytes"
500
			default:
501
				numLabelUnits[key] = key
502
			}
503
		}
504
	}
505

506
	// Copy ignored units into more readable format
507
	unitsIgnored := make(map[string][]string, len(ignoredUnits))
508
	for key, values := range ignoredUnits {
509
		units := make([]string, len(values))
510
		i := 0
511
		for unit := range values {
512
			units[i] = unit
513
			i++
514
		}
515
		sort.Strings(units)
516
		unitsIgnored[key] = units
517
	}
518

519
	return numLabelUnits, unitsIgnored
520
}
521

522
// String dumps a text representation of a profile. Intended mainly
523
// for debugging purposes.
524
func (p *Profile) String() string {
525
	ss := make([]string, 0, len(p.Comments)+len(p.Sample)+len(p.Mapping)+len(p.Location))
526
	for _, c := range p.Comments {
527
		ss = append(ss, "Comment: "+c)
528
	}
529
	if pt := p.PeriodType; pt != nil {
530
		ss = append(ss, fmt.Sprintf("PeriodType: %s %s", pt.Type, pt.Unit))
531
	}
532
	ss = append(ss, fmt.Sprintf("Period: %d", p.Period))
533
	if p.TimeNanos != 0 {
534
		ss = append(ss, fmt.Sprintf("Time: %v", time.Unix(0, p.TimeNanos)))
535
	}
536
	if p.DurationNanos != 0 {
537
		ss = append(ss, fmt.Sprintf("Duration: %.4v", time.Duration(p.DurationNanos)))
538
	}
539

540
	ss = append(ss, "Samples:")
541
	var sh1 string
542
	for _, s := range p.SampleType {
543
		dflt := ""
544
		if s.Type == p.DefaultSampleType {
545
			dflt = "[dflt]"
546
		}
547
		sh1 = sh1 + fmt.Sprintf("%s/%s%s ", s.Type, s.Unit, dflt)
548
	}
549
	ss = append(ss, strings.TrimSpace(sh1))
550
	for _, s := range p.Sample {
551
		ss = append(ss, s.string())
552
	}
553

554
	ss = append(ss, "Locations")
555
	for _, l := range p.Location {
556
		ss = append(ss, l.string())
557
	}
558

559
	ss = append(ss, "Mappings")
560
	for _, m := range p.Mapping {
561
		ss = append(ss, m.string())
562
	}
563

564
	return strings.Join(ss, "\n") + "\n"
565
}
566

567
// string dumps a text representation of a mapping. Intended mainly
568
// for debugging purposes.
569
func (m *Mapping) string() string {
570
	bits := ""
571
	if m.HasFunctions {
572
		bits = bits + "[FN]"
573
	}
574
	if m.HasFilenames {
575
		bits = bits + "[FL]"
576
	}
577
	if m.HasLineNumbers {
578
		bits = bits + "[LN]"
579
	}
580
	if m.HasInlineFrames {
581
		bits = bits + "[IN]"
582
	}
583
	return fmt.Sprintf("%d: %#x/%#x/%#x %s %s %s",
584
		m.ID,
585
		m.Start, m.Limit, m.Offset,
586
		m.File,
587
		m.BuildID,
588
		bits)
589
}
590

591
// string dumps a text representation of a location. Intended mainly
592
// for debugging purposes.
593
func (l *Location) string() string {
594
	ss := []string{}
595
	locStr := fmt.Sprintf("%6d: %#x ", l.ID, l.Address)
596
	if m := l.Mapping; m != nil {
597
		locStr = locStr + fmt.Sprintf("M=%d ", m.ID)
598
	}
599
	if l.IsFolded {
600
		locStr = locStr + "[F] "
601
	}
602
	if len(l.Line) == 0 {
603
		ss = append(ss, locStr)
604
	}
605
	for li := range l.Line {
606
		lnStr := "??"
607
		if fn := l.Line[li].Function; fn != nil {
608
			lnStr = fmt.Sprintf("%s %s:%d s=%d",
609
				fn.Name,
610
				fn.Filename,
611
				l.Line[li].Line,
612
				fn.StartLine)
613
			if fn.Name != fn.SystemName {
614
				lnStr = lnStr + "(" + fn.SystemName + ")"
615
			}
616
		}
617
		ss = append(ss, locStr+lnStr)
618
		// Do not print location details past the first line
619
		locStr = "             "
620
	}
621
	return strings.Join(ss, "\n")
622
}
623

624
// string dumps a text representation of a sample. Intended mainly
625
// for debugging purposes.
626
func (s *Sample) string() string {
627
	ss := []string{}
628
	var sv string
629
	for _, v := range s.Value {
630
		sv = fmt.Sprintf("%s %10d", sv, v)
631
	}
632
	sv = sv + ": "
633
	for _, l := range s.Location {
634
		sv = sv + fmt.Sprintf("%d ", l.ID)
635
	}
636
	ss = append(ss, sv)
637
	const labelHeader = "                "
638
	if len(s.Label) > 0 {
639
		ss = append(ss, labelHeader+labelsToString(s.Label))
640
	}
641
	if len(s.NumLabel) > 0 {
642
		ss = append(ss, labelHeader+numLabelsToString(s.NumLabel, s.NumUnit))
643
	}
644
	return strings.Join(ss, "\n")
645
}
646

647
// labelsToString returns a string representation of a
648
// map representing labels.
649
func labelsToString(labels map[string][]string) string {
650
	ls := []string{}
651
	for k, v := range labels {
652
		ls = append(ls, fmt.Sprintf("%s:%v", k, v))
653
	}
654
	sort.Strings(ls)
655
	return strings.Join(ls, " ")
656
}
657

658
// numLabelsToString returns a string representation of a map
659
// representing numeric labels.
660
func numLabelsToString(numLabels map[string][]int64, numUnits map[string][]string) string {
661
	ls := []string{}
662
	for k, v := range numLabels {
663
		units := numUnits[k]
664
		var labelString string
665
		if len(units) == len(v) {
666
			values := make([]string, len(v))
667
			for i, vv := range v {
668
				values[i] = fmt.Sprintf("%d %s", vv, units[i])
669
			}
670
			labelString = fmt.Sprintf("%s:%v", k, values)
671
		} else {
672
			labelString = fmt.Sprintf("%s:%v", k, v)
673
		}
674
		ls = append(ls, labelString)
675
	}
676
	sort.Strings(ls)
677
	return strings.Join(ls, " ")
678
}
679

680
// SetLabel sets the specified key to the specified value for all samples in the
681
// profile.
682
func (p *Profile) SetLabel(key string, value []string) {
683
	for _, sample := range p.Sample {
684
		if sample.Label == nil {
685
			sample.Label = map[string][]string{key: value}
686
		} else {
687
			sample.Label[key] = value
688
		}
689
	}
690
}
691

692
// RemoveLabel removes all labels associated with the specified key for all
693
// samples in the profile.
694
func (p *Profile) RemoveLabel(key string) {
695
	for _, sample := range p.Sample {
696
		delete(sample.Label, key)
697
	}
698
}
699

700
// HasLabel returns true if a sample has a label with indicated key and value.
701
func (s *Sample) HasLabel(key, value string) bool {
702
	for _, v := range s.Label[key] {
703
		if v == value {
704
			return true
705
		}
706
	}
707
	return false
708
}
709

710
// DiffBaseSample returns true if a sample belongs to the diff base and false
711
// otherwise.
712
func (s *Sample) DiffBaseSample() bool {
713
	return s.HasLabel("pprof::base", "true")
714
}
715

716
// Scale multiplies all sample values in a profile by a constant and keeps
717
// only samples that have at least one non-zero value.
718
func (p *Profile) Scale(ratio float64) {
719
	if ratio == 1 {
720
		return
721
	}
722
	ratios := make([]float64, len(p.SampleType))
723
	for i := range p.SampleType {
724
		ratios[i] = ratio
725
	}
726
	p.ScaleN(ratios)
727
}
728

729
// ScaleN multiplies each sample values in a sample by a different amount
730
// and keeps only samples that have at least one non-zero value.
731
func (p *Profile) ScaleN(ratios []float64) error {
732
	if len(p.SampleType) != len(ratios) {
733
		return fmt.Errorf("mismatched scale ratios, got %d, want %d", len(ratios), len(p.SampleType))
734
	}
735
	allOnes := true
736
	for _, r := range ratios {
737
		if r != 1 {
738
			allOnes = false
739
			break
740
		}
741
	}
742
	if allOnes {
743
		return nil
744
	}
745
	fillIdx := 0
746
	for _, s := range p.Sample {
747
		keepSample := false
748
		for i, v := range s.Value {
749
			if ratios[i] != 1 {
750
				val := int64(math.Round(float64(v) * ratios[i]))
751
				s.Value[i] = val
752
				keepSample = keepSample || val != 0
753
			}
754
		}
755
		if keepSample {
756
			p.Sample[fillIdx] = s
757
			fillIdx++
758
		}
759
	}
760
	p.Sample = p.Sample[:fillIdx]
761
	return nil
762
}
763

764
// HasFunctions determines if all locations in this profile have
765
// symbolized function information.
766
func (p *Profile) HasFunctions() bool {
767
	for _, l := range p.Location {
768
		if l.Mapping != nil && !l.Mapping.HasFunctions {
769
			return false
770
		}
771
	}
772
	return true
773
}
774

775
// HasFileLines determines if all locations in this profile have
776
// symbolized file and line number information.
777
func (p *Profile) HasFileLines() bool {
778
	for _, l := range p.Location {
779
		if l.Mapping != nil && (!l.Mapping.HasFilenames || !l.Mapping.HasLineNumbers) {
780
			return false
781
		}
782
	}
783
	return true
784
}
785

786
// Unsymbolizable returns true if a mapping points to a binary for which
787
// locations can't be symbolized in principle, at least now. Examples are
788
// "[vdso]", [vsyscall]" and some others, see the code.
789
func (m *Mapping) Unsymbolizable() bool {
790
	name := filepath.Base(m.File)
791
	return strings.HasPrefix(name, "[") || strings.HasPrefix(name, "linux-vdso") || strings.HasPrefix(m.File, "/dev/dri/")
792
}
793

794
// Copy makes a fully independent copy of a profile.
795
func (p *Profile) Copy() *Profile {
796
	pp := &Profile{}
797
	if err := unmarshal(serialize(p), pp); err != nil {
798
		panic(err)
799
	}
800
	if err := pp.postDecode(); err != nil {
801
		panic(err)
802
	}
803

804
	return pp
805
}
806