support building for a specific kernel version

Slightly rework things so that we can provide a kernel release/version
tag to mkinitfs and have it only operate on that, suffixing all the
relevant files and passing the info on to boot-deploy.

Signed-off-by: Caleb Connolly <caleb@postmarketos.org>

Makefile

@@ -13,6 +13,11 @@ GOFLAGS?=
 LDFLAGS+=-s -w -X main.Version=$(VERSION)
 RM?=rm -f
 GOTEST=go test -count=1 -race
+DISABLE_GOGC?=
+
+ifeq ($(DISABLE_GOGC),1)
+	LDFLAGS+=-X main.DisableGC=true
+endif
 
 GOSRC!=find * -name '*.go'
 GOSRC+=go.mod go.sum

cmd/mkinitfs/main.go

@@ -9,6 +9,8 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"runtime/debug"
+	"strings"
 	"time"
 
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/archive"
@@ -26,12 +28,19 @@ import (
 
 // set at build time
 var Version string
+var DisableGC string
 
 func main() {
+	// To allow working around silly GC-related issues, like https://gitlab.com/qemu-project/qemu/-/issues/2560
+	if strings.ToLower(DisableGC) == "true" {
+		debug.SetGCPercent(-1)
+	}
+
 	retCode := 0
 	defer func() { os.Exit(retCode) }()
 
 	outDir := flag.String("d", "/boot", "Directory to output initfs(-extra) and other boot files")
+	kernVerArg := flag.String("k", "guess", "Kernel version to run for")
 
 	var showVersion bool
 	flag.BoolVar(&showVersion, "version", false, "Print version and quit.")
@@ -40,6 +49,8 @@ func main() {
 	flag.BoolVar(&disableBootDeploy, "no-bootdeploy", false, "Disable running 'boot-deploy' after generating archives.")
 	flag.Parse()
 
+	kernVer := *kernVerArg
+
 	if showVersion {
 		fmt.Printf("%s - %s\n", filepath.Base(os.Args[0]), Version)
 		return
@@ -60,11 +71,14 @@ func main() {
 
 	defer misc.TimeFunc(time.Now(), "mkinitfs")
 
-	kernVer, err := osutil.GetKernelVersion()
-	if err != nil {
-		log.Println(err)
-		retCode = 1
-		return
+	if kernVer == "guess" {
+		_kernVer, err := osutil.GetKernelVersion()
+		if err != nil {
+			log.Println(err)
+			retCode = 1
+			return
+		}
+		kernVer = _kernVer
 	}
 
 	// temporary working dir
@@ -103,16 +117,37 @@ func main() {
 		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"),
+		modules.New("/usr/share/mkinitfs/modules", kernVer),
+		modules.New("/etc/mkinitfs/modules", kernVer),
 	})
+	initfsExtra := initramfs.New([]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", kernVer),
+		modules.New("/etc/mkinitfs/modules-extra", kernVer),
+	})
+
 	if err := initramfsAr.AddItems(initfs); 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 {
+
+	// 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, fmt.Sprintf("initramfs-%s", kernVer)), os.FileMode(0644)); err != nil {
 		log.Println(err)
 		log.Println("failed to generate: ", "initramfs")
 		retCode = 1
@@ -120,41 +155,35 @@ func main() {
 	}
 	misc.TimeFunc(start, "initramfs")
 
-	//
-	// 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)
+	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)
-	initfsExtra := initramfs.New([]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 := initramfsExtraAr.AddItemsExclude(initfsExtra, initfs); err != nil {
-		log.Println(err)
-		log.Println("failed to generate: ", "initramfs-extra")
-		retCode = 1
-		return
+		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")
 	}
-	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, kernVer); err != nil {
 			log.Println(err)
 			log.Println("boot-deploy failed")
 			retCode = 1
@@ -163,10 +192,10 @@ func main() {
 	}
 }
 
-func bootDeploy(workDir string, outDir string, devinfo deviceinfo.DeviceInfo) error {
+func bootDeploy(workDir string, outDir string, devinfo deviceinfo.DeviceInfo, kernVer 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, devinfo, kernVer)
 	return bd.Run()
 }

doc/mkinitfs.1.scd

@@ -42,6 +42,7 @@ mkinitfs reads deviceinfo values from */usr/share/deviceinfo/deviceinfo* and
 */etc/deviceinfo*, in that order. The following variables
 are *required* by mkinitfs:
 
+	- deviceinfo_create_initfs_extra
 	- deviceinfo_generate_systemd_boot
 	- deviceinfo_initfs_compression
 	- deviceinfo_initfs_extra_compression

internal/bootdeploy/bootdeploy.go

@@ -18,6 +18,7 @@ type BootDeploy struct {
 	inDir   string
 	outDir  string
 	devinfo deviceinfo.DeviceInfo
+	kernVer string
 }
 
 // New returns a new BootDeploy, which then runs:
@@ -26,11 +27,12 @@ type BootDeploy struct {
 //
 // devinfo is used to access some deviceinfo values, such as UbootBoardname
 // and GenerateSystemdBoot
-func New(inDir string, outDir string, devinfo deviceinfo.DeviceInfo) *BootDeploy {
+func New(inDir string, outDir string, devinfo deviceinfo.DeviceInfo, kernVer string) *BootDeploy {
 	return &BootDeploy{
 		inDir:   inDir,
 		outDir:  outDir,
 		devinfo: devinfo,
+		kernVer: kernVer,
 	}
 }
 
@@ -43,10 +45,11 @@ func (b *BootDeploy) Run() error {
 		}
 	}
 
-	kernels, err := getKernelPath(b.outDir, b.devinfo.GenerateSystemdBoot == "true")
+	kernels, err := getKernelPath(b.outDir, b.kernVer, b.devinfo.GenerateSystemdBoot == "true")
 	if err != nil {
 		return err
 	}
+	println(fmt.Sprintf("kernels: %v\n", kernels))
 
 	// Pick a kernel that does not have suffixes added by boot-deploy
 	var kernFile string
@@ -78,12 +81,19 @@ func (b *BootDeploy) Run() error {
 	}
 
 	// boot-deploy -i initramfs -k vmlinuz-postmarketos-rockchip -d /tmp/cpio -o /tmp/foo initramfs-extra
-	cmd := exec.Command("boot-deploy",
-		"-i", "initramfs",
+	args := []string{
+		"-i", fmt.Sprintf("initramfs-%s", b.kernVer),
 		"-k", kernFilename,
+		"-v", b.kernVer,
 		"-d", b.inDir,
 		"-o", b.outDir,
-		"initramfs-extra")
+	}
+
+	if b.devinfo.CreateInitfsExtra {
+		args = append(args, "initramfs-extra")
+	}
+	println(fmt.Sprintf("Calling boot-deply with args: %v\n", args))
+	cmd := exec.Command("boot-deploy", args...)
 
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -94,20 +104,20 @@ func (b *BootDeploy) Run() error {
 	return nil
 }
 
-func getKernelPath(outDir string, zboot bool) ([]string, error) {
+func getKernelPath(outDir string, kernVer string, zboot bool) ([]string, error) {
 	var kernels []string
 	if zboot {
-		kernels, _ = filepath.Glob(filepath.Join(outDir, "linux.efi"))
+		kernels, _ = filepath.Glob(filepath.Join(outDir, fmt.Sprintf("linux-%s.efi", kernVer)))
 		if len(kernels) > 0 {
 			return kernels, nil
 		}
 		// else fallback to vmlinuz* below
 	}
 
-	kernFile := "vmlinuz*"
+	kernFile := fmt.Sprintf("vmlinuz-%s", kernVer)
 	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 nil, errors.New("Unable to find any kernels at " + filepath.Join(outDir, kernFile) + " or " + filepath.Join(outDir, fmt.Sprintf("linux-%s.efi", kernVer)))
 	}
 
 	return kernels, nil

internal/filelist/modules/modules.go

@@ -12,26 +12,22 @@ import (
 
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/filelist"
 	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/misc"
-	"gitlab.com/postmarketOS/postmarketos-mkinitfs/internal/osutil"
 )
 
 type Modules struct {
 	modulesListPath string
+	kernVer         string
 }
 
 // New returns a new Modules that will read in lists of kernel modules in the given path.
-func New(modulesListPath string) *Modules {
+func New(modulesListPath string, kernVer string) *Modules {
 	return &Modules{
 		modulesListPath: modulesListPath,
+		kernVer:         kernVer,
 	}
 }
 
 func (m *Modules) List() (*filelist.FileList, error) {
-	kernVer, err := osutil.GetKernelVersion()
-	if err != nil {
-		return nil, err
-	}
-
 	files := filelist.NewFileList()
 	libDir := "/usr/lib/modules"
 	if exists, err := misc.Exists(libDir); !exists {
@@ -40,7 +36,7 @@ func (m *Modules) List() (*filelist.FileList, error) {
 		return nil, fmt.Errorf("received unexpected error when getting status for %q: %w", libDir, err)
 	}
 
-	modDir := filepath.Join(libDir, kernVer)
+	modDir := filepath.Join(libDir, m.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)

internal/osutil/osutil.go

@@ -40,11 +40,6 @@ func MergeUsr(file string) string {
 		}
 	}
 
-	// Convert /usr/sbin --> /usr/bin
-	if part, found := strings.CutPrefix(file, "/usr/sbin"); found {
-		file = filepath.Join("/usr/bin/", part)
-	}
-
 	return file
 }
 

internal/osutil/osutil_test.go

@@ -18,11 +18,11 @@ func TestMergeUsr(t *testing.T) {
 		},
 		{
 			in:       "/sbin/foo",
-			expected: "/usr/bin/foo",
+			expected: "/usr/sbin/foo",
 		},
 		{
 			in:       "/usr/sbin/foo",
-			expected: "/usr/bin/foo",
+			expected: "/usr/sbin/foo",
 		},
 		{
 			in:       "/usr/bin/foo",

pkgs/deviceinfo/deviceinfo.go

@@ -21,6 +21,7 @@ type DeviceInfo struct {
 	UbootBoardname         string
 	GenerateSystemdBoot    string
 	FormatVersion          string
+	CreateInitfsExtra      bool
 }
 
 // Reads the relevant entries from "file" into DeviceInfo struct
@@ -112,6 +113,7 @@ func (d DeviceInfo) String() string {
 			%s: %v
 			%s: %v
 			%s: %v
+			%s: %v
 	}`,
 		"deviceinfo_format_version", d.FormatVersion,
 		"deviceinfo_", d.FormatVersion,
@@ -120,5 +122,6 @@ func (d DeviceInfo) String() string {
 		"deviceinfo_ubootBoardname", d.UbootBoardname,
 		"deviceinfo_generateSystemdBoot", d.GenerateSystemdBoot,
 		"deviceinfo_formatVersion", d.FormatVersion,
+		"deviceinfo_createInitfsExtra", d.CreateInitfsExtra,
 	)
 }

pkgs/deviceinfo/deviceinfo_test.go

@@ -42,6 +42,7 @@ func TestNameToField(t *testing.T) {
 		{"modules_initfs", "ModulesInitfs"},
 		{"deviceinfo_initfs_compression___", "InitfsCompression"},
 		{"deviceinfo_initfs_extra_compression", "InitfsExtraCompression"},
+		{"deviceinfo_create_initfs_extra", "CreateInitfsExtra"},
 	}
 
 	for _, table := range tables {
@@ -65,6 +66,7 @@ func TestUnmarshal(t *testing.T) {
 			UbootBoardname:         "foobar-bazz",
 			InitfsCompression:      "zstd:--foo=1 -T0 --bar=bazz",
 			InitfsExtraCompression: "",
+			CreateInitfsExtra:      true,
 		},
 		},
 	}

pkgs/deviceinfo/test_resources/deviceinfo-unmarshal-1

@@ -4,3 +4,4 @@ deviceinfo_uboot_boardname="foobar-bazz"
 deviceinfo_initfs_compression="zstd:--foo=1 -T0 --bar=bazz"
 # empty option
 deviceinfo_initfs_extra_compression=""
+deviceinfo_create_initfs_extra="true" # in-line comment that should be ignored