Add Raw Block Volume support

Author: handerajat

pkg/csi-util/utils.go

@@ -20,6 +20,7 @@ import (
 	"net"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -69,7 +70,6 @@ const (
 
 	InTransitEncryptionPackageName = "oci-fss-utils"
 	FIPS_ENABLED_FILE_PATH         = "/host/proc/sys/crypto/fips_enabled"
-	FINDMNT_COMMAND                = "findmnt"
 	CAT_COMMAND                    = "cat"
 	RPM_COMMAND                    = "rpm-host"
 	LabelIpFamilyPreferred         = "oci.oraclecloud.com/ip-family-preferred"
@@ -79,6 +79,9 @@ const (
 
 	Ipv6Stack = "IPv6"
 	Ipv4Stack = "IPv4"
+
+	// For Raw Block Volumes, the name of the bind-mounted file inside StagingTargetPath
+	RawBlockStagingFile = "mountfile"
 )
 
 // Util interface
@@ -255,6 +258,37 @@ func GetKubeClient(logger *zap.SugaredLogger, master, kubeconfig string) *kubern
 	return kubeClientSet
 }
 
+// Get the staging target filepath inside the given stagingTargetPath, to be used for raw block volume support
+func GetPathForBlock(volumePath string) string {
+	pathForBlock := filepath.Join(volumePath, RawBlockStagingFile)
+	return pathForBlock
+}
+
+// Creates a file on the specified path after creating the containing directory
+func CreateFilePath(logger *zap.SugaredLogger, path string) error {
+	pathDir := filepath.Dir(path)
+
+	err := os.MkdirAll(pathDir, 0750)
+	if err != nil {
+		logger.With(zap.Error(err)).Fatal("failed to create surrounding directory")
+		return err
+	}
+
+	file, fileErr := os.OpenFile(path, os.O_CREATE, 0640)
+	if fileErr != nil && !os.IsExist(fileErr) {
+		logger.With(zap.Error(err)).Fatal("failed to create/open the target file")
+		return fileErr
+	}
+
+	fileErr = file.Close()
+	if fileErr != nil {
+		logger.With(zap.Error(err)).Fatal("failed to close the target file")
+		return fileErr
+	}
+
+	return nil
+}
+
 func MaxOfInt(a, b int64) int64 {
 	if a > b {
 		return a
@@ -417,18 +451,6 @@ func IsInTransitEncryptionPackageInstalled() (bool, error) {
 	return false, nil
 }
 
-func FindMount(target string) ([]string, error) {
-	mountArgs := []string{"-n", "-o", "SOURCE", "-T", target}
-	command := exec.Command(FINDMNT_COMMAND, mountArgs...)
-	output, err := command.CombinedOutput()
-	if err != nil {
-		return nil, fmt.Errorf("findmnt failed: %v\narguments: %s\nOutput: %v\n", err, mountArgs, string(output))
-	}
-
-	sources := strings.Fields(string(output))
-	return sources, nil
-}
-
 func GetBlockSizeBytes(logger *zap.SugaredLogger, devicePath string) (int64, error) {
 	args := []string{"--getsize64", devicePath}
 	cmd := exec.Command("blockdev", args...)

pkg/csi/driver/bv_controller.go

@@ -244,7 +244,6 @@ func (d *BlockVolumeControllerDriver) CreateVolume(ctx context.Context, req *csi
 
 	availableDomainShortName := ""
 	volumeName := req.Name
-
 	dimensionsMap := make(map[string]string)
 
 	volumeParams, err := extractVolumeParameters(log, req.GetParameters())
@@ -256,6 +255,14 @@ func (d *BlockVolumeControllerDriver) CreateVolume(ctx context.Context, req *csi
 		return nil, status.Errorf(codes.InvalidArgument, "failed to parse storageclass parameters %v", err)
 	}
 
+	// Return error for the case of Raw Block Volume with Ultra High Performance Volumes
+	for _, cap := range req.VolumeCapabilities {
+		if blk := cap.GetBlock(); blk != nil && volumeParams.vpusPerGB >= 30 {
+			log.Error("volumeMode is set to Block for an Ultra High Performance Volume, which is not supported")
+			return nil, status.Errorf(codes.InvalidArgument, "failed to support Block volumeMode for Ultra High Performance Volumes (vpusPerGB >= 30)")
+		}
+	}
+
 	dimensionsMap[metrics.ResourceOCIDDimension] = volumeName
 	dimensionsMap[metrics.VolumeVpusPerGBDimension] = strconv.Itoa(int(volumeParams.vpusPerGB))
 
@@ -972,8 +979,7 @@ func (d *BlockVolumeControllerDriver) validateCapabilities(caps []*csi.VolumeCap
 
 	for _, cap := range caps {
 		if blk := cap.GetBlock(); blk != nil {
-			d.logger.Error("volumeMode is set to Block which is not supported.")
-			return fmt.Errorf("driver does not support Block volumeMode. Please use Filesystem mode")
+			d.logger.Info("The requested volume mode is set to Block")
 		}
 		if hasSupport(cap.AccessMode.Mode) {
 			continue

pkg/csi/driver/bv_controller_test.go

@@ -954,21 +954,94 @@ func TestControllerDriver_CreateVolume(t *testing.T) {
 			wantErr: errors.New("required in PreferredTopologies or allowedTopologies"),
 		},
 		{
-			name:   "Error for unsupported volumeMode Block",
+			name: "No error when a volume is created in block mode",
+			args: args{
+				ctx: context.TODO(),
+				req: &csi.CreateVolumeRequest{
+					Name: "volume-in-available-state",
+					VolumeCapabilities: []*csi.VolumeCapability{
+						{
+							AccessMode: &csi.VolumeCapability_AccessMode{
+								Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+							},
+							AccessType: &csi.VolumeCapability_Block{
+								Block: &csi.VolumeCapability_BlockVolume{},
+							},
+						},
+					},
+					Parameters: map[string]string{
+						"vpusPerGB": "10",
+					},
+					CapacityRange: &csi.CapacityRange{
+						RequiredBytes: int64(50000),
+					},
+					AccessibilityRequirements: &csi.TopologyRequirement{
+						Requisite: []*csi.Topology{
+							{
+								Segments: map[string]string{
+									kubeAPI.LabelZoneFailureDomain: "PHX-AD-2",
+								},
+							}, {
+								Segments: map[string]string{
+									kubeAPI.LabelZoneFailureDomain: "PHX-AD-2",
+								},
+							},
+						},
+					},
+				},
+			},
+			want: &csi.CreateVolumeResponse{
+				Volume: &csi.Volume{
+					VolumeId:      "volume-in-available-state",
+					CapacityBytes: int64(52428800000),
+					AccessibleTopology: []*csi.Topology{
+						{
+							Segments: map[string]string{
+								kubeAPI.LabelTopologyZone: "PHX-AD-2",
+							},
+						},
+						{
+							Segments: map[string]string{
+								kubeAPI.LabelZoneFailureDomain: "PHX-AD-2",
+							},
+						},
+					},
+					VolumeContext: map[string]string{
+						"needResize":      "false",
+						"newSize":         "",
+						"vpusPerGB":       "10",
+						"attachment-type": "",
+					},
+				},
+			},
+			wantErr: nil,
+		},
+		{
+			name:   "Error for support of Block volumeMode in Ultra High Performance Volumes (vpusPerGB >= 30)",
 			fields: fields{},
 			args: args{
 				ctx: nil,
 				req: &csi.CreateVolumeRequest{
 					Name: "ut-volume",
-					VolumeCapabilities: []*csi.VolumeCapability{{
-						AccessType: &csi.VolumeCapability_Block{
-							Block: &csi.VolumeCapability_BlockVolume{},
-						},
-					}},
+					VolumeCapabilities: []*csi.VolumeCapability{
+						{
+							AccessMode: &csi.VolumeCapability_AccessMode{
+								Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+							},
+							AccessType: &csi.VolumeCapability_Block{
+								Block: &csi.VolumeCapability_BlockVolume{},
+							},
+						}},
+					Parameters: map[string]string{
+						"vpusPerGB": "40",
+					},
+					CapacityRange: &csi.CapacityRange{
+						RequiredBytes: int64(csi_util.MaximumVolumeSizeInBytes),
+					},
 				},
 			},
 			want:    nil,
-			wantErr: errors.New("driver does not support Block volumeMode. Please use Filesystem mode"),
+			wantErr: errors.New("failed to support Block volumeMode for Ultra High Performance Volumes (vpusPerGB >= 30)"),
 		},
 		{
 			name:   "Create Volume times out waiting for volume to become available",