feat(cinder-csi): add mkfsOptions StorageClass parameter

Add support for a new `mkfsOptions` StorageClass parameter that allows
cluster admins to pass custom mkfs flags when formatting volumes. This
is particularly useful for Ceph-backed storage where passing
`-E nodiscard` to mkfs.ext4 can dramatically speed up provisioning
(e.g. from ~7 minutes to seconds for a 100 GB volume).

The parameter value is comma-separated, with each token further split
on whitespace to produce individual mkfs command-line arguments.
Example: `mkfsOptions: "-E nodiscard,-O ^metadata_csum"`

Implementation:
- Extract mkfsOptions from StorageClass params in CreateVolume and pass
  via VolumeContext (both new-volume and idempotent early-return paths)
- Parse mkfsOptions in NodeStageVolume using parseMkfsOptions() helper
- Use FormatAndMountSensitiveWithFormatOptions() from k8s.io/mount-utils
  to pass format options separately from mount options
- No behavior change when mkfsOptions is not set

Inspired by the Ceph CSI implementation (ceph/ceph-csi#621).

Author: rybnico

docs/cinder-csi-plugin/using-cinder-csi-plugin.md

@@ -283,6 +283,7 @@ helm install --namespace kube-system --name cinder-csi ./charts/cinder-csi-plugi
 |-------------------------   |-----------------------|-----------------|-----------------|
 | StorageClass `parameters`  | `availability`          | `nova`          | String. Volume Availability Zone |
 | StorageClass `parameters`  | `type`                  | Empty String    | String. Name/ID of Volume type. Corresponding volume type should exist in cinder     |
+| StorageClass `parameters`  | `mkfs-options`           | Empty String    | String. Comma-separated mkfs options passed to mkfs when formatting the volume. |
 | VolumeSnapshotClass `parameters` | `force-create`    | `false`         | Enable to support creating snapshot for a volume in in-use status |
 | VolumeSnapshotClass `parameters` | `type`            | Empty String    | `snapshot` creates a VolumeSnapshot object linked to a Cinder volume snapshot. `backup` creates a VolumeSnapshot object linked to a cinder volume backup. Defaults to `snapshot` if not defined |
 | VolumeSnapshotClass `parameters` | `backup-max-duration-seconds-per-gb`  | `20`    | Defines the amount of time to wait for a backup to complete in seconds per GB of volume size |

pkg/csi/cinder/controllerserver.go

@@ -119,7 +119,11 @@ func (cs *controllerServer) CreateVolume(ctx context.Context, req *csi.CreateVol
 		}
 		klog.V(4).Infof("Volume %s already exists in Availability Zone: %s of size %d GiB", vols[0].ID, vols[0].AvailabilityZone, vols[0].Size)
 		accessibleTopology := getTopology(&vols[0], accessibleTopologyReq, cs.Driver.withTopology, ignoreVolumeAZ)
-		return getCreateVolumeResponse(&vols[0], nil, accessibleTopology), nil
+		existingVolCtx := map[string]string{}
+		if mkfsOptions := volParams["mkfs-options"]; mkfsOptions != "" {
+			existingVolCtx["mkfs-options"] = mkfsOptions
+		}
+		return getCreateVolumeResponse(&vols[0], existingVolCtx, accessibleTopology), nil
 	}
 
 	if len(vols) > 1 {
@@ -233,6 +237,11 @@ func (cs *controllerServer) CreateVolume(ctx context.Context, req *csi.CreateVol
 		klog.V(4).Infof("CreateVolume: Resolved scheduler hints: affinity=%s, anti-affinity=%s", affinity, antiAffinity)
 	}
 
+	// Pass mkfsOptions to node via volume context
+	if mkfsOptions := volParams["mkfs-options"]; mkfsOptions != "" {
+		volCtx["mkfs-options"] = mkfsOptions
+	}
+
 	vol, err := cloud.CreateVolume(ctx, opts, schedulerHints)
 	if err != nil {
 		klog.Errorf("Failed to CreateVolume: %v", err)

pkg/csi/cinder/controllerserver_test.go

@@ -200,6 +200,94 @@ func TestCreateVolumeWithParam(t *testing.T) {
 	assert.Equal(FakeAvailability, actualRes.Volume.AccessibleTopology[0].GetSegments()[topologyKey])
 }
 
+// Test CreateVolume passes mkfs-options to VolumeContext
+func TestCreateVolumeWithMkfsOptions(t *testing.T) {
+	fakeCs, osmock := fakeControllerServer()
+
+	// mock OpenStack
+	properties := map[string]string{cinderCSIClusterIDKey: FakeCluster}
+	osmock.On("CreateVolume", FakeVolName, mock.AnythingOfType("int"), FakeVolType, FakeAvailability, "", "", "", properties).Return(&FakeVol, nil)
+	osmock.On("GetVolumesByName", FakeVolName).Return(FakeVolListEmpty, nil)
+	osmock.On("GetBlockStorageOpts").Return(openstack.BlockStorageOpts{})
+
+	assert := assert.New(t)
+
+	// Fake request with mkfs-options
+	fakeReq := &csi.CreateVolumeRequest{
+		Name: FakeVolName,
+		VolumeCapabilities: []*csi.VolumeCapability{
+			{
+				AccessMode: &csi.VolumeCapability_AccessMode{
+					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+				},
+			},
+		},
+		Parameters: map[string]string{
+			"mkfs-options": "-E nodiscard",
+		},
+		AccessibilityRequirements: &csi.TopologyRequirement{
+			Requisite: []*csi.Topology{
+				{
+					Segments: map[string]string{topologyKey: FakeAvailability},
+				},
+			},
+		},
+	}
+
+	// Invoke CreateVolume
+	actualRes, err := fakeCs.CreateVolume(FakeCtx, fakeReq)
+	if err != nil {
+		t.Errorf("failed to CreateVolume: %v", err)
+	}
+
+	// Assert mkfs-options is in VolumeContext
+	assert.NotNil(actualRes.Volume)
+	assert.Equal("-E nodiscard", actualRes.Volume.VolumeContext["mkfs-options"])
+}
+
+// Test CreateVolume passes mkfs-options on idempotent path (volume already exists)
+func TestCreateVolumeExistingWithMkfsOptions(t *testing.T) {
+	fakeCs, osmock := fakeControllerServer()
+
+	// mock OpenStack - volume already exists
+	osmock.On("GetVolumesByName", FakeVolName).Return(FakeVolList, nil)
+	osmock.On("GetBlockStorageOpts").Return(openstack.BlockStorageOpts{})
+
+	assert := assert.New(t)
+
+	// Fake request with mkfs-options
+	fakeReq := &csi.CreateVolumeRequest{
+		Name: FakeVolName,
+		VolumeCapabilities: []*csi.VolumeCapability{
+			{
+				AccessMode: &csi.VolumeCapability_AccessMode{
+					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+				},
+			},
+		},
+		Parameters: map[string]string{
+			"mkfs-options": "-E nodiscard",
+		},
+		AccessibilityRequirements: &csi.TopologyRequirement{
+			Requisite: []*csi.Topology{
+				{
+					Segments: map[string]string{topologyKey: FakeAvailability},
+				},
+			},
+		},
+	}
+
+	// Invoke CreateVolume
+	actualRes, err := fakeCs.CreateVolume(FakeCtx, fakeReq)
+	if err != nil {
+		t.Errorf("failed to CreateVolume: %v", err)
+	}
+
+	// Assert mkfs-options is in VolumeContext even on idempotent path
+	assert.NotNil(actualRes.Volume)
+	assert.Equal("-E nodiscard", actualRes.Volume.VolumeContext["mkfs-options"])
+}
+
 // Test CreateVolume with ignore-volume-az option
 func TestCreateVolumeWithIgnoreVolumeAZ(t *testing.T) {
 	fakeCs, osmock := fakeControllerServer()

pkg/csi/cinder/nodeserver.go

@@ -29,6 +29,7 @@ import (
 	"google.golang.org/grpc/status"
 	"k8s.io/klog/v2"
 	utilpath "k8s.io/utils/path"
+	"k8s.io/cloud-provider-openstack/pkg/util"
 
 	sharedcsi "k8s.io/cloud-provider-openstack/pkg/csi"
 	"k8s.io/cloud-provider-openstack/pkg/csi/cinder/openstack"
@@ -219,8 +220,16 @@ func (ns *nodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStageVol
 			mountFlags := mnt.GetMountFlags()
 			options = append(options, collectMountOptions(fsType, mountFlags)...)
 		}
+
+		// Parse mkfs options from volume context
+		var formatOptions []string
+		if mkfsOpts, ok := volumeContext["mkfs-options"]; ok && mkfsOpts != "" {
+			formatOptions = util.SplitTrim(mkfsOpts, ',')
+			klog.V(4).Infof("NodeStageVolume: mkfs-options for volume %s: %v", volumeID, formatOptions)
+		}
+
 		// Mount
-		err = ns.formatAndMountRetry(devicePath, stagingTarget, fsType, options)
+		err = ns.formatAndMountRetry(devicePath, stagingTarget, fsType, options, formatOptions)
 		if err != nil {
 			return nil, status.Error(codes.Internal, err.Error())
 		}
@@ -248,9 +257,9 @@ func (ns *nodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStageVol
 
 // formatAndMountRetry attempts to format and mount a device at the given path.
 // If the initial mount fails, it rescans the device and retries the mount operation.
-func (ns *nodeServer) formatAndMountRetry(devicePath, stagingTarget, fsType string, options []string) error {
+func (ns *nodeServer) formatAndMountRetry(devicePath, stagingTarget, fsType string, options []string, formatOptions []string) error {
 	m := ns.Mount
-	err := m.Mounter().FormatAndMount(devicePath, stagingTarget, fsType, options)
+	err := m.Mounter().FormatAndMountSensitiveWithFormatOptions(devicePath, stagingTarget, fsType, options, nil, formatOptions)
 	if err != nil {
 		klog.Infof("Initial format and mount failed: %v. Attempting rescan.", err)
 		// Attempting rescan if the initial mount fails
@@ -260,7 +269,7 @@ func (ns *nodeServer) formatAndMountRetry(devicePath, stagingTarget, fsType stri
 			return err
 		}
 		klog.Infof("Rescan succeeded, retrying format and mount")
-		err = m.Mounter().FormatAndMount(devicePath, stagingTarget, fsType, options)
+		err = m.Mounter().FormatAndMountSensitiveWithFormatOptions(devicePath, stagingTarget, fsType, options, nil, formatOptions)
 	}
 	return err
 }

pkg/csi/cinder/nodeserver_test.go

@@ -236,6 +236,48 @@ func TestNodeStageVolumeBlock(t *testing.T) {
 	assert.Equal(expectedRes, actualRes)
 }
 
+// Test NodeStageVolume with mkfsOptions in VolumeContext
+func TestNodeStageVolumeWithMkfsOptions(t *testing.T) {
+	fakeNs, omock, mmock, _ := fakeNodeServer()
+
+	mmock.On("GetDevicePath", FakeVolID).Return(FakeDevicePath, nil)
+	mmock.On("IsLikelyNotMountPointAttach", FakeStagingTargetPath).Return(true, nil)
+	omock.On("GetVolume", FakeVolID).Return(FakeVol, nil)
+
+	assert := assert.New(t)
+
+	// Expected Result
+	expectedRes := &csi.NodeStageVolumeResponse{}
+	stdVolCap := &csi.VolumeCapability{
+		AccessType: &csi.VolumeCapability_Mount{
+			Mount: &csi.VolumeCapability_MountVolume{},
+		},
+		AccessMode: &csi.VolumeCapability_AccessMode{
+			Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+		},
+	}
+
+	// Fake request with mkfsOptions in VolumeContext
+	fakeReq := &csi.NodeStageVolumeRequest{
+		VolumeId:          FakeVolID,
+		PublishContext:    map[string]string{"DevicePath": FakeDevicePath},
+		StagingTargetPath: FakeStagingTargetPath,
+		VolumeCapability:  stdVolCap,
+		VolumeContext: map[string]string{
+			"mkfs-options": "-E nodiscard",
+		},
+	}
+
+	// Invoke NodeStageVolume
+	actualRes, err := fakeNs.NodeStageVolume(FakeCtx, fakeReq)
+	if err != nil {
+		t.Errorf("failed to NodeStageVolume: %v", err)
+	}
+
+	// Assert
+	assert.Equal(expectedRes, actualRes)
+}
+
 // Test NodeUnpublishVolume
 func TestNodeUnpublishVolume(t *testing.T) {
 	fakeNs, omock, mmock, _ := fakeNodeServer()
@@ -394,5 +436,4 @@ func TestNodeGetVolumeStatsFs(t *testing.T) {
 
 	assert.NoError(err)
 	assert.Equal(expectedFsRes, fsRes)
-
 }