fix(preflights): support for builtin kernel modules (#1737)

* fix(preflights): support for builtin kernel modules

* f

Author: emosbaugh

pkg/collect/host_kernel_modules.go

@@ -4,6 +4,8 @@ import (
 	"bufio"
 	"bytes"
 	"encoding/json"
+	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -157,6 +159,26 @@ type kernelModulesLoaded struct{}
 
 // collect the list of modules that the kernel is aware of.
 func (l kernelModulesLoaded) collect() (map[string]KernelModuleInfo, error) {
+	modules, err := l.collectProc()
+	if err != nil {
+		return nil, fmt.Errorf("proc: %w", err)
+	}
+
+	builtin, err := l.collectBuiltin()
+	if err != nil {
+		return nil, fmt.Errorf("builtin: %w", err)
+	}
+
+	for name, module := range builtin {
+		if _, ok := modules[name]; !ok {
+			modules[name] = module
+		}
+	}
+
+	return modules, nil
+}
+
+func (l kernelModulesLoaded) collectProc() (map[string]KernelModuleInfo, error) {
 	modules := make(map[string]KernelModuleInfo)
 
 	file, err := os.Open("/proc/modules")
@@ -199,6 +221,45 @@ func (l kernelModulesLoaded) collect() (map[string]KernelModuleInfo, error) {
 	return modules, nil
 }
 
+func (l kernelModulesLoaded) collectBuiltin() (map[string]KernelModuleInfo, error) {
+	out, err := exec.Command("uname", "-r").Output()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to determine kernel release")
+	}
+	kernel := strings.TrimSpace(string(out))
+
+	file, err := os.Open(fmt.Sprintf("/usr/lib/modules/%s/modules.builtin", kernel))
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	return l.parseBuiltin(file)
+}
+
+func (l kernelModulesLoaded) parseBuiltin(r io.Reader) (map[string]KernelModuleInfo, error) {
+	modules := make(map[string]KernelModuleInfo)
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		_, file := filepath.Split(scanner.Text())
+		name := strings.TrimSuffix(file, filepath.Ext(file))
+
+		if name == "" {
+			continue
+		}
+
+		modules[name] = KernelModuleInfo{
+			Status: KernelModuleLoaded,
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return modules, nil
+}
+
 func (c *CollectHostKernelModules) RemoteCollect(progressChan chan<- interface{}) (map[string][]byte, error) {
 	return nil, ErrRemoteCollectorNotImplemented
 }

pkg/collect/host_kernel_modules_test.go

@@ -2,6 +2,7 @@ package collect
 
 import (
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/pkg/errors"
@@ -164,3 +165,51 @@ func TestCollectHostKernelModules_Collect(t *testing.T) {
 		})
 	}
 }
+
+func Test_parseBuiltin(t *testing.T) {
+	tests := []struct {
+		name    string
+		content string
+		want    map[string]KernelModuleInfo
+	}{
+		{
+			name:    "empty",
+			content: "",
+			want:    map[string]KernelModuleInfo{},
+		},
+		{
+			name: "basic",
+			content: `kernel/arch/x86/events/rapl.ko
+kernel/arch/x86/events/amd/amd-uncore.ko
+kernel/arch/x86/events/intel/intel-uncore.ko
+kernel/arch/x86/events/intel/intel-cstate.ko`,
+			want: map[string]KernelModuleInfo{
+				"rapl": {
+					Status: KernelModuleLoaded,
+				},
+				"amd-uncore": {
+					Status: KernelModuleLoaded,
+				},
+				"intel-uncore": {
+					Status: KernelModuleLoaded,
+				},
+				"intel-cstate": {
+					Status: KernelModuleLoaded,
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l := kernelModulesLoaded{}
+			got, err := l.parseBuiltin(strings.NewReader(tt.content))
+			if err != nil {
+				t.Errorf("parseBuiltin() error = %v", err)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("parseBuiltin() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}