nvmeof: do not pass mutable parameters to RBD CreateVolume

Do not pass any mutable parameters to the RBD CreateVolume call.
NVMe-oF manages its own mutable parameters (QoS and host list)
separately and these should not be passed to RBD.

The NVMe-oF mutable parameters are defined in a shared slice:
- nvmeofRWIOsPerSecond
- nvmeofRWMbytesPerSecond
- nvmeofRMbytesPerSecond
- nvmeofWMbytesPerSecond
- allowHostNQNs

This shared slice is used in CreateVolume, ControllerModifyVolume,
and validateCreateVolumeRequest to avoid duplication.

Assisted-by: AskBob <askbob@ibm.com>
Signed-off-by: Niels de Vos <ndevos@ibm.com>

Author: nixpanic

internal/nvmeof/controller/controllerserver.go

@@ -41,6 +41,15 @@ import (
 	"github.com/ceph/ceph-csi/internal/util/log"
 )
 
+// nvmeofMutableParams lists all NVMe-oF specific mutable parameters.
+var nvmeofMutableParams = []string{
+	nvmeof.RwIosPerSecond,
+	nvmeof.RwMbytesPerSecond,
+	nvmeof.RMbytesPerSecond,
+	nvmeof.WMbytesPerSecond,
+	nvmeof.AllowHostNQNs,
+}
+
 type Server struct {
 	csi.UnimplementedControllerServer
 
@@ -99,6 +108,8 @@ func (cs *Server) ValidateVolumeCapabilities(
 }
 
 // CreateVolume creates a new RBD volume and exposes it through NVMe-oF Gateway.
+//
+//nolint:gocyclo,cyclop // TODO: reduce complexity
 func (cs *Server) CreateVolume(
 	ctx context.Context,
 	req *csi.CreateVolumeRequest,
@@ -148,9 +159,33 @@ func (cs *Server) CreateVolume(
 		defer cs.volumeLocks.Release(sourceVolumeID)
 	}
 
-	// Step 1: Create RBD volume through backend. if exists, it is ok.
+	// Step 1: Extract NVMe-oF mutable parameters before passing to RBD
+	extractedMutableParams := make(map[string]string)
+	if req.GetMutableParameters() != nil {
+		// Extract NVMe-oF specific mutable parameters
+		for _, key := range nvmeofMutableParams {
+			if value, exists := req.GetMutableParameters()[key]; exists {
+				extractedMutableParams[key] = value
+			}
+		}
+	}
+
+	// Create a modified request without any mutable parameters for RBD
+	// NVMe-oF handles its own mutable parameters separately
+	rbdReq := &csi.CreateVolumeRequest{
+		Name:                      req.GetName(),
+		CapacityRange:             req.GetCapacityRange(),
+		VolumeCapabilities:        req.GetVolumeCapabilities(),
+		Parameters:                req.GetParameters(),
+		Secrets:                   req.GetSecrets(),
+		VolumeContentSource:       req.GetVolumeContentSource(),
+		AccessibilityRequirements: req.GetAccessibilityRequirements(),
+		// MutableParameters intentionally not set - NVMe-oF manages these separately
+	}
+
+	// Step 2: Create RBD volume through backend. if exists, it is ok.
 	// RBD backend automatically handles cloning when VolumeContentSource is present.
-	res, err := cs.backendServer.CreateVolume(ctx, req)
+	res, err := cs.backendServer.CreateVolume(ctx, rbdReq)
 	if err != nil {
 		log.ErrorLog(ctx, "failed to create RBD volume: %v", err)
 
@@ -183,7 +218,7 @@ func (cs *Server) CreateVolume(
 	// can be empty. if it was defined in config-map the rbd csi driver would have set it already
 	rbdRadosNameSpace := res.GetVolume().GetVolumeContext()["radosNamespace"]
 
-	// Step 2: Setup NVMe-oF resources
+	// Step 4: Setup NVMe-oF resources
 	var nvmeofData *nvmeof.NVMeoFVolumeData
 	// Defer: Cleanup NVMe-oF on any error (BEFORE the call!)
 	defer func() {
@@ -204,13 +239,13 @@ func (cs *Server) CreateVolume(
 
 		return nil, status.Errorf(codes.Internal, "NVMe-oF setup failed: %v", err)
 	}
-	// step 3: Populate volume context for NodeServer
+	// Step 5: Populate volume context for NodeServer
 	err = populateVolumeContext(backend, nvmeofData)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "failed to populate volume context: %v", err)
 	}
 
-	// Step 4: Store NVMe-oF metadata in the volume context
+	// Step 6: Store NVMe-oF metadata in the volume context
 	err = cs.storeNVMeoFMetadata(ctx, req, volumeID, nvmeofData)
 	if err != nil {
 		return nil, err // Error already formatted with proper status code
@@ -372,28 +407,14 @@ func (cs *Server) ControllerModifyVolume(
 	defer cs.volumeLocks.Release(volumeID)
 
 	// Step 2: Validate that only known parameters are provided
-	knownParams := []string{
-		nvmeof.RwIosPerSecond,
-		nvmeof.RwMbytesPerSecond,
-		nvmeof.RMbytesPerSecond,
-		nvmeof.WMbytesPerSecond,
-		nvmeof.AllowHostNQNs,
-	}
-
 	for param := range params {
-		if !slices.Contains(knownParams, param) {
+		if !slices.Contains(nvmeofMutableParams, param) {
 			return nil, status.Errorf(codes.InvalidArgument,
 				"unknown mutable parameter: %s", param)
 		}
 	}
 
 	// Step 3: Parse QoS parameters from mutable_parameters
-	hasRBDQoS := rbd.HasQoSParams(params)
-	if hasRBDQoS {
-		log.ErrorLog(ctx, "Cannot set RBD QoS parameters on NVMe-oF volumes")
-
-		return nil, status.Error(codes.InvalidArgument, "cannot set RBD QoS parameters on NVMe-oF volumes")
-	}
 	nvmeofQoS, err := nvmeof.NewNVMeoFQosVolumeFromParams(params)
 	if err != nil {
 		log.ErrorLog(ctx, "failed to parse NVMe-oF QoS parameters: %v", err)
@@ -509,27 +530,16 @@ func validateCreateVolumeRequest(req *csi.CreateVolumeRequest) error {
 	mutableParams := req.GetMutableParameters()
 
 	// Validate that only known mutable parameters are provided
-	knownMutableParams := []string{
-		nvmeof.RwIosPerSecond,
-		nvmeof.RwMbytesPerSecond,
-		nvmeof.RMbytesPerSecond,
-		nvmeof.WMbytesPerSecond,
-		nvmeof.AllowHostNQNs,
-	}
-
 	for param := range mutableParams {
-		if !slices.Contains(knownMutableParams, param) {
+		if !slices.Contains(nvmeofMutableParams, param) {
 			return fmt.Errorf("unknown mutable parameter: %s", param)
 		}
 	}
 
-	// check for RBD QoS parameters in both params and mutableParams
+	// Check for RBD QoS parameters in regular params (not mutableParams - already validated above)
 	if hasRBDQoS := rbd.HasQoSParams(params); hasRBDQoS {
 		return errors.New("setting RBD QoS parameters on NVMe-oF volumes is not supported")
 	}
-	if hasRBDQoS := rbd.HasQoSParams(mutableParams); hasRBDQoS {
-		return errors.New("setting RBD QoS parameters on NVMe-oF volumes is not supported")
-	}
 
 	// It take the mutableParams value from the volumeAttributesClassName in the PersistentVolumeClaim yaml.
 	_, err = nvmeof.NewNVMeoFQosVolumeFromParams(mutableParams)