Remove unused CimFS related code

CimFS is currently not supported with HyperV isolation. However, we still have code that
handles processing of UtilityVM layer during image import. After the layer refactoring
change we need to update this code as well. But since this code isn't being used anywhere
updating it doesn't make much sense. There are no tests for this either. This code is
removed for now and we can add it back later once the plan for running HyperV isolated
containers with CimFS is more solid.

Signed-off-by: Amit Barve <ambarve@microsoft.com>

internal/wclayer/cim/LayerWriter.go

@@ -6,16 +6,12 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"os"
 	"path/filepath"
-	"strconv"
 	"strings"
 
 	"github.com/Microsoft/go-winio"
-	"github.com/Microsoft/hcsshim/internal/log"
 	"github.com/Microsoft/hcsshim/internal/oc"
 	"github.com/Microsoft/hcsshim/internal/wclayer"
-	"github.com/Microsoft/hcsshim/osversion"
 	"github.com/Microsoft/hcsshim/pkg/cimfs"
 	"go.opencensus.io/trace"
 )
@@ -174,31 +170,8 @@ func (cw *CimLayerWriter) Close(ctx context.Context) (retErr error) {
 		}
 	}()
 
-	// Find out the osversion of this layer, both base & non-base layers can have UtilityVM layer.
+	// UVM based containers aren't supported with CimFS, don't process the UVM layer
 	processUtilityVM := false
-	if cw.hasUtilityVM {
-		uvmSoftwareHivePath := filepath.Join(cw.layerPath, wclayer.UtilityVMPath, wclayer.RegFilesPath, "SOFTWARE")
-		osvStr, err := getOsBuildNumberFromRegistry(uvmSoftwareHivePath)
-		if err != nil {
-			return fmt.Errorf("read os version string from UtilityVM SOFTWARE hive: %w", err)
-		}
-
-		osv, err := strconv.ParseUint(osvStr, 10, 16)
-		if err != nil {
-			return fmt.Errorf("parse os version string (%s): %w", osvStr, err)
-		}
-
-		// write this version to a file for future reference by the shim process
-		if err = wclayer.WriteLayerUvmBuildFile(cw.layerPath, uint16(osv)); err != nil {
-			return fmt.Errorf("write uvm build version: %w", err)
-		}
-
-		// CIMFS for hyperV isolated is only supported after 20348, processing UtilityVM layer on 2048
-		// & lower will cause failures since those images won't have CIMFS specific UVM files (mostly
-		// BCD entries required for CIMFS)
-		processUtilityVM = (osv > osversion.LTSC2022)
-		log.G(ctx).Debugf("import image os version %d, processing UtilityVM layer: %t\n", osv, processUtilityVM)
-	}
 
 	if len(cw.parentLayerPaths) == 0 {
 		if err := cw.processBaseLayer(ctx, processUtilityVM); err != nil {
@@ -261,22 +234,3 @@ func NewCimLayerWriter(ctx context.Context, layerPath, cimPath string, parentLay
 		stdFileWriter:    sfw,
 	}, nil
 }
-
-// DestroyCimLayer destroys a cim layer i.e it removes all the cimfs files for the given layer as well as
-// all of the other files that are stored in the layer directory (at path `layerPath`).
-// If this is not a cimfs layer (i.e a cim file for the given layer does not exist) then nothing is done.
-func DestroyCimLayer(ctx context.Context, layerPath string) error {
-	cimPath := GetCimPathFromLayer(layerPath)
-
-	// verify that such a cim exists first, sometimes containerd tries to call
-	// this with the root snapshot directory as the layer path. We don't want to
-	// destroy everything inside the snapshots directory.
-	if _, err := os.Stat(cimPath); err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		return err
-	}
-
-	return cimfs.DestroyCim(ctx, cimPath)
-}

internal/wclayer/cim/process.go

@@ -7,95 +7,19 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"syscall"
 	"time"
 
 	"github.com/Microsoft/go-winio"
-	"github.com/Microsoft/go-winio/vhd"
-	"github.com/Microsoft/hcsshim/computestorage"
-	"github.com/Microsoft/hcsshim/internal/memory"
-	"github.com/Microsoft/hcsshim/internal/security"
-	"github.com/Microsoft/hcsshim/internal/vhdx"
 	"github.com/Microsoft/hcsshim/internal/wclayer"
 	"golang.org/x/sys/windows"
 )
 
 const defaultVHDXBlockSizeInMB = 1
 
-// processUtilityVMLayer is similar to createContainerBaseLayerVHDs but along with the scratch creation it
-// also does some BCD modifications to allow the UVM to boot from the CIM. It expects that the UVM BCD file is
-// present at layerPath/`wclayer.BcdFilePath` and a UVM SYSTEM hive is present at
-// layerPath/UtilityVM/`wclayer.RegFilesPath`/SYSTEM. The scratch VHDs are created under the `layerPath`
-// directory.
+// processUtilityVMLayer will handle processing of UVM specific files when we start
+// supporting UVM based containers with CimFS in the future.
 func processUtilityVMLayer(ctx context.Context, layerPath string) error {
-	// func createUtilityVMLayerVHDs(ctx context.Context, layerPath string) error {
-	baseVhdPath := filepath.Join(layerPath, wclayer.UtilityVMPath, wclayer.UtilityVMBaseVhd)
-	diffVhdPath := filepath.Join(layerPath, wclayer.UtilityVMPath, wclayer.UtilityVMScratchVhd)
-	defaultVhdSize := uint64(10)
-
-	// Just create the vhdx for utilityVM layer, no need to format it.
-	createParams := &vhd.CreateVirtualDiskParameters{
-		Version: 2,
-		Version2: vhd.CreateVersion2{
-			MaximumSize:      defaultVhdSize * memory.GiB,
-			BlockSizeInBytes: defaultVHDXBlockSizeInMB * memory.MiB,
-		},
-	}
-
-	handle, err := vhd.CreateVirtualDisk(baseVhdPath, vhd.VirtualDiskAccessNone, vhd.CreateVirtualDiskFlagNone, createParams)
-	if err != nil {
-		return fmt.Errorf("failed to create vhdx: %w", err)
-	}
-
-	defer func() {
-		if err != nil {
-			os.RemoveAll(baseVhdPath)
-			os.RemoveAll(diffVhdPath)
-		}
-	}()
-
-	err = computestorage.FormatWritableLayerVhd(ctx, windows.Handle(handle))
-	closeErr := syscall.CloseHandle(handle)
-	if err != nil {
-		return err
-	} else if closeErr != nil {
-		return fmt.Errorf("failed to close vhdx handle: %w", closeErr)
-	}
-
-	partitionInfo, err := vhdx.GetScratchVhdPartitionInfo(ctx, baseVhdPath)
-	if err != nil {
-		return fmt.Errorf("failed to get base vhd layout info: %w", err)
-	}
-	// relativeCimPath needs to be the cim path relative to the snapshots directory. The snapshots
-	// directory is shared inside the UVM over VSMB, so during the UVM boot this relative path will be
-	// used to find the cim file under that VSMB share.
-	relativeCimPath := filepath.Join(filepath.Base(GetCimDirFromLayer(layerPath)), GetCimNameFromLayer(layerPath))
-	bcdPath := filepath.Join(layerPath, bcdFilePath)
-	if err = updateBcdStoreForBoot(bcdPath, relativeCimPath, partitionInfo.DiskID, partitionInfo.PartitionID); err != nil {
-		return fmt.Errorf("failed to update BCD: %w", err)
-	}
-
-	if err := enableCimBoot(filepath.Join(layerPath, wclayer.UtilityVMPath, wclayer.RegFilesPath, "SYSTEM")); err != nil {
-		return fmt.Errorf("failed to setup cim image for uvm boot: %w", err)
-	}
-
-	// Note: diff vhd creation and granting of vm group access must be done AFTER
-	// getting the partition info of the base VHD. Otherwise it causes the vhd parent
-	// chain to get corrupted.
-	// TODO(ambarve): figure out why this happens so that bcd update can be moved to a separate function
-
-	// Create the differencing disk that will be what's copied for the final rw layer
-	// for a container.
-	if err = vhd.CreateDiffVhd(diffVhdPath, baseVhdPath, defaultVHDXBlockSizeInMB); err != nil {
-		return fmt.Errorf("failed to create differencing disk: %w", err)
-	}
-
-	if err := security.GrantVmGroupAccess(baseVhdPath); err != nil {
-		return fmt.Errorf("failed to grant vm group access to %s: %w", baseVhdPath, err)
-	}
-	if err := security.GrantVmGroupAccess(diffVhdPath); err != nil {
-		return fmt.Errorf("failed to grant vm group access to %s: %w", diffVhdPath, err)
-	}
+	//
 	return nil
 }