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`  | `mkfsOptions`           | Empty String    | String. Comma-separated mkfs options passed to mkfs when formatting the volume. Useful for passing `-E nodiscard` on Ceph-backed storage to speed up provisioning. |
 | 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["mkfsOptions"]; mkfsOptions != "" {
+			existingVolCtx["mkfsOptions"] = 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["mkfsOptions"]; mkfsOptions != "" {
+		volCtx["mkfsOptions"] = 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 mkfsOptions 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 mkfsOptions
+	fakeReq := &csi.CreateVolumeRequest{
+		Name: FakeVolName,
+		VolumeCapabilities: []*csi.VolumeCapability{
+			{
+				AccessMode: &csi.VolumeCapability_AccessMode{
+					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+				},
+			},
+		},
+		Parameters: map[string]string{
+			"mkfsOptions": "-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 mkfsOptions is in VolumeContext
+	assert.NotNil(actualRes.Volume)
+	assert.Equal("-E nodiscard", actualRes.Volume.VolumeContext["mkfsOptions"])
+}
+
+// Test CreateVolume passes mkfsOptions 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 mkfsOptions
+	fakeReq := &csi.CreateVolumeRequest{
+		Name: FakeVolName,
+		VolumeCapabilities: []*csi.VolumeCapability{
+			{
+				AccessMode: &csi.VolumeCapability_AccessMode{
+					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+				},
+			},
+		},
+		Parameters: map[string]string{
+			"mkfsOptions": "-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 mkfsOptions is in VolumeContext even on idempotent path
+	assert.NotNil(actualRes.Volume)
+	assert.Equal("-E nodiscard", actualRes.Volume.VolumeContext["mkfsOptions"])
+}
+
 // Test CreateVolume with ignore-volume-az option
 func TestCreateVolumeWithIgnoreVolumeAZ(t *testing.T) {
 	fakeCs, osmock := fakeControllerServer()

pkg/csi/cinder/nodeserver.go

@@ -219,8 +219,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["mkfsOptions"]; ok && mkfsOpts != "" {
+			formatOptions = parseMkfsOptions(mkfsOpts)
+			klog.V(4).Infof("NodeStageVolume: mkfsOptions 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 +256,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 +268,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
 }
@@ -429,6 +437,20 @@ func getDevicePath(volumeID string, m mount.IMount) (string, error) {
 	return devicePath, nil
 }
 
+// parseMkfsOptions splits a comma-separated mkfsOptions string into individual
+// command-line arguments. Each comma-separated token is further split on
+// whitespace. Empty tokens are filtered out.
+func parseMkfsOptions(mkfsOpts string) []string {
+	var formatOptions []string
+	for _, opt := range strings.Split(mkfsOpts, ",") {
+		opt = strings.TrimSpace(opt)
+		if opt != "" {
+			formatOptions = append(formatOptions, strings.Fields(opt)...)
+		}
+	}
+	return formatOptions
+}
+
 func collectMountOptions(fsType string, mntFlags []string) []string {
 	var options []string
 	options = append(options, mntFlags...)

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{
+			"mkfsOptions": "-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()
@@ -396,3 +438,54 @@ func TestNodeGetVolumeStatsFs(t *testing.T) {
 	assert.Equal(expectedFsRes, fsRes)
 
 }
+
+func TestParseMkfsOptions(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{
+			name:     "single option with flag",
+			input:    "-E nodiscard",
+			expected: []string{"-E", "nodiscard"},
+		},
+		{
+			name:     "multiple comma-separated options",
+			input:    "-E nodiscard,-O ^metadata_csum",
+			expected: []string{"-E", "nodiscard", "-O", "^metadata_csum"},
+		},
+		{
+			name:     "trailing comma",
+			input:    "-E nodiscard,",
+			expected: []string{"-E", "nodiscard"},
+		},
+		{
+			name:     "double comma",
+			input:    "-E nodiscard,,-b 4096",
+			expected: []string{"-E", "nodiscard", "-b", "4096"},
+		},
+		{
+			name:     "whitespace around commas",
+			input:    " -E nodiscard , -b 4096 ",
+			expected: []string{"-E", "nodiscard", "-b", "4096"},
+		},
+		{
+			name:     "single flag no value",
+			input:    "-F",
+			expected: []string{"-F"},
+		},
+		{
+			name:     "empty string",
+			input:    "",
+			expected: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := parseMkfsOptions(tt.input)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}