Add DTV extraction support to libc package

The DTV variables read from extracted __tls_get_addr can be used to
read TLS variables.

If this symbol is missing, empty introspection data is returned.

Author: dalehamel

libc/libc.go

@@ -8,13 +8,17 @@ import (
 	"fmt"
 	"regexp"
 
+	"go.opentelemetry.io/ebpf-profiler/internal/log"
+
 	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
 )
 
 // LibcInfo contains introspection information extracted from the C-library
 type LibcInfo struct {
 	// TSDInfo is the TSDInfo extracted for this C-library
 	TSDInfo TSDInfo
+	// TODO comment
+	DTVInfo DTVInfo
 }
 
 // TSDInfo contains information to access C-library's Thread Specific Data from eBPF
@@ -35,6 +39,16 @@ type TSDInfo struct {
 	Indirect uint8
 }
 
+// TODO comment
+type DTVInfo struct {
+	// Offset is the offset of DTV from FS base (or from thread pointer)
+	Offset     int64
+	// EntryWidth is the size of each DTV entry in bytes
+	EntryWidth uint32 
+	// Indirect is 0 if DTV is at FS+offset, 1 if at [FS+0]+offset
+	Indirect   uint8
+}
+
 // This code analyzes the C-library provided POSIX defined function which is used
 // to read thread-specific data (TSD):
 //   void *pthread_getspecific(pthread_key_t key);
@@ -96,8 +110,14 @@ func ExtractLibcInfo(ef *pfelf.File) (*LibcInfo, error) {
 		return nil, err
 	}
 
+	dtvinfo, err := extractDTVInfo(ef)
+	if err != nil {
+		return &LibcInfo{}, err
+	}
+
 	return &LibcInfo{
 		TSDInfo: *tsdinfo,
+		DTVInfo: dtvinfo,
 	}, nil
 }
 
@@ -128,3 +148,33 @@ func extractTSDInfo(ef *pfelf.File) (*TSDInfo, error) {
 	}
 	return &info, nil
 }
+
+// extractDTVInfo extracts the introspection data for the DTV to access TLS vars
+func extractDTVInfo(ef *pfelf.File) (DTVInfo, error) {
+	var info DTVInfo
+	_, code, err := ef.SymbolData("__tls_get_addr", 2048)
+	if err != nil {
+		// Only error out reading DTV if we have the symbol, but fail to parse it
+		// if the symbol is not exported, failing to read it is not a critical error
+		// and empty DTV introspection data is returned
+		log.Warnf("unable to read '__tls_get_addr': %s, libc DTV introspection data is unavailable", err)
+		return info, nil
+	}
+
+	if len(code) < 8 {
+		return info, fmt.Errorf("__tls_get_addr function size is %d", len(code))
+	}
+
+	switch ef.Machine {
+	case elf.EM_AARCH64:
+		info, err = extractDTVInfoARM(code)
+	case elf.EM_X86_64:
+		info, err = extractDTVInfoX86(code)
+	default:
+		return info, fmt.Errorf("unsupported arch %s", ef.Machine.String())
+	}
+	if err != nil {
+		return info, fmt.Errorf("failed to extract DTV data: %s", err)
+	}
+	return info, nil
+}

libc/libc_aarch64.go

@@ -268,3 +268,72 @@ func extractTSDInfoARM(code []byte) (TSDInfo, error) {
 		Indirect:   indirect,
 	}, nil
 }
+
+func extractDTVInfoARM(code []byte) (DTVInfo, error) {
+	dtvOffset := int64(0)
+	entryWidth := uint32(0)
+	foundThreadPtr := false
+	foundDTVLoad := false
+
+	// Scan entire function
+	for offs := 0; offs < len(code); offs += 4 {
+		if offs+4 > len(code) {
+			break
+		}
+
+		inst, err := aa.Decode(code[offs:])
+		if err != nil {
+			return DTVInfo{}, err
+		}
+
+		switch inst.Op {
+
+		case aa.MRS:
+			foundThreadPtr = true
+
+		case aa.LDUR:
+			if len(inst.Args) >= 2 {
+				if m, ok := inst.Args[1].(aa.MemImmediate); ok {
+					imm, ok := ah.DecodeImmediate(m)
+					if ok {
+						dtvOffset = imm
+						foundDTVLoad = true
+					}
+				}
+			}
+
+		case aa.LDR:
+			if len(inst.Args) >= 2 {
+				// Check what type of LDR this is
+				switch m := inst.Args[1].(type) {
+				case aa.MemImmediate:
+					if foundThreadPtr && !foundDTVLoad {
+						imm, ok := ah.DecodeImmediate(m)
+						if ok {
+							dtvOffset = imm
+							foundDTVLoad = true
+						}
+					}
+
+				case aa.MemExtend:
+					if m.Amount > 0 {
+						entryWidth = uint32(1 << m.Amount)
+					}
+				}
+			}
+
+		case aa.LSL:
+			if len(inst.Args) >= 3 {
+				if imm, ok := inst.Args[2].(aa.Imm); ok {
+					entryWidth = uint32(1 << imm.Imm)
+				}
+			}
+		}
+	}
+
+	return DTVInfo{
+		Offset:     dtvOffset,
+		EntryWidth: entryWidth,
+		Indirect:   1,
+	}, nil
+}