...
Run Format

Source file src/runtime/pprof/elf.go

Documentation: runtime/pprof

     1  // Copyright 2017 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  	"encoding/binary"
     9  	"errors"
    10  	"fmt"
    11  	"os"
    12  )
    13  
    14  var (
    15  	errBadELF    = errors.New("malformed ELF binary")
    16  	errNoBuildID = errors.New("no NT_GNU_BUILD_ID found in ELF binary")
    17  )
    18  
    19  // elfBuildID returns the GNU build ID of the named ELF binary,
    20  // without introducing a dependency on debug/elf and its dependencies.
    21  func elfBuildID(file string) (string, error) {
    22  	buf := make([]byte, 256)
    23  	f, err := os.Open(file)
    24  	if err != nil {
    25  		return "", err
    26  	}
    27  	defer f.Close()
    28  
    29  	if _, err := f.ReadAt(buf[:64], 0); err != nil {
    30  		return "", err
    31  	}
    32  
    33  	// ELF file begins with \x7F E L F.
    34  	if buf[0] != 0x7F || buf[1] != 'E' || buf[2] != 'L' || buf[3] != 'F' {
    35  		return "", errBadELF
    36  	}
    37  
    38  	var byteOrder binary.ByteOrder
    39  	switch buf[5] {
    40  	default:
    41  		return "", errBadELF
    42  	case 1: // little-endian
    43  		byteOrder = binary.LittleEndian
    44  	case 2: // big-endian
    45  		byteOrder = binary.BigEndian
    46  	}
    47  
    48  	var shnum int
    49  	var shoff, shentsize int64
    50  	switch buf[4] {
    51  	default:
    52  		return "", errBadELF
    53  	case 1: // 32-bit file header
    54  		shoff = int64(byteOrder.Uint32(buf[32:]))
    55  		shentsize = int64(byteOrder.Uint16(buf[46:]))
    56  		if shentsize != 40 {
    57  			return "", errBadELF
    58  		}
    59  		shnum = int(byteOrder.Uint16(buf[48:]))
    60  	case 2: // 64-bit file header
    61  		shoff = int64(byteOrder.Uint64(buf[40:]))
    62  		shentsize = int64(byteOrder.Uint16(buf[58:]))
    63  		if shentsize != 64 {
    64  			return "", errBadELF
    65  		}
    66  		shnum = int(byteOrder.Uint16(buf[60:]))
    67  	}
    68  
    69  	for i := 0; i < shnum; i++ {
    70  		if _, err := f.ReadAt(buf[:shentsize], shoff+int64(i)*shentsize); err != nil {
    71  			return "", err
    72  		}
    73  		if typ := byteOrder.Uint32(buf[4:]); typ != 7 { // SHT_NOTE
    74  			continue
    75  		}
    76  		var off, size int64
    77  		if shentsize == 40 {
    78  			// 32-bit section header
    79  			off = int64(byteOrder.Uint32(buf[16:]))
    80  			size = int64(byteOrder.Uint32(buf[20:]))
    81  		} else {
    82  			// 64-bit section header
    83  			off = int64(byteOrder.Uint64(buf[24:]))
    84  			size = int64(byteOrder.Uint64(buf[32:]))
    85  		}
    86  		size += off
    87  		for off < size {
    88  			if _, err := f.ReadAt(buf[:16], off); err != nil { // room for header + name GNU\x00
    89  				return "", err
    90  			}
    91  			nameSize := int(byteOrder.Uint32(buf[0:]))
    92  			descSize := int(byteOrder.Uint32(buf[4:]))
    93  			noteType := int(byteOrder.Uint32(buf[8:]))
    94  			descOff := off + int64(12+(nameSize+3)&^3)
    95  			off = descOff + int64((descSize+3)&^3)
    96  			if nameSize != 4 || noteType != 3 || buf[12] != 'G' || buf[13] != 'N' || buf[14] != 'U' || buf[15] != '\x00' { // want name GNU\x00 type 3 (NT_GNU_BUILD_ID)
    97  				continue
    98  			}
    99  			if descSize > len(buf) {
   100  				return "", errBadELF
   101  			}
   102  			if _, err := f.ReadAt(buf[:descSize], descOff); err != nil {
   103  				return "", err
   104  			}
   105  			return fmt.Sprintf("%x", buf[:descSize]), nil
   106  		}
   107  	}
   108  	return "", errNoBuildID
   109  }
   110  

View as plain text