Allow different types of boot configurations for WCOW UVM

Currently WCOW UVM only support booting with VmbFS and legacy layers. However, we are
adding support for booting the UVM with BlockCIM layers. This commit updates the
WCOWBootFiles struct to support different boot configurations.

Signed-off-by: Amit Barve <[email protected]>

Author: ambarve

internal/layers/wcow_parse.go

@@ -263,8 +263,11 @@ func GetWCOWUVMBootFilesFromLayers(ctx context.Context, rootfs []*types.Mount, l
 		}
 	}
 	return &uvm.WCOWBootFiles{
-		OSFilesPath:           filepath.Join(uvmFolder, `UtilityVM\Files`),
-		OSRelativeBootDirPath: `\EFI\Microsoft\Boot`,
-		ScratchVHDPath:        scratchVHDPath,
+		BootType: uvm.VmbFSBoot,
+		VmbFSFiles: &uvm.VmbFSBootFiles{
+			OSFilesPath:           filepath.Join(uvmFolder, `UtilityVM\Files`),
+			OSRelativeBootDirPath: `\EFI\Microsoft\Boot`,
+			ScratchVHDPath:        scratchVHDPath,
+		},
 	}, nil
 }

internal/uvm/create.go

@@ -124,6 +124,25 @@ type Options struct {
 	NumaMemoryBlocksCounts []uint64
 }
 
+func verifyWCOWBootFiles(bootFiles *WCOWBootFiles) error {
+	if bootFiles.BootType == VmbFSBoot {
+		if bootFiles.VmbFSFiles == nil {
+			return fmt.Errorf("VmbFS boot files is empty")
+		} else if bootFiles.BlockCIMFiles != nil {
+			return fmt.Errorf("confidential boot files should be empty")
+		}
+	} else if bootFiles.BootType == BlockCIMBoot {
+		if bootFiles.BlockCIMFiles == nil {
+			return fmt.Errorf("Confidential boot files is empty")
+		} else if bootFiles.VmbFSFiles != nil {
+			return fmt.Errorf("VmbFS boot files should be empty")
+		}
+	} else {
+		return fmt.Errorf("invalid boot type specified")
+	}
+	return nil
+}
+
 // Verifies that the final UVM options are correct and supported.
 func verifyOptions(_ context.Context, options interface{}) error {
 	switch opts := options.(type) {
@@ -156,6 +175,9 @@ func verifyOptions(_ context.Context, options interface{}) error {
 		if opts.SCSIControllerCount != 1 {
 			return errors.New("exactly 1 SCSI controller is required for WCOW")
 		}
+		if err := verifyWCOWBootFiles(opts.BootFiles); err != nil {
+			return err
+		}
 	}
 	return nil
 }

internal/uvm/create_wcow.go

@@ -86,14 +86,17 @@ func prepareConfigDoc(ctx context.Context, uvm *UtilityVM, opts *OptionsWCOW) (*
 	memorySizeInMB := uvm.normalizeMemorySize(ctx, opts.MemorySizeInMB)
 
 	// UVM rootfs share is readonly.
+	if opts.BootFiles.BootType != VmbFSBoot {
+		return nil, fmt.Errorf("expected VmbFS boot type, found: %d", opts.BootFiles.BootType)
+	}
 	vsmbOpts := uvm.DefaultVSMBOptions(true)
 	vsmbOpts.TakeBackupPrivilege = true
 	virtualSMB := &hcsschema.VirtualSmb{
 		DirectFileMappingInMB: 1024, // Sensible default, but could be a tuning parameter somewhere
 		Shares: []hcsschema.VirtualSmbShare{
 			{
 				Name:    "os",
-				Path:    opts.BootFiles.OSFilesPath,
+				Path:    opts.BootFiles.VmbFSFiles.OSFilesPath,
 				Options: vsmbOpts,
 			},
 		},
@@ -192,7 +195,7 @@ func prepareConfigDoc(ctx context.Context, uvm *UtilityVM, opts *OptionsWCOW) (*
 			Chipset: &hcsschema.Chipset{
 				Uefi: &hcsschema.Uefi{
 					BootThis: &hcsschema.UefiBootEntry{
-						DevicePath: filepath.Join(opts.BootFiles.OSRelativeBootDirPath, "bootmgfw.efi"),
+						DevicePath: filepath.Join(opts.BootFiles.VmbFSFiles.OSRelativeBootDirPath, "bootmgfw.efi"),
 						DeviceType: "VmbFs",
 					},
 				},
@@ -313,7 +316,7 @@ func CreateWCOW(ctx context.Context, opts *OptionsWCOW) (_ *UtilityVM, err error
 		return nil, fmt.Errorf("error in preparing config doc: %w", err)
 	}
 
-	if err := wclayer.GrantVmAccess(ctx, uvm.id, opts.BootFiles.ScratchVHDPath); err != nil {
+	if err := wclayer.GrantVmAccess(ctx, uvm.id, opts.BootFiles.VmbFSFiles.ScratchVHDPath); err != nil {
 		return nil, errors.Wrap(err, "failed to grant vm access to scratch")
 	}
 
@@ -326,7 +329,7 @@ func CreateWCOW(ctx context.Context, opts *OptionsWCOW) (_ *UtilityVM, err error
 
 	doc.VirtualMachine.Devices.Scsi[guestrequest.ScsiControllerGuids[0]].Attachments["0"] = hcsschema.Attachment{
 
-		Path:  opts.BootFiles.ScratchVHDPath,
+		Path:  opts.BootFiles.VmbFSFiles.ScratchVHDPath,
 		Type_: "VirtualDisk",
 	}
 

internal/uvm/types.go

@@ -153,7 +153,28 @@ type OutputHandler func(io.Reader)
 
 type OutputHandlerCreator func(*Options) OutputHandler
 
+type WCOWBootFilesType uint8
+
+const (
+	VmbFSBoot WCOWBootFilesType = iota
+	BlockCIMBoot
+)
+
+// WCOWBootFiles provides the files paths (and other data) required to configure boot of
+// an UVM.  This struct (more like a union) maintains a type variable to specify what kind
+// of boot we are doing and then the struct applicable to that boot type will have the
+// necessary data. All other fields should be null.  (Maybe we can make this into an
+// interface with a method that configures boot given the UVM HCS doc, but configuring
+// boot requires access to the uvm struct itself to update the used SCSI mounts etc. and
+// then the interface gets ugly...)
 type WCOWBootFiles struct {
+	BootType      WCOWBootFilesType
+	VmbFSFiles    *VmbFSBootFiles
+	BlockCIMFiles *BlockCIMBootFiles
+}
+
+// files required to boot an UVM with layer files stored on NTFS in legacy (WCIFS) format.
+type VmbFSBootFiles struct {
 	// Path to the directory that contains the OS files.
 	OSFilesPath string
 	// Path of the boot directory relative to the `OSFilesPath`. This boot directory MUST
@@ -162,3 +183,13 @@ type WCOWBootFiles struct {
 	// Path for the scratch VHD of thef UVM
 	ScratchVHDPath string
 }
+
+// files required to boot an UVM with the layer files stored in a block CIM.
+type BlockCIMBootFiles struct {
+	// Path to the VHD that has a block CIM (which contains the OS files) on it.
+	BootCIMVHDPath string
+	// VHD that contains the EFI partition
+	EFIVHDPath string
+	// A non formatted scratch VHD
+	ScratchVHDPath string
+}