Add mkfs options parameter to volume context

Makefile

@@ -53,7 +53,7 @@ build-linux:
 	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o $(BINARY_NAME) -v ./cmd/
 
 docker-build:
-	docker build $(BUILDARGS) -t ${IMG} -f Dockerfile .
+	docker build $(BUILDARGS) -t ${IMG} -f Dockerfile . --load
 
 docker-push:
 	docker push ${IMG}

pkg/driver/constants.go

@@ -33,6 +33,10 @@ const (
 	ParameterNodeID = "node_id"
 	// ParameterDeviceName is the device name parameter
 	ParameterDeviceName = "device_name"
+	// ParameterReadOnly is the name of the parameter used to specify whether the volume should be mounted as read-only
+	ParameterReadOnly = "readOnly"
+	// ParameterMkfsOptions is the name of the parameter used to specify the options for the mkfs command
+	ParameterMkfsOptions = "mkfs_options"
 
 	CSIDriverName    = "csi.ironcore.dev"
 	topologyKey      = "topology." + CSIDriverName + "/zone"

pkg/driver/controller.go

@@ -57,6 +57,11 @@ func (d *driver) CreateVolume(ctx context.Context, req *csi.CreateVolumeRequest)
 		fstype = FSTypeExt4
 	}
 
+	mkfsOptions, ok := params[ParameterMkfsOptions]
+	if !ok {
+		mkfsOptions = ""
+	}
+
 	volumeClass, ok := params[ParameterType]
 	if !ok {
 		return nil, status.Errorf(codes.Internal, "Required parameter %s is missing", ParameterType)
@@ -136,6 +141,7 @@ func (d *driver) CreateVolume(ctx context.Context, req *csi.CreateVolumeRequest)
 				ParameterVolumePool:   volumePoolName,
 				ParameterCreationTime: time.Unix(volume.CreationTimestamp.Unix(), 0).String(),
 				ParameterFSType:       fstype,
+				ParameterMkfsOptions:  mkfsOptions,
 			},
 			ContentSource:      req.GetVolumeContentSource(),
 			AccessibleTopology: accessibleTopology,
@@ -461,7 +467,7 @@ func validateDeviceName(volume *storagev1alpha1.Volume, machine *computev1alpha1
 			}
 		}
 	}
-	return "", fmt.Errorf("failed to get device name of volume %s name from machine %s", client.ObjectKeyFromObject(volume), client.ObjectKeyFromObject(machine))
+	return "", fmt.Errorf("failed to get device name of volume %s from machine %s", client.ObjectKeyFromObject(volume), client.ObjectKeyFromObject(machine))
 }
 
 func isValidVolumeCapabilities(volCaps []*csi.VolumeCapability) bool {

pkg/driver/node.go

@@ -9,6 +9,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/container-storage-interface/spec/lib/go/csi"
 	"golang.org/x/sys/unix"
@@ -33,7 +34,8 @@ var (
 
 func (d *driver) NodeStageVolume(_ context.Context, req *csi.NodeStageVolumeRequest) (*csi.NodeStageVolumeResponse, error) {
 	klog.InfoS("Staging volume on node ", "Volume", req.GetVolumeId(), "StagingTargetPath", req.GetStagingTargetPath())
-	fstype := req.GetVolumeContext()[ParameterFSType]
+	volumeContext := req.GetVolumeContext()
+	fstype := volumeContext[ParameterFSType]
 	devicePath := req.PublishContext[ParameterDeviceName]
 
 	klog.InfoS("Check if the device path exists")
@@ -42,16 +44,10 @@ func (d *driver) NodeStageVolume(_ context.Context, req *csi.NodeStageVolumeRequ
 			// We will requeue here since the device path is not ready yet.
 			return nil, status.Errorf(codes.Unavailable, "Device path %s does not exist: %v", devicePath, err)
 		} else {
-			return nil, status.Errorf(codes.Internal, "Failed to determine wether the device path %s exists: %v", devicePath, err)
+			return nil, status.Errorf(codes.Internal, "Failed to determine whether the device path %s exists: %v", devicePath, err)
 		}
 	}
 
-	readOnly := false
-	if req.GetVolumeContext()["readOnly"] == "true" {
-		readOnly = true
-	}
-	mountOptions := req.GetVolumeCapability().GetMount().GetMountFlags()
-
 	targetPath := req.GetStagingTargetPath()
 	klog.InfoS("Validate mount point", "MountPoint", targetPath)
 	notMnt, err := d.mounter.IsLikelyNotMountPoint(targetPath)
@@ -68,16 +64,27 @@ func (d *driver) NodeStageVolume(_ context.Context, req *csi.NodeStageVolumeRequ
 		return nil, status.Errorf(codes.Internal, "Failed to create target directory %s for volume %s: %v", targetPath, req.GetVolumeId(), err)
 	}
 
-	var options []string
+	mountOptions := req.GetVolumeCapability().GetMount().GetMountFlags()
 
-	if readOnly {
+	readOnly, ok := volumeContext[ParameterReadOnly]
+	readOnlyFlag := ok && readOnly == "true"
+
+	var options []string
+	if readOnlyFlag {
 		options = append(options, "ro")
 	} else {
 		options = append(options, "rw")
 	}
 	options = append(options, mountOptions...)
+
+	var formatOptions []string
+	mkfsOptions, ok := volumeContext[ParameterMkfsOptions]
+	if ok && mkfsOptions != "" {
+		formatOptions = append(formatOptions, strings.Split(mkfsOptions, " ")...)
+	}
+
 	klog.InfoS("Format and mount the volume")
-	if err = d.mounter.FormatAndMount(devicePath, targetPath, fstype, options); err != nil {
+	if err = d.mounter.FormatAndMountSensitiveWithFormatOptions(devicePath, targetPath, fstype, options, nil, formatOptions); err != nil {
 		return nil, status.Errorf(codes.Internal, "Failed to mount volume %s [%s] to %s: %v", devicePath, fstype, targetPath, err)
 	}
 	klog.InfoS("Staged volume on node", "Volume", req.GetVolumeId())

pkg/driver/node_test.go

@@ -114,7 +114,7 @@ var _ = Describe("Node", func() {
 		It("should fail if the mount operation fails", func(ctx SpecContext) {
 			mockMounter.EXPECT().IsLikelyNotMountPoint(targetPath).Return(true, nil)
 			mockOS.EXPECT().MkdirAll(targetPath, os.FileMode(0750)).Return(nil)
-			mockMounter.EXPECT().FormatAndMount(devicePath, targetPath, fstype, mountOptions).Return(errors.New("failed to mount volume"))
+			mockMounter.EXPECT().FormatAndMountSensitiveWithFormatOptions(devicePath, targetPath, fstype, mountOptions, nil, nil).Return(errors.New("failed to mount volume"))
 			_, err := drv.NodeStageVolume(ctx, req)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(ContainSubstring("Failed to mount volume"))
@@ -126,7 +126,7 @@ var _ = Describe("Node", func() {
 		It("should stage the volume", func(ctx SpecContext) {
 			mockMounter.EXPECT().IsLikelyNotMountPoint(targetPath).Return(true, nil)
 			mockOS.EXPECT().MkdirAll(targetPath, os.FileMode(0750)).Return(nil)
-			mockMounter.EXPECT().FormatAndMount(devicePath, targetPath, fstype, mountOptions).Return(nil)
+			mockMounter.EXPECT().FormatAndMountSensitiveWithFormatOptions(devicePath, targetPath, fstype, mountOptions, nil, nil).Return(nil)
 			_, err := drv.NodeStageVolume(ctx, req)
 			Expect(err).NotTo(HaveOccurred())
 		})

pkg/utils/mount/mountutils_unix.go

@@ -18,7 +18,7 @@ import (
 // SafeFormatAndMount). Defined it explicitly so that it can be mocked.
 type MountWrapper interface {
 	k8smountutils.Interface
-	FormatAndMount(source string, target string, fstype string, options []string) error
+	FormatAndMountSensitiveWithFormatOptions(source string, target string, fstype string, options []string, sensitiveOptions []string, formatOptions []string) error
 	NewResizeFs() (Resizefs, error)
 }