runtime: support to create VirtualVolume rootfs storages

1) Creating storage for all `io.katacontainers.volume=` messages in rootFs.Options,
and then aggregates all storages  into `containerStorages`.
2) Creating storage for other data volumes and push them into `volumeStorages`.

Signed-off-by: ChengyuZhu6 <chengyu.zhu@intel.com>

src/runtime/pkg/katautils/create.go

@@ -130,7 +130,7 @@ func CreateSandbox(ctx context.Context, vci vc.VC, ociSpec specs.Spec, runtimeCo
 	}
 
 	if !rootFs.Mounted && len(sandboxConfig.Containers) == 1 {
-		if rootFs.Source != "" {
+		if rootFs.Source != "" && !vc.HasOptionPrefix(rootFs.Options, vc.VirtualVolumePrefix) {
 			realPath, err := ResolvePath(rootFs.Source)
 			if err != nil {
 				return nil, vc.Process{}, err

src/runtime/virtcontainers/fs_share_linux.go

@@ -15,6 +15,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strings"
 	"sync"
 	"syscall"
 
@@ -26,6 +27,7 @@ import (
 	"github.com/kata-containers/kata-containers/src/runtime/pkg/katautils/katatrace"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/agent/protocols/grpc"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/annotations"
+	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/types"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/utils"
 )
 
@@ -460,9 +462,55 @@ func (f *FilesystemShare) shareRootFilesystemWithNydus(ctx context.Context, c *C
 	}, nil
 }
 
+// handleVirtualVolume processes all `io.katacontainers.volume=` messages in rootFs.Options,
+// creating storage, and then aggregates all storages  into an array.
+func handleVirtualVolume(c *Container) ([]*grpc.Storage, string, error) {
+	var volumes []*grpc.Storage
+	var volumeType string
+
+	for _, o := range c.rootFs.Options {
+		if strings.HasPrefix(o, VirtualVolumePrefix) {
+			virtVolume, err := types.ParseKataVirtualVolume(strings.TrimPrefix(o, VirtualVolumePrefix))
+			if err != nil {
+				return nil, "", err
+			}
+
+			volumeType = virtVolume.VolumeType
+			var vol *grpc.Storage
+			vol, err = handleVirtualVolumeStorageObject(c, "", virtVolume)
+			if err != nil {
+				return nil, "", err
+			}
+
+			if vol != nil {
+				volumes = append(volumes, vol)
+			}
+		}
+	}
+
+	return volumes, volumeType, nil
+}
+
+func (f *FilesystemShare) shareRootFilesystemWithVirtualVolume(ctx context.Context, c *Container) (*SharedFile, error) {
+	guestPath := filepath.Join("/run/kata-containers/", c.id, c.rootfsSuffix)
+	rootFsStorages, _, err := handleVirtualVolume(c)
+	if err != nil {
+		return nil, err
+	}
+
+	return &SharedFile{
+		containerStorages: rootFsStorages,
+		guestPath:         guestPath,
+	}, nil
+}
+
 // func (c *Container) shareRootfs(ctx context.Context) (*grpc.Storage, string, error) {
 func (f *FilesystemShare) ShareRootFilesystem(ctx context.Context, c *Container) (*SharedFile, error) {
 
+	if HasOptionPrefix(c.rootFs.Options, VirtualVolumePrefix) {
+		return f.shareRootFilesystemWithVirtualVolume(ctx, c)
+	}
+
 	if c.rootFs.Type == NydusRootFSType {
 		return f.shareRootFilesystemWithNydus(ctx, c)
 	}

src/runtime/virtcontainers/kata_agent.go

@@ -83,41 +83,42 @@ const (
 type customRequestTimeoutKeyType struct{}
 
 var (
-	checkRequestTimeout           = 30 * time.Second
+	checkRequestTimeout              = 30 * time.Second
-	defaultRequestTimeout         = 60 * time.Second
+	defaultRequestTimeout            = 60 * time.Second
-	remoteRequestTimeout          = 300 * time.Second
+	remoteRequestTimeout             = 300 * time.Second
-	customRequestTimeoutKey       = customRequestTimeoutKeyType(struct{}{})
+	customRequestTimeoutKey          = customRequestTimeoutKeyType(struct{}{})
-	errorMissingOCISpec           = errors.New("Missing OCI specification")
+	errorMissingOCISpec              = errors.New("Missing OCI specification")
-	defaultKataHostSharedDir      = "/run/kata-containers/shared/sandboxes/"
+	defaultKataHostSharedDir         = "/run/kata-containers/shared/sandboxes/"
-	defaultKataGuestSharedDir     = "/run/kata-containers/shared/containers/"
+	defaultKataGuestSharedDir        = "/run/kata-containers/shared/containers/"
-	defaultKataGuestNydusRootDir  = "/run/kata-containers/shared/"
+	defaultKataGuestNydusRootDir     = "/run/kata-containers/shared/"
-	mountGuestTag                 = "kataShared"
+	defaultKataGuestVirtualVolumedir = "/run/kata-containers/virtual-volumes/"
-	defaultKataGuestSandboxDir    = "/run/kata-containers/sandbox/"
+	mountGuestTag                    = "kataShared"
-	type9pFs                      = "9p"
+	defaultKataGuestSandboxDir       = "/run/kata-containers/sandbox/"
-	typeVirtioFS                  = "virtiofs"
+	type9pFs                         = "9p"
-	typeOverlayFS                 = "overlay"
+	typeVirtioFS                     = "virtiofs"
-	kata9pDevType                 = "9p"
+	typeOverlayFS                    = "overlay"
-	kataMmioBlkDevType            = "mmioblk"
+	kata9pDevType                    = "9p"
-	kataBlkDevType                = "blk"
+	kataMmioBlkDevType               = "mmioblk"
-	kataBlkCCWDevType             = "blk-ccw"
+	kataBlkDevType                   = "blk"
-	kataSCSIDevType               = "scsi"
+	kataBlkCCWDevType                = "blk-ccw"
-	kataNvdimmDevType             = "nvdimm"
+	kataSCSIDevType                  = "scsi"
-	kataVirtioFSDevType           = "virtio-fs"
+	kataNvdimmDevType                = "nvdimm"
-	kataOverlayDevType            = "overlayfs"
+	kataVirtioFSDevType              = "virtio-fs"
-	kataWatchableBindDevType      = "watchable-bind"
+	kataOverlayDevType               = "overlayfs"
-	kataVfioPciDevType            = "vfio-pci"    // VFIO PCI device to used as VFIO in the container
+	kataWatchableBindDevType         = "watchable-bind"
-	kataVfioPciGuestKernelDevType = "vfio-pci-gk" // VFIO PCI device for consumption by the guest kernel
+	kataVfioPciDevType               = "vfio-pci"    // VFIO PCI device to used as VFIO in the container
-	kataVfioApDevType             = "vfio-ap"
+	kataVfioPciGuestKernelDevType    = "vfio-pci-gk" // VFIO PCI device for consumption by the guest kernel
-	sharedDir9pOptions            = []string{"trans=virtio,version=9p2000.L,cache=mmap", "nodev"}
+	kataVfioApDevType                = "vfio-ap"
-	sharedDirVirtioFSOptions      = []string{}
+	sharedDir9pOptions               = []string{"trans=virtio,version=9p2000.L,cache=mmap", "nodev"}
-	sharedDirVirtioFSDaxOptions   = "dax"
+	sharedDirVirtioFSOptions         = []string{}
-	shmDir                        = "shm"
+	sharedDirVirtioFSDaxOptions      = "dax"
-	kataEphemeralDevType          = "ephemeral"
+	shmDir                           = "shm"
-	defaultEphemeralPath          = filepath.Join(defaultKataGuestSandboxDir, kataEphemeralDevType)
+	kataEphemeralDevType             = "ephemeral"
-	grpcMaxDataSize               = int64(1024 * 1024)
+	defaultEphemeralPath             = filepath.Join(defaultKataGuestSandboxDir, kataEphemeralDevType)
-	localDirOptions               = []string{"mode=0777"}
+	grpcMaxDataSize                  = int64(1024 * 1024)
-	maxHostnameLen                = 64
+	localDirOptions                  = []string{"mode=0777"}
-	GuestDNSFile                  = "/etc/resolv.conf"
+	maxHostnameLen                   = 64
+	GuestDNSFile                     = "/etc/resolv.conf"
 )
 
 const (
@@ -1200,6 +1201,10 @@ func (k *kataAgent) appendDevices(deviceList []*grpc.Device, c *Container) []*gr
 			return nil
 		}
 
+		if strings.HasPrefix(dev.ContainerPath, defaultKataGuestVirtualVolumedir) {
+			continue
+		}
+
 		switch device.DeviceType() {
 		case config.DeviceBlock:
 			kataDevice = k.appendBlockDevice(dev, device, c)