bootloader/lk: add support for UC20 lk bootloader with V2 lkenv structs

bootloader/bootloader_test.go

@@ -32,6 +32,7 @@ import (
 	"github.com/snapcore/snapd/bootloader"
 	"github.com/snapcore/snapd/bootloader/assets"
 	"github.com/snapcore/snapd/bootloader/bootloadertest"
+	"github.com/snapcore/snapd/dirs"
 	"github.com/snapcore/snapd/snap"
 	"github.com/snapcore/snapd/testutil"
 )
@@ -56,6 +57,8 @@ func (s *baseBootenvTestSuite) SetUpTest(c *C) {
 	s.BaseTest.SetUpTest(c)
 	s.AddCleanup(snap.MockSanitizePlugsSlots(func(snapInfo *snap.Info) {}))
 	s.rootdir = c.MkDir()
+	dirs.SetRootDir(s.rootdir)
+	s.AddCleanup(func() { dirs.SetRootDir("") })
 }
 
 type bootenvTestSuite struct {
@@ -114,7 +117,7 @@ func (s *bootenvTestSuite) TestInstallBootloaderConfigFromGadget(c *C) {
 			opts:       &bootloader.Options{Role: bootloader.RoleRecovery},
 		},
 		{name: "androidboot", gadgetFile: "androidboot.conf", sysFile: "/boot/androidboot/androidboot.env"},
-		{name: "lk", gadgetFile: "lk.conf", sysFile: "/boot/lk/snapbootsel.bin"},
+		{name: "lk", gadgetFile: "lk.conf", sysFile: "/boot/lk/snapbootsel.bin", opts: &bootloader.Options{PrepareImageTime: true}},
 	} {
 		mockGadgetDir := c.MkDir()
 		rootDir := c.MkDir()

bootloader/export_test.go

@@ -28,6 +28,8 @@ import (
 
 	"github.com/snapcore/snapd/bootloader/lkenv"
 	"github.com/snapcore/snapd/bootloader/ubootenv"
+	"github.com/snapcore/snapd/osutil"
+	"github.com/snapcore/snapd/osutil/disks"
 )
 
 // creates a new Androidboot bootloader object
@@ -72,45 +74,140 @@ func MockGrubFiles(c *C, rootdir string) {
 	c.Assert(err, IsNil)
 }
 
-func NewLk(rootdir string, opts *Options) Bootloader {
+func NewLk(rootdir string, opts *Options) ExtractedRecoveryKernelImageBootloader {
 	if opts == nil {
-		opts = &Options{}
+		opts = &Options{
+			Role: RoleSole,
+		}
 	}
-	return newLk(rootdir, opts)
+	return newLk(rootdir, opts).(ExtractedRecoveryKernelImageBootloader)
 }
 
-func LkConfigFile(b Bootloader) string {
+// LkConfigFile returns the primary lk bootloader environment file.
+func LkConfigFile(b Bootloader) (string, error) {
 	lk := b.(*lk)
-	return lk.envFile()
+	return lk.envBackstore(primaryStorage)
 }
 
 func UbootConfigFile(b Bootloader) string {
 	u := b.(*uboot)
 	return u.envFile()
 }
 
-func MockLkFiles(c *C, rootdir string, opts *Options) {
+func MockLkFiles(c *C, rootdir string, opts *Options) (restore func()) {
+	var cleanups []func()
 	if opts == nil {
-		opts = &Options{}
+		// default to v1, uc16/uc18 version for test simplicity
+		opts = &Options{
+			Role: RoleSole,
+		}
+	}
+
+	l := &lk{rootdir: rootdir}
+	l.processOpts(opts)
+
+	var version lkenv.Version
+	switch opts.Role {
+	case RoleSole:
+		version = lkenv.V1
+	case RoleRunMode:
+		version = lkenv.V2Run
+	case RoleRecovery:
+		version = lkenv.V2Recovery
 	}
-	l := &lk{rootdir: rootdir, inRuntimeMode: !opts.PrepareImageTime}
-	err := os.MkdirAll(l.dir(), 0755)
-	c.Assert(err, IsNil)
 
-	// first create empty env file
+	// setup some role specific things
+	if opts.Role == RoleRunMode || opts.Role == RoleRecovery {
+		// then we need to setup some additional files - namely the kernel
+		// command line and a mock disk for that
+		lkBootDisk := &disks.MockDiskMapping{
+			// mock the partition labels, since these structures won't have
+			// filesystems, but they will have partition labels
+			PartitionLabelToPartUUID: map[string]string{
+				"snapbootsel":        "snapbootsel-partuuid",
+				"snapbootselbak":     "snapbootselbak-partuuid",
+				"snaprecoverysel":    "snaprecoverysel-partuuid",
+				"snaprecoveryselbak": "snaprecoveryselbak-partuuid",
+				// for run mode kernel snaps
+				"boot_a": "boot-a-partuuid",
+				"boot_b": "boot-b-partuuid",
+				// for recovery system kernel snaps
+				"boot_ra": "boot-ra-partuuid",
+				"boot_rb": "boot-rb-partuuid",
+			},
+			DiskHasPartitions: true,
+			DevNum:            "lk-boot-disk-dev-num",
+		}
+
+		m := map[string]*disks.MockDiskMapping{
+			"lk-boot-disk": lkBootDisk,
+		}
+
+		// mock the disk
+		r := disks.MockDeviceNameDisksToPartitionMapping(m)
+		cleanups = append(cleanups, r)
+
+		// now mock the kernel command line
+		cmdLine := filepath.Join(c.MkDir(), "cmdline")
+		ioutil.WriteFile(cmdLine, []byte("snapd_lk_boot_disk=lk-boot-disk"), 0644)
+		r = osutil.MockProcCmdline(cmdLine)
+		cleanups = append(cleanups, r)
+	}
+
+	// next create empty env file
 	buf := make([]byte, 4096)
-	err = ioutil.WriteFile(l.envFile(), buf, 0660)
+	f, err := l.envBackstore(primaryStorage)
+	c.Assert(err, IsNil)
+
+	c.Assert(os.MkdirAll(filepath.Dir(f), 0755), IsNil)
+	err = ioutil.WriteFile(f, buf, 0660)
 	c.Assert(err, IsNil)
+
 	// now write env in it with correct crc
-	env := lkenv.NewEnv(l.envFile(), "", lkenv.V1)
-	env.InitializeBootPartitions("boot_a", "boot_b")
+	env := lkenv.NewEnv(f, "", version)
+	if version == lkenv.V2Recovery {
+		env.InitializeBootPartitions("boot_ra", "boot_rb")
+	} else {
+		env.InitializeBootPartitions("boot_a", "boot_b")
+	}
+
 	err = env.Save()
 	c.Assert(err, IsNil)
+
+	// also make the empty files for the boot_a and boot_b partitions
+	if opts.Role == RoleRunMode || opts.Role == RoleRecovery {
+		// for uc20 roles we need to mock the files in /dev/disk/by-partuuid
+		// and we also need to mock the snapbootselbak file (the snapbootsel
+		// was created above when we created envFile())
+		for _, label := range []string{"boot_a", "boot_b", "boot_ra", "boot_rb", "snapbootselbak"} {
+			disk, err := disks.DiskFromDeviceName("lk-boot-disk")
+			c.Assert(err, IsNil)
+			partUUID, err := disk.FindMatchingPartitionUUIDWithPartLabel(label)
+			c.Assert(err, IsNil)
+			bootFile := filepath.Join(rootdir, "/dev/disk/by-partuuid", partUUID)
+			c.Assert(os.MkdirAll(filepath.Dir(bootFile), 0755), IsNil)
+			c.Assert(ioutil.WriteFile(bootFile, nil, 0755), IsNil)
+		}
+	} else {
+		// for non-uc20 roles just mock the files in /dev/disk/by-partlabel
+		for _, partName := range []string{"boot_a", "boot_b"} {
+			mockPart := filepath.Join(rootdir, "/dev/disk/by-partlabel/", partName)
+			err := os.MkdirAll(filepath.Dir(mockPart), 0755)
+			c.Assert(err, IsNil)
+			err = ioutil.WriteFile(mockPart, nil, 0600)
+			c.Assert(err, IsNil)
+		}
+	}
+	return func() {
+		for _, r := range cleanups {
+			r()
+		}
+	}
 }
 
 func LkRuntimeMode(b Bootloader) bool {
 	lk := b.(*lk)
-	return lk.inRuntimeMode
+	return !lk.prepareImageTime
 }
 
 func MockAddBootloaderToFind(blConstructor func(string, *Options) Bootloader) (restore func()) {