btf: lazy string table

Signed-off-by: Lorenz Bauer <[email protected]>

Author: lmb

btf/btf_test.go

@@ -252,19 +252,6 @@ func TestParseCurrentKernelBTF(t *testing.T) {
 	if len(spec.namedTypes) == 0 {
 		t.Fatal("Empty kernel BTF")
 	}
-
-	totalBytes := 0
-	distinct := 0
-	seen := make(map[string]bool)
-	for _, str := range spec.strings.strings {
-		totalBytes += len(str)
-		if !seen[str] {
-			distinct++
-			seen[str] = true
-		}
-	}
-	t.Logf("%d strings total, %d distinct", len(spec.strings.strings), distinct)
-	t.Logf("Average string size: %.0f", float64(totalBytes)/float64(len(spec.strings.strings)))
 }
 
 func TestFindVMLinux(t *testing.T) {

btf/strings.go

@@ -1,21 +1,17 @@
 package btf
 
 import (
-	"bufio"
 	"bytes"
 	"errors"
 	"fmt"
 	"io"
 	"maps"
-	"slices"
 	"strings"
 )
 
 type stringTable struct {
-	base    *stringTable
-	offsets []uint32
-	prevIdx int
-	strings []string
+	base  *stringTable
+	bytes []byte
 }
 
 // sizedReader is implemented by bytes.Reader, io.SectionReader, strings.Reader, etc.
@@ -29,89 +25,57 @@ func readStringTable(r sizedReader, base *stringTable) (*stringTable, error) {
 	// from the last entry offset of the base BTF.
 	firstStringOffset := uint32(0)
 	if base != nil {
-		idx := len(base.offsets) - 1
-		firstStringOffset = base.offsets[idx] + uint32(len(base.strings[idx])) + 1
+		firstStringOffset = uint32(len(base.bytes))
 	}
 
-	// Derived from vmlinux BTF.
-	const averageStringLength = 16
-
-	n := int(r.Size() / averageStringLength)
-	offsets := make([]uint32, 0, n)
-	strings := make([]string, 0, n)
-
-	offset := firstStringOffset
-	scanner := bufio.NewScanner(r)
-	scanner.Split(splitNull)
-	for scanner.Scan() {
-		str := scanner.Text()
-		offsets = append(offsets, offset)
-		strings = append(strings, str)
-		offset += uint32(len(str)) + 1
-	}
-	if err := scanner.Err(); err != nil {
+	bytes := make([]byte, r.Size())
+	if _, err := io.ReadFull(r, bytes); err != nil {
 		return nil, err
 	}
 
-	if len(strings) == 0 {
+	if len(bytes) == 0 {
 		return nil, errors.New("string table is empty")
 	}
 
-	if firstStringOffset == 0 && strings[0] != "" {
-		return nil, errors.New("first item in string table is non-empty")
+	if bytes[len(bytes)-1] != 0 {
+		return nil, errors.New("string table isn't null terminated")
 	}
 
-	return &stringTable{base, offsets, 0, strings}, nil
-}
-
-func splitNull(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	i := bytes.IndexByte(data, 0)
-	if i == -1 {
-		if atEOF && len(data) > 0 {
-			return 0, nil, errors.New("string table isn't null terminated")
-		}
-		return 0, nil, nil
+	if firstStringOffset == 0 && bytes[0] != 0 {
+		return nil, errors.New("first item in string table is non-empty")
 	}
 
-	return i + 1, data[:i], nil
+	return &stringTable{base: base, bytes: bytes}, nil
 }
 
 func (st *stringTable) Lookup(offset uint32) (string, error) {
-	if st.base != nil && offset <= st.base.offsets[len(st.base.offsets)-1] {
-		return st.base.lookup(offset)
-	}
-	return st.lookup(offset)
-}
-
-func (st *stringTable) lookup(offset uint32) (string, error) {
 	// Fast path: zero offset is the empty string, looked up frequently.
-	if offset == 0 && st.base == nil {
+	if offset == 0 {
 		return "", nil
 	}
 
-	// Accesses tend to be globally increasing, so check if the next string is
-	// the one we want. This skips the binary search in about 50% of cases.
-	if st.prevIdx+1 < len(st.offsets) && st.offsets[st.prevIdx+1] == offset {
-		st.prevIdx++
-		return st.strings[st.prevIdx], nil
-	}
+	return st.lookupSlow(offset)
+}
 
-	i, found := slices.BinarySearch(st.offsets, offset)
-	if !found {
-		return "", fmt.Errorf("offset %d isn't start of a string", offset)
+func (st *stringTable) lookupSlow(offset uint32) (string, error) {
+	if st.base != nil {
+		n := uint32(len(st.base.bytes))
+		if offset < n {
+			return st.base.lookupSlow(offset)
+		}
+		offset -= n
 	}
 
-	// Set the new increment index, but only if its greater than the current.
-	if i > st.prevIdx+1 {
-		st.prevIdx = i
+	if offset > uint32(len(st.bytes)) {
+		return "", fmt.Errorf("offset %d is out of bounds of string table", offset)
 	}
 
-	return st.strings[i], nil
-}
+	if offset > 0 && st.bytes[offset-1] != 0 {
+		return "", fmt.Errorf("offset %d is not the beginning of a string", offset)
+	}
 
-// Num returns the number of strings in the table.
-func (st *stringTable) Num() int {
-	return len(st.strings)
+	i := bytes.IndexByte(st.bytes[offset:], 0)
+	return string(st.bytes[offset : offset+uint32(i)]), nil
 }
 
 // stringTableBuilder builds BTF string tables.