feat: Seek firmware from path specified in /sys/module/firmware_class/parameters/path

Signed-off-by: Yejin Seo <yejseo01@arm.com>

Author: yejseo01

cmd/remoteproc-simulator/main.go

@@ -88,7 +88,7 @@ Example usage:
 
 	rootCmd.Flags().UintVar(&index, "index", 0, "is the N in /sys/class/remoteproc/remoteprocN/.../ (default 0)")
 	rootCmd.Flags().StringVar(&name, "name", "dsp0", "remote processor name written to /sys/class/remoteproc/.../name")
-	rootCmd.Flags().StringVar(&rootDir, "root-dir", "", "location where /sys and /lib will be created")
+	rootCmd.Flags().StringVar(&rootDir, "root-dir", "", "location where /sys will be created")
 	rootCmd.Flags().BoolVar(&showVersion, "version", false, "show version information")
 
 	if err := rootCmd.Execute(); err != nil {

e2e/boostrapping_test.go

@@ -1,6 +1,7 @@
 package e2e
 
 import (
+	"os"
 	"path/filepath"
 	"testing"
 
@@ -50,7 +51,8 @@ func TestBootstrapping(t *testing.T) {
 
 		runSimulator(t, "--root-dir", root, "--index", "99")
 
-		firmwareDir := filepath.Join(root, "lib", "firmware")
-		assert.DirExists(t, firmwareDir)
+		firmwareDir, err := os.ReadFile(filepath.Join(root, "sys", "module", "firmware_class", "parameters", "path"))
+		assert.NoError(t, err)
+		assert.DirExists(t, string(firmwareDir))
 	})
 }

e2e/running_firmware_test.go

@@ -25,7 +25,7 @@ func TestRunningFirmware(t *testing.T) {
 		requireState(t, instanceDir, "offline")
 	})
 
-	t.Run("firmware file must exist in /lib/firmware", func(t *testing.T) {
+	t.Run("firmware file must exist in folder indicated inside /sys/module/firmware_class/parameters/path", func(t *testing.T) {
 		root := t.TempDir()
 		runSimulator(t, "--root-dir", root, "--index", "0")
 		instanceDir := filepath.Join(root, "sys", "class", "remoteproc", "remoteproc0")
@@ -38,7 +38,10 @@ func TestRunningFirmware(t *testing.T) {
 }
 
 func createFirmwareFile(t *testing.T, root, firmwareName string) {
-	firmwarePath := filepath.Join(root, "lib", "firmware", firmwareName)
+	firmwareDirPath, err := os.ReadFile(filepath.Join(root, "sys", "module", "firmware_class", "parameters", "path"))
+	require.NoError(t, err)
+	os.MkdirAll(string(firmwareDirPath), 0755)
+	firmwarePath := filepath.Join(string(firmwareDirPath), firmwareName)
 	require.NoError(t, writeFile(firmwarePath, ""))
 }
 

pkg/simulator/filesystem.go

@@ -7,17 +7,19 @@ import (
 )
 
 type FileSystemManager struct {
-	instanceDir string
-	firmwareDir string
-	createdDirs []string
+	instanceDir         string
+	firmwareDirPathFile string
+	firmwareDir         string
+	createdDirs         []string
 }
 
 func NewFileSystemManager(rootDir string, index uint) *FileSystemManager {
 	instanceName := fmt.Sprintf("remoteproc%d", index)
 	return &FileSystemManager{
-		instanceDir: filepath.Join(rootDir, "sys", "class", "remoteproc", instanceName),
-		firmwareDir: filepath.Join(rootDir, "lib", "firmware"),
-		createdDirs: []string{},
+		instanceDir:         filepath.Join(rootDir, "sys", "class", "remoteproc", instanceName),
+		firmwareDirPathFile: filepath.Join(rootDir, "sys", "module", "firmware_class", "parameters", "path"),
+		firmwareDir:         filepath.Join(rootDir, "userhome", "firmware"),
+		createdDirs:         []string{},
 	}
 }
 
@@ -30,13 +32,24 @@ func (fs *FileSystemManager) BootstrapDirectories() error {
 		fs.createdDirs = append(fs.createdDirs, createdInstancePath)
 	}
 
-	createdFirmwarePath, err := mkdirAll(fs.firmwareDir, 0755)
+	createdFirmwareDirPathFileFolder, err := mkfile(fs.firmwareDirPathFile, 0755)
+	if err != nil {
+		fs.Cleanup()
+		return fmt.Errorf("failed to create firmware path directory: %w", err)
+	}
+	if createdFirmwareDirPathFileFolder != "" {
+		fs.createdDirs = append(fs.createdDirs, createdFirmwareDirPathFileFolder)
+	}
+	// Write Firmware path
+	os.WriteFile(fs.firmwareDirPathFile, []byte(fs.firmwareDir), 0644)
+
+	createdFirmwareDir, err := mkdirAll(fs.firmwareDir, 0755)
 	if err != nil {
 		fs.Cleanup()
 		return fmt.Errorf("failed to create firmware directory: %w", err)
 	}
-	if createdFirmwarePath != "" {
-		fs.createdDirs = append(fs.createdDirs, createdFirmwarePath)
+	if createdFirmwareDir != "" {
+		fs.createdDirs = append(fs.createdDirs, createdFirmwareDir)
 	}
 
 	return nil
@@ -52,6 +65,13 @@ func (fs *FileSystemManager) WriteInstanceFile(filename, content string) error {
 }
 
 func (fs *FileSystemManager) FirmwareExists(firmwareName string) bool {
+	firmwareDir, _ := os.ReadFile(fs.firmwareDirPathFile) // simulate reading the firmware path
+	firmwareDirStr := string(firmwareDir)
+	if firmwareDirStr != fs.firmwareDir {
+		fmt.Printf("firmware path mismatch: expected %s from /sys/module/firmware_class/parameters/path, got %s\n", fs.firmwareDir, firmwareDirStr)
+		return false
+	}
+
 	path := filepath.Join(fs.firmwareDir, firmwareName)
 	_, err := os.Stat(path)
 	return !os.IsNotExist(err)
@@ -75,6 +95,19 @@ func (fs *FileSystemManager) Cleanup() error {
 	return nil
 }
 
+func mkfile(path string, perm os.FileMode) (string, error) {
+	folder, err := mkdirAll(filepath.Dir(path), perm)
+	if err != nil {
+		return "", err
+	}
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, perm)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+	return folder, nil
+}
+
 func mkdirAll(path string, perm os.FileMode) (string, error) {
 	current := path
 	var topmostMissing string