refactor common constants into vmutils package

Signed-off-by: Harsh Rawat <harshrawat@microsoft.com>

Author: rawahars

internal/devices/assigned_devices.go

@@ -12,6 +12,7 @@ import (
 	"github.com/Microsoft/hcsshim/internal/cmd"
 	"github.com/Microsoft/hcsshim/internal/log"
 	"github.com/Microsoft/hcsshim/internal/uvm"
+	"github.com/Microsoft/hcsshim/internal/vm/vmutils"
 	"github.com/pkg/errors"
 )
 
@@ -40,7 +41,7 @@ func AddDevice(ctx context.Context, vm *uvm.UtilityVM, idType, deviceID string,
 		}
 	}()
 
-	if uvm.IsValidDeviceType(idType) {
+	if vmutils.IsValidDeviceType(idType) {
 		vpci, err = vm.AssignDevice(ctx, deviceID, index, "")
 		if err != nil {
 			return vpci, nil, errors.Wrapf(err, "failed to assign device %s of type %s to pod %s", deviceID, idType, vm.ID())

internal/hcsoci/devices.go

@@ -18,6 +18,7 @@ import (
 	"github.com/Microsoft/hcsshim/internal/oci"
 	"github.com/Microsoft/hcsshim/internal/resources"
 	"github.com/Microsoft/hcsshim/internal/uvm"
+	"github.com/Microsoft/hcsshim/internal/vm/vmutils"
 	"github.com/Microsoft/hcsshim/osversion"
 	"github.com/Microsoft/hcsshim/pkg/annotations"
 )
@@ -174,7 +175,7 @@ func handleAssignedDevicesLCOW(
 
 	// assign device into UVM and create corresponding spec windows devices
 	for _, d := range specDevs {
-		if !uvm.IsValidDeviceType(d.IDType) {
+		if !vmutils.IsValidDeviceType(d.IDType) {
 			return resultDevs, closers, errors.Errorf("specified device %s has unsupported type %s", d.ID, d.IDType)
 		}
 

internal/oci/uvm.go

@@ -10,6 +10,7 @@ import (
 	"strconv"
 
 	runhcsopts "github.com/Microsoft/hcsshim/cmd/containerd-shim-runhcs-v1/options"
+	"github.com/Microsoft/hcsshim/internal/vm/vmutils"
 	"github.com/Microsoft/hcsshim/pkg/annotations"
 	"github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/sirupsen/logrus"
@@ -156,7 +157,7 @@ func handleAnnotationBootFilesPath(ctx context.Context, a map[string]string, lop
 func handleAnnotationKernelDirectBoot(ctx context.Context, a map[string]string, lopts *uvm.OptionsLCOW) {
 	lopts.KernelDirect = ParseAnnotationsBool(ctx, a, annotations.KernelDirectBoot, lopts.KernelDirect)
 	if !lopts.KernelDirect {
-		lopts.KernelFile = uvm.KernelFile
+		lopts.KernelFile = vmutils.KernelFile
 	}
 }
 
@@ -166,9 +167,9 @@ func handleAnnotationPreferredRootFSType(ctx context.Context, a map[string]strin
 	lopts.PreferredRootFSType = parseAnnotationsPreferredRootFSType(ctx, a, annotations.PreferredRootFSType, lopts.PreferredRootFSType)
 	switch lopts.PreferredRootFSType {
 	case uvm.PreferredRootFSTypeInitRd:
-		lopts.RootFSFile = uvm.InitrdFile
+		lopts.RootFSFile = vmutils.InitrdFile
 	case uvm.PreferredRootFSTypeVHD:
-		lopts.RootFSFile = uvm.VhdFile
+		lopts.RootFSFile = vmutils.VhdFile
 	}
 }
 
@@ -206,7 +207,7 @@ func handleLCOWSecurityPolicy(ctx context.Context, a map[string]string, lopts *u
 		// VPMem not supported by the enlightened kernel for SNP so set count to zero.
 		lopts.VPMemDeviceCount = 0
 		// set the default GuestState filename.
-		lopts.GuestStateFilePath = uvm.GuestStateFile
+		lopts.GuestStateFilePath = vmutils.DefaultGuestStateFile
 		lopts.KernelBootOptions = ""
 		lopts.AllowOvercommit = false
 		lopts.SecurityPolicyEnabled = true
@@ -219,7 +220,7 @@ func handleLCOWSecurityPolicy(ctx context.Context, a map[string]string, lopts *u
 		// The default behavior is to use kernel.vmgs and a rootfs-verity.vhd file with Merkle tree appended to ext4 filesystem.
 		lopts.PreferredRootFSType = uvm.PreferredRootFSTypeNA
 		lopts.RootFSFile = ""
-		lopts.DmVerityRootFsVhd = uvm.DefaultDmVerityRootfsVhd
+		lopts.DmVerityRootFsVhd = vmutils.DefaultDmVerityRootfsVhd
 		lopts.DmVerityMode = true
 	}
 
@@ -286,7 +287,7 @@ func parseDevices(ctx context.Context, specWindows *specs.Windows) []uvm.VPCIDev
 	extraDevices := []uvm.VPCIDeviceID{}
 	for _, d := range specWindows.Devices {
 		pciID, index := devices.GetDeviceInfoFromPath(d.ID)
-		if uvm.IsValidDeviceType(d.IDType) {
+		if vmutils.IsValidDeviceType(d.IDType) {
 			key := uvm.NewVPCIDeviceID(pciID, index)
 			extraDevices = append(extraDevices, key)
 		} else {

internal/tools/uvmboot/lcow.go

@@ -197,10 +197,10 @@ func createLCOWOptions(ctx context.Context, c *cli.Context, id string) (*uvm.Opt
 	}
 	if c.IsSet(kernelFileArgName) {
 		switch strings.ToLower(c.String(kernelFileArgName)) {
-		case uvm.KernelFile:
-			options.KernelFile = uvm.KernelFile
-		case uvm.UncompressedKernelFile:
-			options.KernelFile = uvm.UncompressedKernelFile
+		case vmutils.KernelFile:
+			options.KernelFile = vmutils.KernelFile
+		case vmutils.UncompressedKernelFile:
+			options.KernelFile = vmutils.UncompressedKernelFile
 		default:
 			return nil, unrecognizedError(c.String(kernelFileArgName), kernelFileArgName)
 		}
@@ -213,10 +213,10 @@ func createLCOWOptions(ctx context.Context, c *cli.Context, id string) (*uvm.Opt
 	if c.IsSet(rootFSTypeArgName) {
 		switch strings.ToLower(c.String(rootFSTypeArgName)) {
 		case "initrd":
-			options.RootFSFile = uvm.InitrdFile
+			options.RootFSFile = vmutils.InitrdFile
 			options.PreferredRootFSType = uvm.PreferredRootFSTypeInitRd
 		case "vhd":
-			options.RootFSFile = uvm.VhdFile
+			options.RootFSFile = vmutils.VhdFile
 			options.PreferredRootFSType = uvm.PreferredRootFSTypeVHD
 		case "none":
 			options.RootFSFile = ""
@@ -275,7 +275,7 @@ func createLCOWOptions(ctx context.Context, c *cli.Context, id string) (*uvm.Opt
 		options.SecurityPolicyEnforcer = c.String(securityPolicyEnforcerArgName)
 	}
 	if c.IsSet(securityHardwareFlag) {
-		options.GuestStateFilePath = uvm.GuestStateFile
+		options.GuestStateFilePath = vmutils.DefaultGuestStateFile
 		options.SecurityPolicyEnabled = true
 		options.AllowOvercommit = false
 	}

internal/uvm/constants.go

@@ -5,24 +5,9 @@ package uvm
 import (
 	"errors"
 
-	"github.com/Microsoft/hcsshim/internal/memory"
 	"github.com/Microsoft/hcsshim/internal/protocol/guestrequest"
 )
 
-const (
-	// MaxVPMEMCount is the maximum number of VPMem devices that may be added to an LCOW
-	// utility VM
-	MaxVPMEMCount = 128
-
-	// DefaultVPMEMCount is the default number of VPMem devices that may be added to an LCOW
-	// utility VM if the create request doesn't specify how many.
-	DefaultVPMEMCount = 64
-
-	// DefaultVPMemSizeBytes is the default size of a VPMem device if the create request
-	// doesn't specify.
-	DefaultVPMemSizeBytes = 4 * memory.GiB // 4GB
-)
-
 var (
 	errNotSupported = errors.New("not supported")
 	errBadUVMOpts   = errors.New("UVM options incorrect")

internal/uvm/cpugroups.go

@@ -10,11 +10,8 @@ import (
 	"github.com/Microsoft/hcsshim/internal/cpugroup"
 	"github.com/Microsoft/hcsshim/internal/hcs/resourcepaths"
 	hcsschema "github.com/Microsoft/hcsshim/internal/hcs/schema2"
-	"github.com/Microsoft/hcsshim/osversion"
 )
 
-var errCPUGroupCreateNotSupported = fmt.Errorf("cpu group assignment on create requires a build of %d or higher", osversion.V21H1)
-
 // ReleaseCPUGroup unsets the cpugroup from the VM
 func (uvm *UtilityVM) ReleaseCPUGroup(ctx context.Context) error {
 	if err := uvm.unsetCPUGroup(ctx); err != nil {

internal/uvm/create.go

@@ -169,8 +169,8 @@ func verifyOptions(_ context.Context, options interface{}) error {
 		if opts.SCSIControllerCount > MaxSCSIControllers {
 			return fmt.Errorf("SCSI controller count can't be more than %d", MaxSCSIControllers)
 		}
-		if opts.VPMemDeviceCount > MaxVPMEMCount {
-			return fmt.Errorf("VPMem device count cannot be greater than %d", MaxVPMEMCount)
+		if opts.VPMemDeviceCount > vmutils.MaxVPMEMCount {
+			return fmt.Errorf("VPMem device count cannot be greater than %d", vmutils.MaxVPMEMCount)
 		}
 		if opts.VPMemDeviceCount > 0 {
 			if opts.VPMemSizeBytes%4096 != 0 {

internal/uvm/create_lcow.go

@@ -60,34 +60,6 @@ const (
 	PreferredRootFSTypeInitRd PreferredRootFSType = iota
 	PreferredRootFSTypeVHD
 	PreferredRootFSTypeNA
-
-	entropyVsockPort  = 1
-	linuxLogVsockPort = 109
-)
-
-const (
-	// InitrdFile is the default file name for an initrd.img used to boot LCOW.
-	InitrdFile = "initrd.img"
-	// VhdFile is the default file name for a rootfs.vhd used to boot LCOW.
-	VhdFile = "rootfs.vhd"
-	// DefaultDmVerityRootfsVhd is the default file name for a dmverity_rootfs.vhd,
-	// which is mounted by the GuestStateFile during boot and used as the root file
-	// system when booting in the SNP case. Similar to layer VHDs, the Merkle tree
-	// is appended after ext4 filesystem ends.
-	DefaultDmVerityRootfsVhd = "rootfs.vhd"
-	// KernelFile is the default file name for a kernel used to boot LCOW.
-	KernelFile = "kernel"
-	// UncompressedKernelFile is the default file name for an uncompressed
-	// kernel used to boot LCOW with KernelDirect.
-	UncompressedKernelFile = "vmlinux"
-	// GuestStateFile is the default file name for a vmgs (VM Guest State) file
-	// which contains the kernel and kernel command which mounts DmVerityVhdFile
-	// when booting in the SNP case.
-	GuestStateFile = "kernel.vmgs"
-	// UVMReferenceInfoFile is the default file name for a COSE_Sign1
-	// reference UVM info, which can be made available to workload containers
-	// and can be used for validation purposes.
-	UVMReferenceInfoFile = "reference_info.cose"
 )
 
 type ConfidentialLCOWOptions struct {
@@ -143,17 +115,17 @@ func NewDefaultOptionsLCOW(id, owner string) *OptionsLCOW {
 	kernelDirectSupported := osversion.Build() >= 18286
 	opts := &OptionsLCOW{
 		Options:                 newDefaultOptions(id, owner),
-		KernelFile:              KernelFile,
+		KernelFile:              vmutils.KernelFile,
 		KernelDirect:            kernelDirectSupported,
-		RootFSFile:              InitrdFile,
+		RootFSFile:              vmutils.InitrdFile,
 		KernelBootOptions:       "",
 		UseGuestConnection:      true,
 		ExecCommandLine:         fmt.Sprintf("/bin/gcs -v4 -log-format json -loglevel %s", logrus.StandardLogger().Level.String()),
 		ForwardStdout:           false,
 		ForwardStderr:           true,
 		OutputHandlerCreator:    vmutils.ParseGCSLogrus,
-		VPMemDeviceCount:        DefaultVPMEMCount,
-		VPMemSizeBytes:          DefaultVPMemSizeBytes,
+		VPMemDeviceCount:        vmutils.DefaultVPMEMCount,
+		VPMemSizeBytes:          vmutils.DefaultVPMemSizeBytes,
 		VPMemNoMultiMapping:     osversion.Get().Build < osversion.V19H1,
 		PreferredRootFSType:     PreferredRootFSTypeInitRd,
 		EnableColdDiscardHint:   false,
@@ -163,7 +135,7 @@ func NewDefaultOptionsLCOW(id, owner string) *OptionsLCOW {
 		ConfidentialLCOWOptions: &ConfidentialLCOWOptions{
 			ConfidentialCommonOptions: &ConfidentialCommonOptions{
 				SecurityPolicyEnabled: false,
-				UVMReferenceInfoFile:  UVMReferenceInfoFile,
+				UVMReferenceInfoFile:  vmutils.DefaultUVMReferenceInfoFile,
 			},
 		},
 	}
@@ -196,29 +168,29 @@ func (opts *OptionsLCOW) UpdateBootFilesPath(ctx context.Context, path string) {
 
 	opts.BootFilesPath = path
 
-	if _, err := os.Stat(filepath.Join(opts.BootFilesPath, VhdFile)); err == nil {
+	if _, err := os.Stat(filepath.Join(opts.BootFilesPath, vmutils.VhdFile)); err == nil {
 		// We have a rootfs.vhd in the boot files path. Use it over an initrd.img
-		opts.RootFSFile = VhdFile
+		opts.RootFSFile = vmutils.VhdFile
 		opts.PreferredRootFSType = PreferredRootFSTypeVHD
 
 		log.G(ctx).WithFields(logrus.Fields{
 			logfields.UVMID: opts.ID,
-			VhdFile:         filepath.Join(opts.BootFilesPath, VhdFile),
-		}).Debug("updated LCOW root filesystem to " + VhdFile)
+			vmutils.VhdFile: filepath.Join(opts.BootFilesPath, vmutils.VhdFile),
+		}).Debug("updated LCOW root filesystem to " + vmutils.VhdFile)
 	}
 
 	if opts.KernelDirect {
 		// KernelDirect supports uncompressed kernel if the kernel is present.
 		// Default to uncompressed if on box. NOTE: If `kernel` is already
 		// uncompressed and simply named 'kernel' it will still be used
 		// uncompressed automatically.
-		if _, err := os.Stat(filepath.Join(opts.BootFilesPath, UncompressedKernelFile)); err == nil {
-			opts.KernelFile = UncompressedKernelFile
+		if _, err := os.Stat(filepath.Join(opts.BootFilesPath, vmutils.UncompressedKernelFile)); err == nil {
+			opts.KernelFile = vmutils.UncompressedKernelFile
 
 			log.G(ctx).WithFields(logrus.Fields{
-				logfields.UVMID:        opts.ID,
-				UncompressedKernelFile: filepath.Join(opts.BootFilesPath, UncompressedKernelFile),
-			}).Debug("updated LCOW kernel file to " + UncompressedKernelFile)
+				logfields.UVMID:                opts.ID,
+				vmutils.UncompressedKernelFile: filepath.Join(opts.BootFilesPath, vmutils.UncompressedKernelFile),
+			}).Debug("updated LCOW kernel file to " + vmutils.UncompressedKernelFile)
 		}
 	}
 }
@@ -242,7 +214,7 @@ func fetchProcessor(ctx context.Context, opts *OptionsLCOW, uvm *UtilityVM) (*hc
 	// We can set a cpu group for the VM at creation time in recent builds.
 	if opts.CPUGroupID != "" {
 		if osversion.Build() < osversion.V21H1 {
-			return nil, errCPUGroupCreateNotSupported
+			return nil, vmutils.ErrCPUGroupCreateNotSupported
 		}
 		processor.CpuGroup = &hcsschema.CpuGroup{Id: opts.CPUGroupID}
 	}
@@ -363,7 +335,7 @@ func makeLCOWVMGSDoc(ctx context.Context, opts *OptionsLCOW, uvm *UtilityVM) (_
 		}
 	}()
 
-	dmVerityRootFsFullPath := filepath.Join(opts.BundleDirectory, DefaultDmVerityRootfsVhd)
+	dmVerityRootFsFullPath := filepath.Join(opts.BundleDirectory, vmutils.DefaultDmVerityRootfsVhd)
 	if err := copyfile.CopyFile(ctx, dmVerityRootfsTemplatePath, dmVerityRootFsFullPath, true); err != nil {
 		return nil, fmt.Errorf("failed to copy DM Verity rootfs template file: %w", err)
 	}
@@ -425,7 +397,7 @@ func makeLCOWVMGSDoc(ctx context.Context, opts *OptionsLCOW, uvm *UtilityVM) (_
 	//		entropyVsockPort - 1 is the entropy port,
 	//		linuxLogVsockPort - 109 used by vsockexec to log stdout/stderr logging,
 	//		0x40000000 + 1 (LinuxGcsVsockPort + 1) is the bridge (see guestconnectiuon.go)
-	hvSockets := []uint32{entropyVsockPort, linuxLogVsockPort, prot.LinuxGcsVsockPort, prot.LinuxGcsVsockPort + 1}
+	hvSockets := []uint32{vmutils.LinuxEntropyVsockPort, vmutils.LinuxLogVsockPort, prot.LinuxGcsVsockPort, prot.LinuxGcsVsockPort + 1}
 	hvSockets = append(hvSockets, opts.ExtraVSockPorts...)
 	for _, whichSocket := range hvSockets {
 		key := winio.VsockServiceID(whichSocket).String()
@@ -836,18 +808,18 @@ func makeLCOWDoc(ctx context.Context, opts *OptionsLCOW, uvm *UtilityVM) (_ *hcs
 	}
 
 	// Inject initial entropy over vsock during init launch.
-	entropyArgs := fmt.Sprintf("-e %d", entropyVsockPort)
+	entropyArgs := fmt.Sprintf("-e %d", vmutils.LinuxEntropyVsockPort)
 
 	// With default options, run GCS with stderr pointing to the vsock port
 	// created below in order to forward guest logs to logrus.
 	execCmdArgs := "/bin/vsockexec"
 
 	if opts.ForwardStdout {
-		execCmdArgs += fmt.Sprintf(" -o %d", linuxLogVsockPort)
+		execCmdArgs += fmt.Sprintf(" -o %d", vmutils.LinuxLogVsockPort)
 	}
 
 	if opts.ForwardStderr {
-		execCmdArgs += fmt.Sprintf(" -e %d", linuxLogVsockPort)
+		execCmdArgs += fmt.Sprintf(" -e %d", vmutils.LinuxLogVsockPort)
 	}
 
 	if opts.DisableTimeSyncService {
@@ -994,7 +966,7 @@ func CreateLCOW(ctx context.Context, opts *OptionsLCOW) (_ *UtilityVM, err error
 	}
 
 	// Create a socket to inject entropy during boot.
-	uvm.entropyListener, err = uvm.listenVsock(entropyVsockPort)
+	uvm.entropyListener, err = uvm.listenVsock(vmutils.LinuxEntropyVsockPort)
 	if err != nil {
 		return nil, err
 	}
@@ -1004,7 +976,7 @@ func CreateLCOW(ctx context.Context, opts *OptionsLCOW) (_ *UtilityVM, err error
 	if opts.ForwardStdout || opts.ForwardStderr {
 		uvm.outputHandler = opts.OutputHandlerCreator(opts.ID)
 		uvm.outputProcessingDone = make(chan struct{})
-		uvm.outputListener, err = uvm.listenVsock(linuxLogVsockPort)
+		uvm.outputListener, err = uvm.listenVsock(vmutils.LinuxLogVsockPort)
 		if err != nil {
 			return nil, err
 		}

internal/uvm/create_wcow.go

@@ -238,7 +238,7 @@ func prepareCommonConfigDoc(ctx context.Context, uvm *UtilityVM, opts *OptionsWC
 	// We can set a cpu group for the VM at creation time in recent builds.
 	if opts.CPUGroupID != "" {
 		if osversion.Build() < osversion.V21H1 {
-			return nil, errCPUGroupCreateNotSupported
+			return nil, vmutils.ErrCPUGroupCreateNotSupported
 		}
 		processor.CpuGroup = &hcsschema.CpuGroup{Id: opts.CPUGroupID}
 	}

internal/uvm/types.go

@@ -83,8 +83,8 @@ type UtilityVM struct {
 	vpmemMaxCount           uint32 // The max number of VPMem devices.
 	vpmemMaxSizeBytes       uint64 // The max size of the layer in bytes per vPMem device.
 	vpmemMultiMapping       bool   // Enable mapping multiple VHDs onto a single VPMem device
-	vpmemDevicesDefault     [MaxVPMEMCount]*vPMemInfoDefault
-	vpmemDevicesMultiMapped [MaxVPMEMCount]*vPMemInfoMulti
+	vpmemDevicesDefault     [vmutils.MaxVPMEMCount]*vPMemInfoDefault
+	vpmemDevicesMultiMapped [vmutils.MaxVPMEMCount]*vPMemInfoMulti
 
 	// SCSI devices that are mapped into a Windows or Linux utility VM
 	SCSIManager         *scsi.Manager