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