hookscripts: glob hook directories

Move the directory searching / globbing code out of slurpFiles and into
the filelist module so it can be used elsewhere.

cmd/mkinitfs/main.go

@@ -9,6 +9,7 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/archive"
@@ -19,6 +20,7 @@ import (
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist/hookscripts"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist/initramfs"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist/modules"
+	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist/osksdl"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/misc"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/osutil"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/pkgs/deviceinfo"
@@ -47,13 +49,18 @@ func main() {
 
 	log.Default().SetFlags(log.Lmicroseconds)
 
-	var devinfo deviceinfo.DeviceInfo
-	deverr_usr := devinfo.ReadDeviceinfo("/usr/share/deviceinfo/deviceinfo")
-	deverr_etc := devinfo.ReadDeviceinfo("/etc/deviceinfo")
-	if deverr_etc != nil && deverr_usr != nil {
-		log.Println("Error reading deviceinfo")
-		log.Println("\t/usr/share/deviceinfo/deviceinfo:", deverr_usr)
-		log.Println("\t/etc/deviceinfo:", deverr_etc)
+	deviceinfoFile := "/etc/deviceinfo"
+	if exists, err := misc.Exists(deviceinfoFile); !exists {
+		log.Printf("NOTE: %q not found, this file is required by mkinitfs.\n", deviceinfoFile)
+		return
+	} else if err != nil {
+		retCode = 1
+		log.Printf("received unexpected error when getting status for %q: %s", deviceinfoFile, err)
+	}
+
+	devinfo, err := deviceinfo.ReadDeviceinfo(deviceinfoFile)
+	if err != nil {
+		log.Println(err)
 		retCode = 1
 		return
 	}
@@ -78,98 +85,52 @@ func main() {
 	defer func() {
 		e := os.RemoveAll(workDir)
 		if e != nil && err == nil {
-			log.Println(e)
-			log.Println("unable to remove temporary work directory")
+			err = e
+			retCode = 1
 		}
 	}()
 
 	log.Print("Generating for kernel version: ", kernVer)
 	log.Print("Output directory: ", *outDir)
 
-	//
-	// initramfs
-	//
 	// deviceinfo.InitfsCompression needs a little more post-processing
 	compressionFormat, compressionLevel := archive.ExtractFormatLevel(devinfo.InitfsCompression)
-	log.Printf("== Generating %s ==\n", "initramfs")
-	log.Printf("- Using compression format %s with level %q\n", compressionFormat, compressionLevel)
-
-	start := time.Now()
-	initramfsAr := archive.New(compressionFormat, compressionLevel)
-	initfs := initramfs.New([]filelist.FileLister{
+	if err := generateArchive("initramfs", compressionFormat, compressionLevel, workDir, []filelist.FileLister{
 		hookdirs.New("/usr/share/mkinitfs/dirs"),
 		hookdirs.New("/etc/mkinitfs/dirs"),
 		hookfiles.New("/usr/share/mkinitfs/files"),
 		hookfiles.New("/etc/mkinitfs/files"),
 		hookscripts.New("/usr/share/mkinitfs/hooks", "/hooks"),
 		hookscripts.New("/etc/mkinitfs/hooks", "/hooks"),
-		modules.New("/usr/share/mkinitfs/modules"),
-		modules.New("/etc/mkinitfs/modules"),
-	})
-	initfsExtra := initramfs.New([]filelist.FileLister{
+		modules.New(strings.Fields(devinfo.ModulesInitfs), "/usr/share/mkinitfs/modules"),
+		modules.New([]string{}, "/etc/mkinitfs/modules"),
+	}); err != nil {
+		log.Println(err)
+		log.Println("failed to generate: ", "initramfs")
+		retCode = 1
+		return
+	}
+
+	// deviceinfo.InitfsExtraCompression needs a little more post-processing
+	compressionFormat, compressionLevel = archive.ExtractFormatLevel(devinfo.InitfsExtraCompression)
+	if err := generateArchive("initramfs-extra", compressionFormat, compressionLevel, workDir, []filelist.FileLister{
 		hookfiles.New("/usr/share/mkinitfs/files-extra"),
 		hookfiles.New("/etc/mkinitfs/files-extra"),
 		hookscripts.New("/usr/share/mkinitfs/hooks-extra", "/hooks-extra"),
 		hookscripts.New("/etc/mkinitfs/hooks-extra", "/hooks-extra"),
-		modules.New("/usr/share/mkinitfs/modules-extra"),
-		modules.New("/etc/mkinitfs/modules-extra"),
-	})
-
-	if err := initramfsAr.AddItems(initfs); err != nil {
+		modules.New([]string{}, "/usr/share/mkinitfs/modules-extra"),
+		modules.New([]string{}, "/etc/mkinitfs/modules-extra"),
+		osksdl.New(devinfo.MesaDriver),
+	}); err != nil {
 		log.Println(err)
-		log.Println("failed to generate: ", "initramfs")
+		log.Println("failed to generate: ", "initramfs-extra")
 		retCode = 1
 		return
 	}
 
-	// Include initramfs-extra files in the initramfs if not making a separate
-	// archive
-	if !devinfo.CreateInitfsExtra {
-		if err := initramfsAr.AddItems(initfsExtra); err != nil {
-			log.Println(err)
-			log.Println("failed to generate: ", "initramfs")
-			retCode = 1
-			return
-		}
-	}
-
-	if err := initramfsAr.Write(filepath.Join(workDir, "initramfs"), os.FileMode(0644)); err != nil {
-		log.Println(err)
-		log.Println("failed to generate: ", "initramfs")
-		retCode = 1
-		return
-	}
-	misc.TimeFunc(start, "initramfs")
-
-	if devinfo.CreateInitfsExtra {
-		//
-		// initramfs-extra
-		//
-		// deviceinfo.InitfsExtraCompression needs a little more post-processing
-		compressionFormat, compressionLevel = archive.ExtractFormatLevel(devinfo.InitfsExtraCompression)
-		log.Printf("== Generating %s ==\n", "initramfs-extra")
-		log.Printf("- Using compression format %s with level %q\n", compressionFormat, compressionLevel)
-
-		start = time.Now()
-		initramfsExtraAr := archive.New(compressionFormat, compressionLevel)
-		if err := initramfsExtraAr.AddItemsExclude(initfsExtra, initfs); err != nil {
-			log.Println(err)
-			log.Println("failed to generate: ", "initramfs-extra")
-			retCode = 1
-			return
-		}
-		if err := initramfsExtraAr.Write(filepath.Join(workDir, "initramfs-extra"), os.FileMode(0644)); err != nil {
-			log.Println(err)
-			log.Println("failed to generate: ", "initramfs-extra")
-			retCode = 1
-			return
-		}
-		misc.TimeFunc(start, "initramfs-extra")
-	}
-
 	// Final processing of initramfs / kernel is done by boot-deploy
 	if !disableBootDeploy {
-		if err := bootDeploy(workDir, *outDir, devinfo); err != nil {
+		if err := bootDeploy(workDir, *outDir, devinfo.UbootBoardname); err != nil {
 			log.Println(err)
 			log.Println("boot-deploy failed")
 			retCode = 1
@@ -178,10 +139,30 @@ func main() {
 	}
 }
 
-func bootDeploy(workDir string, outDir string, devinfo deviceinfo.DeviceInfo) error {
+func bootDeploy(workDir, outDir, ubootBoardname string) error {
 	log.Print("== Using boot-deploy to finalize/install files ==")
 	defer misc.TimeFunc(time.Now(), "boot-deploy")
 
-	bd := bootdeploy.New(workDir, outDir, devinfo)
+	bd := bootdeploy.New(workDir, outDir, ubootBoardname)
 	return bd.Run()
 }
+
+func generateArchive(name string, format archive.CompressFormat, level archive.CompressLevel, path string, features []filelist.FileLister) error {
+	log.Printf("== Generating %s ==\n", name)
+	log.Printf("- Using compression format %s with level %q\n", format, level)
+
+	defer misc.TimeFunc(time.Now(), name)
+	a := archive.New(format, level)
+
+	fs := initramfs.New(features)
+	if err := a.AddItems(fs); err != nil {
+		return err
+	}
+
+	log.Println("- Writing and verifying archive: ", name)
+	if err := a.Write(filepath.Join(path, name), os.FileMode(0644)); err != nil {
+		return err
+	}
+
+	return nil
+}

doc/mkinitfs.1.scd

@@ -38,14 +38,13 @@ Design goals of this project are:
 The canonical deviceinfo "specification" is at
 https://wiki.postmarketos.org/wiki/Deviceinfo_reference
 
-mkinitfs reads deviceinfo values from */usr/share/deviceinfo/deviceinfo* and
-*/etc/deviceinfo*, in that order. The following variables
+mkinitfs reads deviceinfo values from */etc/deviceinfo*. The following variables
 are *required* by mkinitfs:
 
-	- deviceinfo_create_initfs_extra
-	- deviceinfo_generate_systemd_boot
 	- deviceinfo_initfs_compression
 	- deviceinfo_initfs_extra_compression
+	- deviceinfo_mesa_driver
+	- deviceinfo_modules_initfs
 	- deviceinfo_uboot_boardname
 
 It is a design goal to keep the number of required variables from deviceinfo to
@@ -55,36 +54,6 @@ a bare minimum, and to require only variables that don't hold lists of things.
 necessary tools to extract the configured archive format are in the initramfs
 archive.
 
-# ARCHIVE COMPRESSION
-
-Archive compression parameters are specified in the
-*deviceinfo_initfs_compression* and *deviceinfo_initfs_extra_compression*
-deviceinfo variables. Their values do not have to match, but special
-consideration should be taken since some formats may require additional kernel
-options or tools in the initramfs to support it.
-
-Supported compression *formats* for mkinitfs are:
-
-	- gzip
-	- lz4
-	- lzma
-	- none
-	- zstd
-
-Supported compression *levels* for mkinitfs:
-
-	- best
-	- default
-	- fast
-
-The value of these variables follows this syntax: *<format>:<level>*. For
-example, *zstd* with the *fast* compression level would be:
-*deviceinfo_initfs_compression="zstd:fast"*
-
-Defaults to *gzip* and *default* for both archives if format and/or level is
-unsupported or omitted.
-
-
 # DIRECTORIES
 
 The following directories are used by mkinitfs to generate the initramfs and
@@ -130,9 +99,6 @@ create/manage. mkinitfs reads configuration from */usr/share/mkinitfs* first, an
 	path(s) under the relevant directory in */etc/mkinitfs*, and changing
 	the destination path.
 
-	Any lines in these files that start with *#* are considered comments, and
-	skipped.
-
 ## /usr/share/mkinitfs/hooks, /etc/mkinitfs/hooks
 ## /usr/share/mkinitfs/hooks-extra*, /etc/mkinitfs/hooks-extra
 
@@ -147,25 +113,19 @@ create/manage. mkinitfs reads configuration from */usr/share/mkinitfs* first, an
 ## /usr/share/mkinitfs/modules, /etc/mkinitfs/modules
 ## /usr/share/mkinitfs/modules-extra, /etc/mkinitfs/modules-extra
 
-	Files with the *.modules* extension in these directories are lists of
+	Files with the *.modules* extention in these directories are lists of
 	kernel modules to include in the initramfs. Individual modules and
 	directories can be listed in the files here. Globbing is also supported.
 
 	Modules are installed in the initramfs archive under the same path they
 	exist on the system where mkinitfs is executed.
 
-	Any lines in these files that start with *#* are considered comments, and
-	skipped.
-
 ## /usr/share/mkinitfs/dirs, /etc/mkinitfs/dirs
 
 	Files with the *.dirs* extension in these directories are lists of
 	directories to create within the initramfs. There is no *-extra* variant,
 	since directories are of negligible size.
 
-	Any lines in these files that start with *#* are considered comments, and
-	skipped.
-
 # BOOT-DEPLOY
 
 After generating archives, mkinitfs will execute *boot-deploy*, using *$PATH* to

go.mod

@@ -5,15 +5,6 @@ go 1.20
 require (
 	github.com/cavaliercoder/go-cpio v0.0.0-20180626203310-925f9528c45e
 	github.com/klauspost/compress v1.15.12
-	github.com/pierrec/lz4/v4 v4.1.17
 	github.com/ulikunitz/xz v0.5.10
-	golang.org/x/sys v0.18.0
-)
-
-require (
-	github.com/mvdan/sh v2.6.4+incompatible // indirect
-	golang.org/x/crypto v0.21.0 // indirect
-	golang.org/x/sync v0.6.0 // indirect
-	golang.org/x/term v0.18.0 // indirect
-	mvdan.cc/sh v2.6.4+incompatible // indirect
+	golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c
 )

go.sum

@@ -2,21 +2,7 @@ github.com/cavaliercoder/go-cpio v0.0.0-20180626203310-925f9528c45e h1:hHg27A0RS
 github.com/cavaliercoder/go-cpio v0.0.0-20180626203310-925f9528c45e/go.mod h1:oDpT4efm8tSYHXV5tHSdRvBet/b/QzxZ+XyyPehvm3A=
 github.com/klauspost/compress v1.15.12 h1:YClS/PImqYbn+UILDnqxQCZ3RehC9N318SU3kElDUEM=
 github.com/klauspost/compress v1.15.12/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
-github.com/mvdan/sh v2.6.4+incompatible h1:D4oEWW0J8cL7zeQkrXw76IAYXF0mJfDaBwjgzmKb6zs=
-github.com/mvdan/sh v2.6.4+incompatible/go.mod h1:kipHzrJQZEDCMTNRVRAlMMFjqHEYrthfIlFkJSrmDZE=
-github.com/pierrec/lz4/v4 v4.1.17 h1:kV4Ip+/hUBC+8T6+2EgburRtkE9ef4nbY3f4dFhGjMc=
-github.com/pierrec/lz4/v4 v4.1.17/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/ulikunitz/xz v0.5.10 h1:t92gobL9l3HE202wg3rlk19F6X+JOxl9BBrCCMYEYd8=
 github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
-golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
-golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.18.0 h1:FcHjZXDMxI8mM3nwhX9HlKop4C0YQvCVCdwYl2wOtE8=
-golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
-mvdan.cc/sh v2.6.4+incompatible h1:eD6tDeh0pw+/TOTI1BBEryZ02rD2nMcFsgcvde7jffM=
-mvdan.cc/sh v2.6.4+incompatible/go.mod h1:IeeQbZq+x2SUGBensq/jge5lLQbS3XT2ktyp3wrt4x8=

internal/archive/archive.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/cavaliercoder/go-cpio"
 	"github.com/klauspost/compress/zstd"
-	"github.com/pierrec/lz4/v4"
 	"github.com/ulikunitz/xz"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/osutil"
@@ -29,7 +28,6 @@ type CompressFormat string
 const (
 	FormatGzip CompressFormat = "gzip"
 	FormatLzma CompressFormat = "lzma"
-	FormatLz4  CompressFormat = "lz4"
 	FormatZstd CompressFormat = "zstd"
 	FormatNone CompressFormat = "none"
 )
@@ -106,7 +104,6 @@ func ExtractFormatLevel(s string) (format CompressFormat, level CompressLevel) {
 	case FormatLzma:
 		log.Println("Format lzma doesn't support a compression level, using default settings")
 		level = LevelDefault
-	case FormatLz4:
 	case FormatNone:
 	case FormatZstd:
 	default:
@@ -203,44 +200,9 @@ func (archive *Archive) AddItems(flister filelist.FileLister) error {
 	return nil
 }
 
-// AddItemsExclude is like AddItems, but takes a second FileLister that lists
-// items that should not be added to the archive from the first FileLister
-func (archive *Archive) AddItemsExclude(flister filelist.FileLister, exclude filelist.FileLister) error {
-	list, err := flister.List()
-	if err != nil {
-		return err
-	}
-
-	excludeList, err := exclude.List()
-	if err != nil {
-		return err
-	}
-
-	for i := range list.IterItems() {
-		dest, found := excludeList.Get(i.Source)
-
-		if found {
-			if i.Dest != dest {
-				found = false
-			}
-		}
-
-		if !found {
-			if err := archive.AddItem(i.Source, i.Dest); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
 // Adds the given file or directory at "source" to the archive at "dest"
 func (archive *Archive) AddItem(source string, dest string) error {
-	if osutil.HasMergedUsr() {
-		source = osutil.MergeUsr(source)
-		dest = osutil.MergeUsr(dest)
-	}
+
 	sourceStat, err := os.Lstat(source)
 	if err != nil {
 		e, ok := err.(*os.PathError)
@@ -251,12 +213,6 @@ func (archive *Archive) AddItem(source string, dest string) error {
 		return fmt.Errorf("AddItem: failed to get stat for %q: %w", source, err)
 	}
 
-	// A symlink to a directory doesn't have the os.ModeDir bit set, so we need
-	// to check if it's a symlink first
-	if sourceStat.Mode()&os.ModeSymlink != 0 {
-		return archive.addSymlink(source, dest)
-	}
-
 	if sourceStat.Mode()&os.ModeDir != 0 {
 		return archive.addDir(dest)
 	}
@@ -264,45 +220,6 @@ func (archive *Archive) AddItem(source string, dest string) error {
 	return archive.addFile(source, dest)
 }
 
-func (archive *Archive) addSymlink(source string, dest string) error {
-	target, err := os.Readlink(source)
-	if err != nil {
-		log.Print("addSymlink: failed to get symlink target for: ", source)
-		return err
-	}
-
-	// Make sure we pick up the symlink target too
-	targetAbs := target
-	if filepath.Dir(target) == "." {
-		// relative symlink, make it absolute so we can add the target to the archive
-		targetAbs = filepath.Join(filepath.Dir(source), target)
-	}
-
-	if !filepath.IsAbs(targetAbs) {
-		targetAbs, err = osutil.RelativeSymlinkTargetToDir(targetAbs, filepath.Dir(source))
-		if err != nil {
-			return err
-		}
-	}
-
-	archive.AddItem(targetAbs, targetAbs)
-
-	// Now add the symlink itself
-	destFilename := strings.TrimPrefix(dest, "/")
-
-	archive.items.add(archiveItem{
-		sourcePath: source,
-		header: &cpio.Header{
-			Name:     destFilename,
-			Linkname: target,
-			Mode:     0644 | cpio.ModeSymlink,
-			Size:     int64(len(target)),
-		},
-	})
-
-	return nil
-}
-
 func (archive *Archive) addFile(source string, dest string) error {
 	if err := archive.addDir(filepath.Dir(dest)); err != nil {
 		return err
@@ -314,6 +231,42 @@ func (archive *Archive) addFile(source string, dest string) error {
 		return err
 	}
 
+	// Symlink: write symlink to archive then set 'file' to link target
+	if sourceStat.Mode()&os.ModeSymlink != 0 {
+		// log.Printf("File %q is a symlink", file)
+		target, err := os.Readlink(source)
+		if err != nil {
+			log.Print("addFile: failed to get symlink target: ", source)
+			return err
+		}
+
+		destFilename := strings.TrimPrefix(dest, "/")
+
+		archive.items.add(archiveItem{
+			sourcePath: source,
+			header: &cpio.Header{
+				Name:     destFilename,
+				Linkname: target,
+				Mode:     0644 | cpio.ModeSymlink,
+				Size:     int64(len(target)),
+				// Checksum: 1,
+			},
+		})
+
+		if filepath.Dir(target) == "." {
+			target = filepath.Join(filepath.Dir(source), target)
+		}
+		// make sure target is an absolute path
+		if !filepath.IsAbs(target) {
+			target, err = osutil.RelativeSymlinkTargetToDir(target, filepath.Dir(source))
+			if err != nil {
+				return err
+			}
+		}
+		err = archive.addFile(target, target)
+		return err
+	}
+
 	destFilename := strings.TrimPrefix(dest, "/")
 
 	archive.items.add(archiveItem{
@@ -363,23 +316,6 @@ func (archive *Archive) writeCompressed(path string, mode os.FileMode) (err erro
 		if err != nil {
 			return err
 		}
-	case FormatLz4:
-		// The default compression for the lz4 library is Fast, and
-		// they don't define a Default level otherwise
-		level := lz4.Fast
-		switch archive.compress_level {
-		case LevelBest:
-			level = lz4.Level9
-		case LevelFast:
-			level = lz4.Fast
-		}
-
-		var writer = lz4.NewWriter(fd)
-		err = writer.Apply(lz4.LegacyOption(true), lz4.CompressionLevelOption(level))
-		if err != nil {
-			return err
-		}
-		compressor = writer
 	case FormatNone:
 		compressor = fd
 	case FormatZstd:
@@ -416,13 +352,6 @@ func (archive *Archive) writeCompressed(path string, mode os.FileMode) (err erro
 }
 
 func (archive *Archive) writeCpio() error {
-	// Just in case
-	if osutil.HasMergedUsr() {
-		archive.addSymlink("/bin", "/bin")
-		archive.addSymlink("/sbin", "/sbin")
-		archive.addSymlink("/lib", "/lib")
-		archive.addSymlink("/usr/sbin", "/usr/sbin")
-	}
 	// having a transient function for actually adding files to the archive
 	// allows the deferred fd.close to run after every copy and prevent having
 	// tons of open file handles until the copying is all done
@@ -437,19 +366,19 @@ func (archive *Archive) writeCpio() error {
 			if header.Mode.IsRegular() {
 				fd, err := os.Open(source)
 				if err != nil {
-					return fmt.Errorf("archive.writeCpio: Unable to open file %q, %w", source, err)
+					return fmt.Errorf("archive.writeCpio: uname to open file %q, %w", source, err)
 				}
 				defer fd.Close()
 				if _, err := io.Copy(archive.cpioWriter, fd); err != nil {
-					return fmt.Errorf("archive.writeCpio: Couldn't process %q: %w", source, err)
+					return fmt.Errorf("archive.writeCpio: unable to write out archive: %w", err)
 				}
 			} else if header.Linkname != "" {
 				// the contents of a symlink is just need the link name
 				if _, err := archive.cpioWriter.Write([]byte(header.Linkname)); err != nil {
-					return fmt.Errorf("archive.writeCpio: unable to write out symlink: %q -> %q: %w", source, header.Linkname, err)
+					return fmt.Errorf("archive.writeCpio: unable to write out symlink: %w", err)
 				}
 			} else {
-				return fmt.Errorf("archive.writeCpio: unknown type for file: %q: %d", source, header.Mode)
+				return fmt.Errorf("archive.writeCpio: unknown type for file: %s", source)
 			}
 		}
 

internal/archive/archive_test.go

@@ -249,12 +249,6 @@ func TestExtractFormatLevel(t *testing.T) {
 			expectedFormat: FormatLzma,
 			expectedLevel:  LevelDefault,
 		},
-		{
-			name:           "lz4, fast",
-			in:             "lz4:fast",
-			expectedFormat: FormatLz4,
-			expectedLevel:  LevelFast,
-		},
 		{
 			name:           "none",
 			in:             "none",

internal/bootdeploy/bootdeploy.go

@@ -10,32 +10,32 @@ import (
 	"path"
 	"path/filepath"
 	"strings"
-
-	"gitlab.com/postmarketOS/postmarketos-mkinitfs/pkgs/deviceinfo"
 )
 
 type BootDeploy struct {
-	inDir   string
-	outDir  string
-	devinfo deviceinfo.DeviceInfo
+	inDir          string
+	outDir         string
+	ubootBoardname string
 }
 
 // New returns a new BootDeploy, which then runs:
 //
 //	boot-deploy -d indir -o outDir
 //
-// devinfo is used to access some deviceinfo values, such as UbootBoardname
-// and GenerateSystemdBoot
-func New(inDir string, outDir string, devinfo deviceinfo.DeviceInfo) *BootDeploy {
+// ubootBoardname is used for copying in some u-boot files prior to running
+// boot-deploy. This is optional, passing an empty string is ok if this is not
+// needed.
+func New(inDir, outDir, ubootBoardname string) *BootDeploy {
 	return &BootDeploy{
-		inDir:   inDir,
-		outDir:  outDir,
-		devinfo: devinfo,
+		inDir:          inDir,
+		outDir:         outDir,
+		ubootBoardname: ubootBoardname,
 	}
 }
 
 func (b *BootDeploy) Run() error {
-	if err := copyUbootFiles(b.inDir, b.devinfo.UbootBoardname); errors.Is(err, os.ErrNotExist) {
+
+	if err := copyUbootFiles(b.inDir, b.ubootBoardname); errors.Is(err, os.ErrNotExist) {
 		log.Println("u-boot files copying skipped: ", err)
 	} else {
 		if err != nil {
@@ -43,9 +43,15 @@ func (b *BootDeploy) Run() error {
 		}
 	}
 
-	kernels, err := getKernelPath(b.outDir, b.devinfo.GenerateSystemdBoot == "true")
-	if err != nil {
-		return err
+	return bootDeploy(b.inDir, b.outDir)
+}
+
+func bootDeploy(workDir string, outDir string) error {
+	// boot-deploy expects the kernel to be in the same dir as initramfs.
+	// Assume that the kernel is in the output dir...
+	kernels, _ := filepath.Glob(filepath.Join(outDir, "vmlinuz*"))
+	if len(kernels) == 0 {
+		return errors.New("Unable to find any kernels at " + filepath.Join(outDir, "vmlinuz*"))
 	}
 
 	// Pick a kernel that does not have suffixes added by boot-deploy
@@ -65,7 +71,7 @@ func (b *BootDeploy) Run() error {
 	defer kernFd.Close()
 
 	kernFilename := path.Base(kernFile)
-	kernFileCopy, err := os.Create(filepath.Join(b.inDir, kernFilename))
+	kernFileCopy, err := os.Create(filepath.Join(workDir, kernFilename))
 	if err != nil {
 		return err
 	}
@@ -78,17 +84,12 @@ func (b *BootDeploy) Run() error {
 	}
 
 	// boot-deploy -i initramfs -k vmlinuz-postmarketos-rockchip -d /tmp/cpio -o /tmp/foo initramfs-extra
-	args := []string{
+	cmd := exec.Command("boot-deploy",
 		"-i", "initramfs",
 		"-k", kernFilename,
-		"-d", b.inDir,
-		"-o", b.outDir,
-	}
-
-	if b.devinfo.CreateInitfsExtra {
-		args = append(args, "initramfs-extra")
-	}
-	cmd := exec.Command("boot-deploy", args...)
+		"-d", workDir,
+		"-o", outDir,
+		"initramfs-extra")
 
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -99,25 +100,6 @@ func (b *BootDeploy) Run() error {
 	return nil
 }
 
-func getKernelPath(outDir string, zboot bool) ([]string, error) {
-	var kernels []string
-	if zboot {
-		kernels, _ = filepath.Glob(filepath.Join(outDir, "linux.efi"))
-		if len(kernels) > 0 {
-			return kernels, nil
-		}
-		// else fallback to vmlinuz* below
-	}
-
-	kernFile := "vmlinuz*"
-	kernels, _ = filepath.Glob(filepath.Join(outDir, kernFile))
-	if len(kernels) == 0 {
-		return nil, errors.New("Unable to find any kernels at " + filepath.Join(outDir, kernFile))
-	}
-
-	return kernels, nil
-}
-
 // Copy copies the file at srcFile path to a new file at dstFile path
 func copy(srcFile, dstFile string) error {
 	out, err := os.Create(dstFile)

internal/filelist/filelist.go

@@ -1,6 +1,12 @@
 package filelist
 
-import "sync"
+import (
+	"fmt"
+	"path/filepath"
+	"sync"
+
+	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/misc"
+)
 
 type FileLister interface {
 	List() (*FileList, error)
@@ -45,6 +51,26 @@ func (f *FileList) Import(src *FileList) {
 	}
 }
 
+func (f *FileList) AddGlobbed(src string, dest string) error {
+	fFiles, err := misc.GetFiles([]string{src}, true)
+	if err != nil {
+		return fmt.Errorf("unable to add %q: %w", src, err)
+	}
+	// loop over all returned files from GetFile
+	for _, file := range fFiles {
+		if len(fFiles) > 1 {
+			// Glob with arbitrary subdirectories, so we need to
+			// remove the src path and prepend the dest path
+			f.Add(file, filepath.Join(dest, file[len(src):]))
+		} else {
+			// dest path specified, and only 1 file
+			f.Add(file, dest)
+		}
+	}
+
+	return nil
+}
+
 // iterate through the list and and send each one as a new File over the
 // returned channel
 func (f *FileList) IterItems() <-chan File {

internal/filelist/hookdirs/hookdirs.go

@@ -6,7 +6,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist"
 )
@@ -44,11 +43,7 @@ func (h *HookDirs) List() (*filelist.FileList, error) {
 
 		s := bufio.NewScanner(f)
 		for s.Scan() {
-			dir := strings.TrimSpace(s.Text())
-			if len(dir) == 0 || strings.HasPrefix(dir, "#") {
-				continue
-			}
-
+			dir := s.Text()
 			files.Add(dir, dir)
 		}
 	}

internal/filelist/hookfiles/hookfiles.go

@@ -10,8 +10,6 @@ import (
 	"strings"
 
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist"
-	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/misc"
-	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/osutil"
 )
 
 type HookFiles struct {
@@ -59,32 +57,15 @@ func slurpFiles(fd io.Reader) (*filelist.FileList, error) {
 
 	s := bufio.NewScanner(fd)
 	for s.Scan() {
-		line := strings.TrimSpace(s.Text())
-		if len(line) == 0 || strings.HasPrefix(line, "#") {
-			continue
+		src, dest, has_dest := strings.Cut(s.Text(), ":")
+
+		if !has_dest {
+			dest = src
 		}
 
-		src, dest, has_dest := strings.Cut(line, ":")
-		if osutil.HasMergedUsr() {
-			src = osutil.MergeUsr(src)
-		}
-
-		fFiles, err := misc.GetFiles([]string{src}, true)
+		err := files.AddGlobbed(src, dest)
 		if err != nil {
-			return nil, fmt.Errorf("unable to add %q: %w", src, err)
-		}
-		// loop over all returned files from GetFile
-		for _, file := range fFiles {
-			if !has_dest {
-				files.Add(file, file)
-			} else if len(fFiles) > 1 {
-				// Don't support specifying dest if src was a glob
-				// NOTE: this could support this later...
-				files.Add(file, file)
-			} else {
-				// dest path specified, and only 1 file
-				files.Add(file, dest)
-			}
+			return nil, err
 		}
 	}
 

internal/filelist/hookscripts/hookscripts.go

@@ -35,8 +35,13 @@ func (h *HookScripts) List() (*filelist.FileList, error) {
 	}
 	for _, file := range fileInfo {
 		path := filepath.Join(h.scriptsDir, file.Name())
-		log.Printf("-- Including script: %s\n", path)
-		files.Add(path, filepath.Join(h.destPath, file.Name()))
+		if file.IsDir() {
+			log.Printf("-- Including dir %s\n", path)
+			files.AddGlobbed(filepath.Join(path, "*"), filepath.Join(h.destPath, file.Name()))
+		} else {
+			log.Printf("-- Including script: %s\n", path)
+			files.Add(path, filepath.Join(h.destPath, file.Name()))
+		}
 	}
 	return files, nil
 }

internal/filelist/initramfs/initramfs.go

@@ -9,7 +9,6 @@ import (
 // combining the output from them.
 type Initramfs struct {
 	features []filelist.FileLister
-	files    *filelist.FileList
 }
 
 // New returns a new Initramfs that generate a list of files based on the given
@@ -21,18 +20,15 @@ func New(features []filelist.FileLister) *Initramfs {
 }
 
 func (i *Initramfs) List() (*filelist.FileList, error) {
-	if i.files != nil {
-		return i.files, nil
-	}
-	i.files = filelist.NewFileList()
+	files := filelist.NewFileList()
 
 	for _, f := range i.features {
 		list, err := f.List()
 		if err != nil {
 			return nil, err
 		}
-		i.files.Import(list)
+		files.Import(list)
 	}
 
-	return i.files, nil
+	return files, nil
 }

internal/filelist/modules/modules.go

@@ -17,11 +17,14 @@ import (
 
 type Modules struct {
 	modulesListPath string
+	modulesList     []string
 }
 
-// New returns a new Modules that will read in lists of kernel modules in the given path.
-func New(modulesListPath string) *Modules {
+// New returns a new Modules that will use the given moduleto provide a list
+// of script files.
+func New(modulesList []string, modulesListPath string) *Modules {
 	return &Modules{
+		modulesList:     modulesList,
 		modulesListPath: modulesListPath,
 	}
 }
@@ -33,14 +36,8 @@ func (m *Modules) List() (*filelist.FileList, error) {
 	}
 
 	files := filelist.NewFileList()
-	libDir := "/usr/lib/modules"
-	if exists, err := misc.Exists(libDir); !exists {
-		libDir = "/lib/modules"
-	} else if err != nil {
-		return nil, fmt.Errorf("received unexpected error when getting status for %q: %w", libDir, err)
-	}
 
-	modDir := filepath.Join(libDir, kernVer)
+	modDir := filepath.Join("/lib/modules", kernVer)
 	if exists, err := misc.Exists(modDir); !exists {
 		// dir /lib/modules/<kernel> if kernel built without module support, so just print a message
 		log.Printf("-- kernel module directory not found: %q, not including modules", modDir)
@@ -55,6 +52,20 @@ func (m *Modules) List() (*filelist.FileList, error) {
 		files.Add(file, file)
 	}
 
+	// slurp up given list of modules
+	if len(m.modulesList) > 0 {
+		log.Printf("-- Including kernel modules from deviceinfo")
+		for _, module := range m.modulesList {
+			if modFilelist, err := getModule(module, modDir); err != nil {
+				return nil, fmt.Errorf("unable to get modules from deviceinfo: %w", err)
+			} else {
+				for _, file := range modFilelist {
+					files.Add(file, file)
+				}
+			}
+		}
+	}
+
 	// slurp up modules from lists in modulesListPath
 	log.Printf("- Searching for kernel modules from %s", m.modulesListPath)
 	fileInfo, err := os.ReadDir(m.modulesListPath)
@@ -83,10 +94,7 @@ func slurpModules(fd io.Reader, modDir string) (*filelist.FileList, error) {
 	files := filelist.NewFileList()
 	s := bufio.NewScanner(fd)
 	for s.Scan() {
-		line := strings.TrimSpace(s.Text())
-		if len(line) == 0 || strings.HasPrefix(line, "#") {
-			continue
-		}
+		line := s.Text()
 		dir, file := filepath.Split(line)
 		if file == "" {
 			// item is a directory
@@ -103,8 +111,8 @@ func slurpModules(fd io.Reader, modDir string) (*filelist.FileList, error) {
 			}
 		} else if dir == "" {
 			// item is a module name
-			if modFilelist, err := getModule(line, modDir); err != nil {
-				return nil, fmt.Errorf("unable to get module file %q: %w", line, err)
+			if modFilelist, err := getModule(s.Text(), modDir); err != nil {
+				return nil, fmt.Errorf("unable to get module file %q: %w", s.Text(), err)
 			} else {
 				for _, file := range modFilelist {
 					files.Add(file, file)
@@ -124,9 +132,7 @@ func getModulesInDir(modPath string) (files []string, err error) {
 			// Unable to walk path
 			return err
 		}
-		// this assumes module names are in the format <name>.ko[.format],
-		// where ".format" (e.g. ".gz") is optional.
-		if !strings.Contains(".ko", path) {
+		if filepath.Ext(path) != ".ko" && filepath.Ext(path) != ".xz" {
 			return nil
 		}
 		files = append(files, path)
@@ -188,12 +194,7 @@ func getModuleDeps(modName string, modulesDep io.Reader) ([]string, error) {
 
 	s := bufio.NewScanner(modulesDep)
 	for s.Scan() {
-		line := strings.TrimSpace(s.Text())
-		if len(line) == 0 || strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		fields := strings.Fields(line)
+		fields := strings.Fields(s.Text())
 		if len(fields) == 0 {
 			continue
 		}

internal/filelist/modules/modules_test.go

@@ -18,7 +18,6 @@ func TestStripExts(t *testing.T) {
 		{"another_file", "another_file"},
 		{"a.b.c.d.e.f.g.h.i", "a"},
 		{"virtio_blk.ko", "virtio_blk"},
-		{"virtio_blk.ko ", "virtio_blk"},
 	}
 	for _, table := range tables {
 		out := stripExts(table.in)

internal/filelist/osksdl/osksdl.go

@@ -0,0 +1,158 @@
+package osksdl
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist"
+	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/misc"
+)
+
+type OskSdl struct {
+	mesaDriver string
+}
+
+// New returns a new HookScripts that will use the given path to provide a list
+// of script files.
+func New(mesaDriverName string) *OskSdl {
+	return &OskSdl{
+		mesaDriver: mesaDriverName,
+	}
+}
+
+// Get a list of files and their dependencies related to supporting rootfs full
+// disk (d)encryption
+func (s *OskSdl) List() (*filelist.FileList, error) {
+	files := filelist.NewFileList()
+
+	if exists, err := misc.Exists("/usr/bin/osk-sdl"); !exists {
+		return files, nil
+	} else if err != nil {
+		return files, fmt.Errorf("received unexpected error when getting status for %q: %w", "/usr/bin/osk-sdl", err)
+	}
+
+	log.Println("- Including osk-sdl support")
+
+	confFiles := []string{
+		"/etc/osk.conf",
+		"/etc/ts.conf",
+		"/etc/pointercal",
+		"/etc/fb.modes",
+		"/etc/directfbrc",
+	}
+	confFileList, err := misc.GetFiles(confFiles, false)
+	if err != nil {
+		return nil, fmt.Errorf("getFdeFiles: failed to add files: %w", err)
+	}
+	for _, file := range confFileList {
+		files.Add(file, file)
+	}
+
+	// osk-sdl
+	oskFiles := []string{
+		"/usr/bin/osk-sdl",
+		"/sbin/cryptsetup",
+		"/usr/lib/libGL.so.1",
+	}
+	if oskFileList, err := misc.GetFiles(oskFiles, true); err != nil {
+		return nil, fmt.Errorf("getFdeFiles: failed to add files: %w", err)
+	} else {
+		for _, file := range oskFileList {
+			files.Add(file, file)
+		}
+	}
+
+	fontFile, err := getOskConfFontPath("/etc/osk.conf")
+	if err != nil {
+		return nil, fmt.Errorf("getFdeFiles: failed to add file %q: %w", fontFile, err)
+	}
+	files.Add(fontFile, fontFile)
+
+	// Directfb
+	dfbFiles := []string{}
+	err = filepath.Walk("/usr/lib/directfb-1.7-7", func(path string, f os.FileInfo, err error) error {
+		if filepath.Ext(path) == ".so" {
+			dfbFiles = append(dfbFiles, path)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("getFdeFiles: failed to add file %w", err)
+	}
+	if dfbFileList, err := misc.GetFiles(dfbFiles, true); err != nil {
+		return nil, fmt.Errorf("getFdeFiles: failed to add files: %w", err)
+	} else {
+		for _, file := range dfbFileList {
+			files.Add(file, file)
+		}
+	}
+
+	// tslib
+	tslibFiles := []string{}
+	err = filepath.Walk("/usr/lib/ts", func(path string, f os.FileInfo, err error) error {
+		if filepath.Ext(path) == ".so" {
+			tslibFiles = append(tslibFiles, path)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("getFdeFiles: failed to add file: %w", err)
+	}
+	libts, _ := filepath.Glob("/usr/lib/libts*")
+	tslibFiles = append(tslibFiles, libts...)
+	if tslibFileList, err := misc.GetFiles(tslibFiles, true); err != nil {
+		return nil, fmt.Errorf("getFdeFiles: failed to add files: %w", err)
+	} else {
+		for _, file := range tslibFileList {
+			files.Add(file, file)
+		}
+	}
+
+	// mesa hw accel
+	if s.mesaDriver != "" {
+		mesaFiles := []string{
+			"/usr/lib/libEGL.so.1",
+			"/usr/lib/libGLESv2.so.2",
+			"/usr/lib/libgbm.so.1",
+			"/usr/lib/libudev.so.1",
+			"/usr/lib/xorg/modules/dri/" + s.mesaDriver + "_dri.so",
+		}
+		if mesaFileList, err := misc.GetFiles(mesaFiles, true); err != nil {
+			return nil, fmt.Errorf("getFdeFiles: failed to add files: %w", err)
+		} else {
+			for _, file := range mesaFileList {
+				files.Add(file, file)
+			}
+		}
+	}
+
+	return files, nil
+}
+
+func getOskConfFontPath(oskConfPath string) (string, error) {
+	var path string
+	f, err := os.Open(oskConfPath)
+	if err != nil {
+		return path, err
+	}
+	defer f.Close()
+	s := bufio.NewScanner(f)
+	for s.Scan() {
+		fields := strings.Fields(s.Text())
+		// "key = val" is 3 fields
+		if len(fields) > 2 && fields[0] == "keyboard-font" {
+			path = fields[2]
+		}
+	}
+	if exists, err := misc.Exists(path); !exists {
+		return path, fmt.Errorf("unable to find font: %s", path)
+	} else if err != nil {
+		return path, fmt.Errorf("received unexpected error when getting status for %q: %w", path, err)
+	}
+
+	return path, nil
+}

internal/misc/getfiles.go

@@ -41,22 +41,10 @@ func getFile(file string, required bool) (files []string, err error) {
 
 	fileInfo, err := os.Stat(file)
 	if err != nil {
-		// Check if there is a Zstd-compressed version of the file
-		fileZstd := file + ".zst" // .zst is the extension used by linux-firmware
-		fileInfoZstd, errZstd := os.Stat(fileZstd)
-
-		if errZstd == nil {
-			file = fileZstd
-			fileInfo = fileInfoZstd
-			// Unset nil so we don't retain the error from the os.Stat call for the uncompressed version.
-			err = nil
-		} else {
-			if required {
-				return files, fmt.Errorf("getFile: failed to stat file %q: %w (also tried %q: %w)", file, err, fileZstd, errZstd)
-			}
-
-			return files, nil
+		if required {
+			return files, fmt.Errorf("getFile: failed to stat file %q: %w", file, err)
 		}
+		return files, nil
 	}
 
 	if fileInfo.IsDir() {
@@ -120,7 +108,6 @@ func getDeps(file string, parents map[string]struct{}) (files []string, err erro
 		"/usr/lib",
 		"/lib",
 		"/usr/lib/expect*",
-		"/usr/lib/systemd",
 	}
 
 	for _, lib := range libs {

internal/osutil/osutil.go

@@ -10,44 +10,6 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-// Try to guess whether the system has merged dirs under /usr
-func HasMergedUsr() bool {
-	for _, dir := range []string{"/bin", "/lib"} {
-		stat, err := os.Lstat(dir)
-		if err != nil {
-			// TODO: probably because the dir doesn't exist... so
-			// should we assume that it's because the system has some weird
-			// implementation of "merge /usr"?
-			return true
-		} else if stat.Mode()&os.ModeSymlink == 0 {
-			// Not a symlink, so must not be merged /usr
-			return false
-		}
-	}
-	return true
-}
-
-// Converts given path to one supported by a merged /usr config.
-// E.g., /bin/foo becomes /usr/bin/foo, /lib/bar becomes /usr/lib/bar
-// See: https://www.freedesktop.org/wiki/Software/systemd/TheCaseForTheUsrMerge
-func MergeUsr(file string) string {
-
-	// Prepend /usr to supported paths
-	for _, prefix := range []string{"/bin", "/sbin", "/lib", "/lib64"} {
-		if strings.HasPrefix(file, prefix) {
-			file = filepath.Join("/usr", file)
-			break
-		}
-	}
-
-	// Convert /usr/sbin --> /usr/bin
-	if part, found := strings.CutPrefix(file, "/usr/sbin"); found {
-		file = filepath.Join("/usr/bin/", part)
-	}
-
-	return file
-}
-
 // Converts a relative symlink target path (e.g. ../../lib/foo.so), that is
 // absolute path
 func RelativeSymlinkTargetToDir(symPath string, dir string) (string, error) {

internal/osutil/osutil_test.go

@@ -1,49 +0,0 @@
-// Copyright 2024 Clayton Craft <clayton@craftyguy.net>
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package osutil
-
-import (
-	"testing"
-)
-
-func TestMergeUsr(t *testing.T) {
-	subtests := []struct {
-		in       string
-		expected string
-	}{
-		{
-			in:       "/bin/foo",
-			expected: "/usr/bin/foo",
-		},
-		{
-			in:       "/sbin/foo",
-			expected: "/usr/bin/foo",
-		},
-		{
-			in:       "/usr/sbin/foo",
-			expected: "/usr/bin/foo",
-		},
-		{
-			in:       "/usr/bin/foo",
-			expected: "/usr/bin/foo",
-		},
-		{
-			in:       "/lib/foo.so",
-			expected: "/usr/lib/foo.so",
-		},
-		{
-			in:       "/lib64/foo.so",
-			expected: "/usr/lib64/foo.so",
-		},
-	}
-
-	for _, st := range subtests {
-		t.Run(st.in, func(t *testing.T) {
-			out := MergeUsr(st.in)
-			if out != st.expected {
-				t.Fatalf("expected: %q, got: %q\n", st.expected, out)
-			}
-		})
-	}
-}

pkgs/deviceinfo/deviceinfo.go

@@ -4,82 +4,87 @@
 package deviceinfo
 
 import (
-	"context"
+	"bufio"
 	"fmt"
+	"io"
+	"log"
+	"os"
 	"reflect"
-	"strconv"
 	"strings"
-	"time"
-
-	"github.com/mvdan/sh/shell"
-	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/misc"
 )
 
 type DeviceInfo struct {
 	InitfsCompression      string
 	InitfsExtraCompression string
+	MesaDriver             string
+	ModulesInitfs          string
 	UbootBoardname         string
-	GenerateSystemdBoot    string
-	FormatVersion          string
-	CreateInitfsExtra      bool
 }
 
-// Reads the relevant entries from "file" into DeviceInfo struct
-// Any already-set entries will be overwriten if they are present
-// in "file"
-func (d *DeviceInfo) ReadDeviceinfo(file string) error {
-	if exists, err := misc.Exists(file); !exists {
-		return fmt.Errorf("%q not found, required by mkinitfs", file)
-	} else if err != nil {
-		return fmt.Errorf("unexpected error getting status for %q: %s", file, err)
+func ReadDeviceinfo(file string) (DeviceInfo, error) {
+	var deviceinfo DeviceInfo
+
+	fd, err := os.Open(file)
+	if err != nil {
+		return deviceinfo, err
+	}
+	defer fd.Close()
+
+	if err := unmarshal(fd, &deviceinfo); err != nil {
+		return deviceinfo, err
 	}
 
-	if err := d.unmarshal(file); err != nil {
-		return err
-	}
-
-	return nil
+	return deviceinfo, nil
 }
 
 // Unmarshals a deviceinfo into a DeviceInfo struct
-func (d *DeviceInfo) unmarshal(file string) error {
-	ctx, cancelCtx := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))
-	defer cancelCtx()
-	vars, err := shell.SourceFile(ctx, file)
-	if err != nil {
-		return fmt.Errorf("parsing deviceinfo %q failed: %w", file, err)
-	}
+func unmarshal(r io.Reader, devinfo *DeviceInfo) error {
+	s := bufio.NewScanner(r)
+	for s.Scan() {
+		line := s.Text()
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
 
-	for k, v := range vars {
-		fieldName := nameToField(k)
-		field := reflect.ValueOf(d).Elem().FieldByName(fieldName)
+		// line isn't setting anything, so just ignore it
+		if !strings.Contains(line, "=") {
+			continue
+		}
+
+		// sometimes line has a comment at the end after setting an option
+		line = strings.SplitN(line, "#", 2)[0]
+		line = strings.TrimSpace(line)
+
+		// must support having '=' in the value (e.g. kernel cmdline)
+		parts := strings.SplitN(line, "=", 2)
+		if len(parts) != 2 {
+			return fmt.Errorf("error parsing deviceinfo line, invalid format: %s", line)
+		}
+
+		name, val := parts[0], parts[1]
+		val = strings.ReplaceAll(val, "\"", "")
+
+		if name == "deviceinfo_format_version" && val != "0" {
+			return fmt.Errorf("deviceinfo format version %q is not supported", val)
+		}
+
+		fieldName := nameToField(name)
+
+		if fieldName == "" {
+			return fmt.Errorf("error parsing deviceinfo line, invalid format: %s", line)
+		}
+
+		field := reflect.ValueOf(devinfo).Elem().FieldByName(fieldName)
 		if !field.IsValid() {
 			// an option that meets the deviceinfo "specification", but isn't
 			// one we care about in this module
 			continue
 		}
-		switch field.Interface().(type) {
-		case string:
-			field.SetString(v.String())
-		case bool:
-			if v, err := strconv.ParseBool(v.String()); err != nil {
-				return fmt.Errorf("deviceinfo %q has unsupported type for field %q, expected 'bool'", file, k)
-			} else {
-				field.SetBool(v)
-			}
-		case int:
-			if v, err := strconv.ParseInt(v.String(), 10, 32); err != nil {
-				return fmt.Errorf("deviceinfo %q has unsupported type for field %q, expected 'int'", file, k)
-			} else {
-				field.SetInt(v)
-			}
-		default:
-			return fmt.Errorf("deviceinfo %q has unsupported type for field %q", file, k)
-		}
+		field.SetString(val)
 	}
-
-	if d.FormatVersion != "0" {
-		return fmt.Errorf("deviceinfo %q has an unsupported format version %q", file, d.FormatVersion)
+	if err := s.Err(); err != nil {
+		log.Print("unable to parse deviceinfo: ", err)
+		return err
 	}
 
 	return nil
@@ -103,25 +108,3 @@ func nameToField(name string) string {
 
 	return field
 }
-
-func (d DeviceInfo) String() string {
-	return fmt.Sprintf(`{
-			%s: %v
-			%s: %v
-			%s: %v
-			%s: %v
-			%s: %v
-			%s: %v
-			%s: %v
-			%s: %v
-	}`,
-		"deviceinfo_format_version", d.FormatVersion,
-		"deviceinfo_", d.FormatVersion,
-		"deviceinfo_initfs_compression", d.InitfsCompression,
-		"deviceinfo_initfs_extra_compression", d.InitfsCompression,
-		"deviceinfo_ubootBoardname", d.UbootBoardname,
-		"deviceinfo_generateSystemdBoot", d.GenerateSystemdBoot,
-		"deviceinfo_formatVersion", d.FormatVersion,
-		"deviceinfo_createInitfsExtra", d.CreateInitfsExtra,
-	)
-}

pkgs/deviceinfo/deviceinfo_test.go

@@ -4,32 +4,12 @@
 package deviceinfo
 
 import (
+	"fmt"
+	"reflect"
 	"strings"
 	"testing"
 )
 
-// Test ReadDeviceinfo and the logic of reading from multiple files
-func TestReadDeviceinfo(t *testing.T) {
-	compression_expected := "gz -9"
-
-	var devinfo DeviceInfo
-	err := devinfo.ReadDeviceinfo("./test_resources/deviceinfo-missing")
-	if !strings.Contains(err.Error(), "required by mkinitfs") {
-		t.Errorf("received an unexpected err: %s", err)
-	}
-	err = devinfo.ReadDeviceinfo("./test_resources/deviceinfo-first")
-	if err != nil {
-		t.Errorf("received an unexpected err: %s", err)
-	}
-	err = devinfo.ReadDeviceinfo("./test_resources/deviceinfo-msm")
-	if err != nil {
-		t.Errorf("received an unexpected err: %s", err)
-	}
-	if devinfo.InitfsCompression != compression_expected {
-		t.Errorf("expected %q, got: %q", compression_expected, devinfo.InitfsCompression)
-	}
-}
-
 // Test conversion of name to DeviceInfo struct field format
 func TestNameToField(t *testing.T) {
 	tables := []struct {
@@ -38,11 +18,10 @@ func TestNameToField(t *testing.T) {
 	}{
 		{"deviceinfo_dtb", "Dtb"},
 		{"dtb", "Dtb"},
-		{"deviceinfo_initfs_compression", "InitfsCompression"},
+		{"deviceinfo_modules_initfs", "ModulesInitfs"},
 		{"modules_initfs", "ModulesInitfs"},
-		{"deviceinfo_initfs_compression___", "InitfsCompression"},
+		{"deviceinfo_modules_initfs___", "ModulesInitfs"},
 		{"deviceinfo_initfs_extra_compression", "InitfsExtraCompression"},
-		{"deviceinfo_create_initfs_extra", "CreateInitfsExtra"},
 	}
 
 	for _, table := range tables {
@@ -58,25 +37,39 @@ func TestUnmarshal(t *testing.T) {
 	tables := []struct {
 		// field is just used for reflection within the test, so it must be a
 		// valid DeviceInfo field
-		file     string
-		expected DeviceInfo
+		field    string
+		in       string
+		expected string
 	}{
-		{"./test_resources/deviceinfo-unmarshal-1", DeviceInfo{
-			FormatVersion:          "0",
-			UbootBoardname:         "foobar-bazz",
-			InitfsCompression:      "zstd:--foo=1 -T0 --bar=bazz",
-			InitfsExtraCompression: "",
-			CreateInitfsExtra:      true,
-		},
-		},
+		{"ModulesInitfs", "deviceinfo_modules_initfs=\"panfrost foo bar bazz\"\n", "panfrost foo bar bazz"},
+		{"ModulesInitfs", "deviceinfo_modules_initfs=\"panfrost foo bar bazz\"", "panfrost foo bar bazz"},
+		// line with multiple '='
+		{"InitfsCompression", "deviceinfo_initfs_compression=zstd:--foo=1 -T0 --bar=bazz", "zstd:--foo=1 -T0 --bar=bazz"},
+		// empty option
+		{"ModulesInitfs", "deviceinfo_modules_initfs=\"\"\n", ""},
+		// line with comment at the end
+		{"MesaDriver", "deviceinfo_mesa_driver=\"panfrost\"  # this is a nice driver", "panfrost"},
+		{"", "# this is a comment!\n", ""},
+		// empty lines are fine
+		{"", "", ""},
+		// line with whitepace characters only
+		{"", " \t \n\r", ""},
 	}
 	var d DeviceInfo
 	for _, table := range tables {
-		if err := d.unmarshal(table.file); err != nil {
-			t.Error(err)
+		testName := fmt.Sprintf("unmarshal::'%s':", strings.ReplaceAll(table.in, "\n", "\\n"))
+		if err := unmarshal(strings.NewReader(table.in), &d); err != nil {
+			t.Errorf("%s received an unexpected err: ", err)
 		}
-		if d != table.expected {
-			t.Errorf("expected: %s, got: %s", table.expected, d)
+
+		// Check against expected value
+		field := reflect.ValueOf(&d).Elem().FieldByName(table.field)
+		out := ""
+		if table.field != "" {
+			out = field.String()
+		}
+		if out != table.expected {
+			t.Errorf("%s expected: %q, got: %q", testName, table.expected, out)
 		}
 	}
 

pkgs/deviceinfo/test_resources/deviceinfo-first

@@ -1,3 +0,0 @@
-deviceinfo_format_version="0"
-deviceinfo_initfs_compression="gz -9"
-deviceinfo_mesa_driver="panfrost"

pkgs/deviceinfo/test_resources/deviceinfo-msm

@@ -1,2 +0,0 @@
-deviceinfo_format_version="0"
-deviceinfo_mesa_driver="msm"

pkgs/deviceinfo/test_resources/deviceinfo-unmarshal-1

@@ -1,7 +0,0 @@
-deviceinfo_format_version="0"
-deviceinfo_uboot_boardname="foobar-bazz"
-# line with multiple =
-deviceinfo_initfs_compression="zstd:--foo=1 -T0 --bar=bazz"
-# empty option
-deviceinfo_initfs_extra_compression=""
-deviceinfo_create_initfs_extra="true"