From ed9bf3bd2ea92f05668e51e1fe1cadbd631377d5 Mon Sep 17 00:00:00 2001
From: Lorenz Bauer <lmb@isovalent.com>
Date: Wed, 11 Oct 2023 14:40:00 +0100
Subject: [PATCH] internal: fix reading auxv on 32-bit platforms

It turns out that the auxiliary vector has a platform specific size.
Adjust the code to use uintptr to approximate "unsigned long" from C.
auxv32le.bin is from an i686 Debian bookworm machine.

Fixes https://github.com/cilium/ebpf/issues/1133

Signed-off-by: Lorenz Bauer <lmb@isovalent.com>
---
 internal/testdata/auxv32le.bin                | Bin 0 -> 176 bytes
 .../testdata/auxv64le.bin                     | Bin
 .../testdata/auxv64le_no_vdso.bin             | Bin
 {testdata => internal/testdata}/vdso.bin      | Bin
 .../testdata}/vdso_multiple_notes.bin         | Bin
 internal/vdso.go                              |  44 ++++++++++++---
 internal/vdso_test.go                         |  50 ++++++++++++------
 7 files changed, 70 insertions(+), 24 deletions(-)
 create mode 100644 internal/testdata/auxv32le.bin
 rename testdata/auxv.bin => internal/testdata/auxv64le.bin (100%)
 rename testdata/auxv_no_vdso.bin => internal/testdata/auxv64le_no_vdso.bin (100%)
 rename {testdata => internal/testdata}/vdso.bin (100%)
 rename {testdata => internal/testdata}/vdso_multiple_notes.bin (100%)

diff --git a/internal/testdata/auxv32le.bin b/internal/testdata/auxv32le.bin
new file mode 100644
index 0000000000000000000000000000000000000000..b4270a7bfd83ca4c5d1ebda321982057001726bd
GIT binary patch
literal 176
zcmY#jU|<L^{j*&WNHZAx*=`J^9<VVm2mtB-zq`eOOfW|fNTmQVGZ33x@L^y9(h5M#
z3dGz%%nrm10e`l0fM_7#1mXi9eZX=rfSP!Kd=SkGrTL(=IFJSbNg)1xZti|5Ak75C
V@<9Cl{@nfiK$`pf-2Ffb3;;+)8z}$)

literal 0
HcmV?d00001

diff --git a/testdata/auxv.bin b/internal/testdata/auxv64le.bin
similarity index 100%
rename from testdata/auxv.bin
rename to internal/testdata/auxv64le.bin
diff --git a/testdata/auxv_no_vdso.bin b/internal/testdata/auxv64le_no_vdso.bin
similarity index 100%
rename from testdata/auxv_no_vdso.bin
rename to internal/testdata/auxv64le_no_vdso.bin
diff --git a/testdata/vdso.bin b/internal/testdata/vdso.bin
similarity index 100%
rename from testdata/vdso.bin
rename to internal/testdata/vdso.bin
diff --git a/testdata/vdso_multiple_notes.bin b/internal/testdata/vdso_multiple_notes.bin
similarity index 100%
rename from testdata/vdso_multiple_notes.bin
rename to internal/testdata/vdso_multiple_notes.bin
diff --git a/internal/vdso.go b/internal/vdso.go
index 10e639bf0..c444a41c4 100644
--- a/internal/vdso.go
+++ b/internal/vdso.go
@@ -8,6 +8,7 @@ import (
 	"io"
 	"math"
 	"os"
+	"unsafe"
 
 	"github.com/cilium/ebpf/internal/unix"
 )
@@ -19,6 +20,8 @@ var (
 // vdsoVersion returns the LINUX_VERSION_CODE embedded in the vDSO library
 // linked into the current process image.
 func vdsoVersion() (uint32, error) {
+	const uintptrIs32bits = unsafe.Sizeof((uintptr)(0)) == 4
+
 	// Read data from the auxiliary vector, which is normally passed directly
 	// to the process. Go does not expose that data, so we must read it from procfs.
 	// https://man7.org/linux/man-pages/man3/getauxval.3.html
@@ -31,7 +34,7 @@ func vdsoVersion() (uint32, error) {
 	}
 	defer av.Close()
 
-	vdsoAddr, err := vdsoMemoryAddress(av)
+	vdsoAddr, err := vdsoMemoryAddress(av, NativeEndian, uintptrIs32bits)
 	if err != nil {
 		return 0, fmt.Errorf("finding vDSO memory address: %w", err)
 	}
@@ -52,9 +55,34 @@ func vdsoVersion() (uint32, error) {
 	return c, nil
 }
 
+type auxvPair32 struct {
+	Tag, Value uint32
+}
+
+type auxvPair64 struct {
+	Tag, Value uint64
+}
+
+func readAuxvPair(r io.Reader, order binary.ByteOrder, uintptrIs32bits bool) (tag, value uint64, _ error) {
+	if uintptrIs32bits {
+		var aux auxvPair32
+		if err := binary.Read(r, order, &aux); err != nil {
+			return 0, 0, fmt.Errorf("reading auxv entry: %w", err)
+		}
+		return uint64(aux.Tag), uint64(aux.Value), nil
+	}
+
+	var aux auxvPair64
+	if err := binary.Read(r, order, &aux); err != nil {
+		return 0, 0, fmt.Errorf("reading auxv entry: %w", err)
+	}
+	return aux.Tag, aux.Value, nil
+}
+
 // vdsoMemoryAddress returns the memory address of the vDSO library
 // linked into the current process image. r is an io.Reader into an auxv blob.
-func vdsoMemoryAddress(r io.Reader) (uint64, error) {
+func vdsoMemoryAddress(r io.Reader, order binary.ByteOrder, uintptrIs32bits bool) (uintptr, error) {
+	// See https://elixir.bootlin.com/linux/v6.5.5/source/include/uapi/linux/auxvec.h
 	const (
 		_AT_NULL         = 0  // End of vector
 		_AT_SYSINFO_EHDR = 33 // Offset to vDSO blob in process image
@@ -62,16 +90,16 @@ func vdsoMemoryAddress(r io.Reader) (uint64, error) {
 
 	// Loop through all tag/value pairs in auxv until we find `AT_SYSINFO_EHDR`,
 	// the address of a page containing the virtual Dynamic Shared Object (vDSO).
-	aux := struct{ Tag, Val uint64 }{}
 	for {
-		if err := binary.Read(r, NativeEndian, &aux); err != nil {
-			return 0, fmt.Errorf("reading auxv entry: %w", err)
+		tag, value, err := readAuxvPair(r, order, uintptrIs32bits)
+		if err != nil {
+			return 0, err
 		}
 
-		switch aux.Tag {
+		switch tag {
 		case _AT_SYSINFO_EHDR:
-			if aux.Val != 0 {
-				return aux.Val, nil
+			if value != 0 {
+				return uintptr(value), nil
 			}
 			return 0, fmt.Errorf("invalid vDSO address in auxv")
 		// _AT_NULL is always the last tag/val pair in the aux vector
diff --git a/internal/vdso_test.go b/internal/vdso_test.go
index 53fe9c996..ab2d4a74a 100644
--- a/internal/vdso_test.go
+++ b/internal/vdso_test.go
@@ -1,54 +1,72 @@
 package internal
 
 import (
+	"encoding/binary"
 	"errors"
 	"os"
 	"testing"
+
+	qt "github.com/frankban/quicktest"
 )
 
 func TestAuxvVDSOMemoryAddress(t *testing.T) {
-	av, err := os.Open("../testdata/auxv.bin")
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { av.Close() })
+	for _, testcase := range []struct {
+		source  string
+		is32bit bool
+		address uint64
+	}{
+		{"auxv64le.bin", false, 0x7ffd377e5000},
+		{"auxv32le.bin", true, 0xb7fc3000},
+	} {
+		t.Run(testcase.source, func(t *testing.T) {
+			av, err := os.Open("testdata/" + testcase.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() { av.Close() })
 
-	addr, err := vdsoMemoryAddress(av)
-	if err != nil {
-		t.Fatal(err)
-	}
+			addr, err := vdsoMemoryAddress(av, binary.LittleEndian, testcase.is32bit)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-	expected := uint64(0x7ffd377e5000)
-	if addr != expected {
-		t.Errorf("Expected vDSO memory address %x, got %x", expected, addr)
+			if uint64(addr) != testcase.address {
+				t.Errorf("Expected vDSO memory address %x, got %x", testcase.address, addr)
+			}
+		})
 	}
 }
 
 func TestAuxvNoVDSO(t *testing.T) {
 	// Copy of auxv.bin with the vDSO pointer removed.
-	av, err := os.Open("../testdata/auxv_no_vdso.bin")
+	av, err := os.Open("testdata/auxv64le_no_vdso.bin")
 	if err != nil {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { av.Close() })
 
-	_, err = vdsoMemoryAddress(av)
+	_, err = vdsoMemoryAddress(av, binary.LittleEndian, false)
 	if want, got := errAuxvNoVDSO, err; !errors.Is(got, want) {
 		t.Fatalf("expected error '%v', got: %v", want, got)
 	}
 }
 
+func TestVDSOVersion(t *testing.T) {
+	_, err := vdsoVersion()
+	qt.Assert(t, err, qt.IsNil)
+}
+
 func TestLinuxVersionCodeEmbedded(t *testing.T) {
 	tests := []struct {
 		file    string
 		version uint32
 	}{
 		{
-			"../testdata/vdso.bin",
+			"testdata/vdso.bin",
 			uint32(328828), // 5.4.124
 		},
 		{
-			"../testdata/vdso_multiple_notes.bin",
+			"testdata/vdso_multiple_notes.bin",
 			uint32(328875), // Container Optimized OS v85 with a 5.4.x kernel
 		},
 	}