feat: Go implement lsmod and rmmod

Signed-off-by: Fred Rolland <frolland@nvidia.com>

Author: rollandf

entrypoint/internal/utils/host/host.go

@@ -18,6 +18,9 @@ package host
 
 import (
 	"context"
+	"fmt"
+	"strconv"
+	"strings"
 
 	"github.com/Mellanox/doca-driver-build/entrypoint/internal/utils/cmd"
 	"github.com/Mellanox/doca-driver-build/entrypoint/internal/wrappers"
@@ -73,13 +76,76 @@ type LoadedModule struct {
 
 // LsMod is the default implementation of the host.Interface.
 func (h *host) LsMod(ctx context.Context) (map[string]LoadedModule, error) {
-	// TODO: add implementation
-	//nolint:nilnil
-	return nil, nil
+	// Execute lsmod command
+	stdout, stderr, err := h.cmd.RunCommand(ctx, "lsmod")
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute lsmod command: %w, stderr: %s", err, stderr)
+	}
+
+	// Parse the output
+	modules := make(map[string]LoadedModule)
+	lines := strings.Split(strings.TrimSpace(stdout), "\n")
+
+	// Skip the header line
+	for i, line := range lines {
+		if i == 0 {
+			continue // Skip header line "Module                  Size  Used by"
+		}
+
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		// Parse each line: module_name size ref_count [dependent_modules]
+		fields := strings.Fields(line)
+		if len(fields) < 3 {
+			continue // Skip malformed lines
+		}
+
+		moduleName := fields[0]
+		refCountStr := fields[2]
+
+		// Parse reference count
+		refCount, err := strconv.Atoi(refCountStr)
+		if err != nil {
+			// If we can't parse the ref count, set it to 0
+			refCount = 0
+		}
+
+		// Parse dependent modules (everything after the ref count)
+		var usedBy []string
+		if len(fields) > 3 {
+			// Join all fields after ref count and split by comma
+			dependentStr := strings.Join(fields[3:], " ")
+			if dependentStr != "-" {
+				// Split by comma and clean up each module name
+				dependentModules := strings.Split(dependentStr, ",")
+				for _, dep := range dependentModules {
+					dep = strings.TrimSpace(dep)
+					if dep != "" {
+						usedBy = append(usedBy, dep)
+					}
+				}
+			}
+		}
+
+		modules[moduleName] = LoadedModule{
+			Name:     moduleName,
+			RefCount: refCount,
+			UsedBy:   usedBy,
+		}
+	}
+
+	return modules, nil
 }
 
 // RmMod is the default implementation of the host.Interface.
 func (h *host) RmMod(ctx context.Context, module string) error {
-	// TODO: add implementation
+	// Execute rmmod command to unload the kernel module
+	_, stderr, err := h.cmd.RunCommand(ctx, "rmmod", module)
+	if err != nil {
+		return fmt.Errorf("failed to unload kernel module %s: %w, stderr: %s", module, err, stderr)
+	}
 	return nil
 }

entrypoint/internal/utils/host/host_suite_test.go

@@ -0,0 +1,29 @@
+/*
+ Copyright 2025, NVIDIA CORPORATION & AFFILIATES
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+package host
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestHost(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Host Suite")
+}