No controller fallback for fstype

PublishLUN will not default to a filesystem type. Import cases will continue to work by inspecting the volume to determine fstype before formatting.

Author: torirevilla

.github/workflows/github-actions.yml

@@ -94,6 +94,19 @@ jobs:
           mkdir ${{ runner.temp }}\${{ runner.os }}-coverage-binary.out
           go test -v ./... -covermode=count -- -test.gocoverdir=${{ runner.temp }}\${{ runner.os }}-coverage-binary.out
           go tool covdata textfmt -i=${{ runner.temp }}\${{ runner.os }}-coverage-binary.out -o ${{ runner.os }}-coverage.out
+      - if: runner.os == 'Linux'
+        name: Free Disk Space (Ubuntu)
+        uses: jlumbroso/free-disk-space@v1.3.1
+        with:
+          # this might remove tools that are actually needed,
+          # if set to "true" but frees about 6 GB
+          tool-cache: false
+          android: true
+          dotnet: true
+          haskell: true
+          large-packages: true
+          docker-images: false
+          swap-storage: true
       - if: runner.os != 'Windows'
         name: Run the tests (not on Windows)
         run: |

frontend/csi/controller_helpers/kubernetes/helper.go

@@ -1,4 +1,4 @@
-// Copyright 2025 NetApp, Inc. All Rights Reserved.
+// Copyright 2026 NetApp, Inc. All Rights Reserved.
 
 package kubernetes
 
@@ -140,6 +140,9 @@ func (h *helper) GetVolumeConfig(
 				Logc(ctx).WithError(err).Error("Invalid storage class parameters for LUKS volume import.")
 				return nil, err
 			}
+			if getAnnotation(annotations, AnnFileSystem) == "" {
+				return nil, fmt.Errorf("imported LUKS encrypted volume must provide file system type annotation")
+			}
 		}
 	}
 
@@ -862,6 +865,9 @@ func getVolumeConfig(
 			if _, err = strconv.ParseBool(luksEncryption); err != nil {
 				Logc(ctx).WithError(err).Warning("Unable to parse luks annotation into bool.")
 			}
+			if getAnnotation(annotations, AnnFileSystem) == "" {
+				Logc(ctx).Warning("Imported LUKS encrypted volume must provide file system type annotation.")
+			}
 		}
 	}
 

frontend/csi/controller_server.go

@@ -1,4 +1,4 @@
-// Copyright 2025 NetApp, Inc. All Rights Reserved.
+// Copyright 2026 NetApp, Inc. All Rights Reserved.
 
 package csi
 
@@ -408,6 +408,7 @@ func (p *Plugin) ControllerPublishVolume(
 	case tridentconfig.Block:
 		publishInfo["LUKSEncryption"] = volumePublishInfo.LUKSEncryption
 		publishInfo["sharedTarget"] = strconv.FormatBool(volumePublishInfo.SharedTarget)
+		publishInfo["volumeMode"] = string(volume.Config.VolumeMode)
 
 		if volumePublishInfo.SANType == sa.NVMe {
 			// fill in only NVMe specific fields in publishInfo

frontend/csi/controller_server_test.go

@@ -1073,6 +1073,7 @@ func TestControllerPublishVolume(t *testing.T) {
 					"SANType":           sa.NVMe,
 					"sharedTarget":      "false",
 					"nvmeTargetIPs":     "",
+					"volumeMode":        "",
 				},
 			},
 			expErrCode: codes.OK,
@@ -1110,6 +1111,7 @@ func TestControllerPublishVolume(t *testing.T) {
 					"SANType":                sa.ISCSI,
 					"sharedTarget":           "false",
 					"useCHAP":                "false",
+					"volumeMode":             "",
 				},
 			},
 			expErrCode: codes.OK,
@@ -1141,6 +1143,7 @@ func TestControllerPublishVolume(t *testing.T) {
 					"protocol":       "block",
 					"sharedTarget":   "false",
 					"useCHAP":        "false",
+					"volumeMode":     "",
 				},
 			},
 			expErrCode: codes.OK,

frontend/csi/node_server.go

@@ -1,4 +1,4 @@
-// Copyright 2025 NetApp, Inc. All Rights Reserved.
+// Copyright 2026 NetApp, Inc. All Rights Reserved.
 
 package csi
 
@@ -1327,6 +1327,7 @@ func (p *Plugin) nodeStageFCPVolume(
 	publishInfo.FCPLunSerial = req.PublishContext["fcpLunSerial"]
 	publishInfo.FCPIgroup = req.PublishContext["fcpIgroup"]
 	publishInfo.SANType = req.PublishContext["SANType"]
+	publishInfo.VolumeMode = req.PublishContext["volumeMode"]
 
 	volumeId, stagingTargetPath, err := p.getVolumeIdAndStagingPath(req)
 	if err != nil {
@@ -1765,6 +1766,7 @@ func (p *Plugin) nodeStageISCSIVolume(
 	publishInfo.IscsiLunSerial = req.PublishContext["iscsiLunSerial"]
 	publishInfo.IscsiInterface = req.PublishContext["iscsiInterface"]
 	publishInfo.IscsiIgroup = req.PublishContext["iscsiIgroup"]
+	publishInfo.VolumeMode = req.PublishContext["volumeMode"]
 
 	if useCHAP {
 		publishInfo.IscsiUsername = req.PublishContext["iscsiUsername"]
@@ -2986,6 +2988,7 @@ func (p *Plugin) nodeStageNVMeVolume(
 	publishInfo.NVMeTargetIPs = strings.Split(req.PublishContext["nvmeTargetIPs"], ",")
 	publishInfo.SANType = req.PublishContext["SANType"]
 	publishInfo.FormatOptions = req.PublishContext["formatOptions"]
+	publishInfo.VolumeMode = req.PublishContext["volumeMode"]
 
 	err := p.nvmeHandler.AttachNVMeVolumeRetry(
 		ctx, req.VolumeContext["internalName"], "", publishInfo, req.GetSecrets(), nvme.NVMeAttachTimeout,

storage_drivers/ontap/ontap_common.go

@@ -984,7 +984,7 @@ func PublishLUN(
 	}
 
 	// Prefer the LUN attribute fstype (authoritative, records what is on disk) over volConfig
-	// to catch import mismatches. Fall back to volConfig, then driver default if absent.
+	// to catch import mismatches. Fall back to volConfig.
 	fstype := volConfig.FileSystem
 	lunFstype, lunErr := clientAPI.LunGetFSType(ctx, lunPath)
 	if lunErr != nil || lunFstype == "" {
@@ -995,14 +995,14 @@ func PublishLUN(
 			Logc(ctx).WithFields(LogFields{
 				"LUN":    lunPath,
 				"fstype": fstype,
-			}).Error("LUN attribute fstype not found, using default.")
-			fstype = drivers.DefaultFileSystemType
+			}).Warning("LUN attribute fstype not found.")
 		}
 		// else: keep volConfig value ("raw", "ext4", "xfs", etc.) — LUN has no attribute
 	} else {
 		// LUN attribute is present; it takes precedence over volConfig.
 		fstype = lunFstype
 	}
+	publishInfo.VolumeMode = string(volConfig.VolumeMode)
 
 	// Get the format options
 	// An example of how formatOption may look like:

storage_drivers/ontap/ontap_common_test.go

@@ -5929,7 +5929,7 @@ func TestPublishLun(t *testing.T) {
 	mockAPI.EXPECT().LunMapGetReportingNodes(ctx, igroupName, lunPath).Return([]string{"Node1"}, nil)
 	mockAPI.EXPECT().GetSLMDataLifs(ctx, ips, []string{"Node1"}).Return([]string{}, nil)
 
-	err := PublishLUN(ctx, mockAPI, config, ips, publishInfo, lunPath, igroupName, iSCSINodeName, volNoFsOrFmt)
+	err := PublishLUN(ctx, mockAPI, config, ips, publishInfo, lunPath, igroupName, iSCSINodeName, publishVolCfg("xfs", ""))
 
 	assert.NoError(t, err)
 
@@ -5942,7 +5942,7 @@ func TestPublishLun(t *testing.T) {
 
 	assert.Error(t, err)
 
-	// Test 3 - LunGetFSType returns error
+	// Test 3 - LunGetFSType returns error, fstype will fall back to fstype in vol config
 	mockAPI = mockapi.NewMockOntapAPI(mockCtrl)
 	publishInfo.HostIQN = []string{"host_iqn"}
 	mockAPI.EXPECT().LunGetFSType(ctx, lunPath).Return("", errors.New("LunGetFSType returned error"))
@@ -5956,7 +5956,7 @@ func TestPublishLun(t *testing.T) {
 	err = PublishLUN(ctx, mockAPI, config, ips, publishInfo, lunPath, igroupName, iSCSINodeName, volNoFsOrFmt)
 
 	assert.NoError(t, err)
-	assert.Equal(t, drivers.DefaultFileSystemType, publishInfo.FilesystemType)
+	assert.Equal(t, "", publishInfo.FilesystemType)
 
 	// Test 4 - LunGetAttribute returns error (fstype still from LUN)
 	mockAPI = mockapi.NewMockOntapAPI(mockCtrl)
@@ -6106,7 +6106,7 @@ func TestPublishLun(t *testing.T) {
 	assert.Equal(t, volFmtOpts, publishInfo.FormatOptions)
 	assert.Contains(t, publishInfo.MountOptions, "nouuid")
 
-	// Test 12 - volume fstype empty, LunGetFSType returns empty string with no error, use default
+	// Test 12 - volume fstype empty, LunGetFSType returns empty string with no error, expect empty
 	mockAPI = mockapi.NewMockOntapAPI(mockCtrl)
 	publishInfo = &tridentmodels.VolumePublishInfo{
 		BackendUUID: "fakeBackendUUID",
@@ -6127,9 +6127,9 @@ func TestPublishLun(t *testing.T) {
 	err = PublishLUN(ctx, mockAPI, config, ips, publishInfo, lunPath, igroupName, iSCSINodeName, volNoFsOrFmt)
 
 	assert.NoError(t, err)
-	assert.Equal(t, drivers.DefaultFileSystemType, publishInfo.FilesystemType)
+	assert.Equal(t, "", publishInfo.FilesystemType)
 
-	// Test 13 - volume fstype empty, LunGetFSType returns error, use default
+	// Test 13 - volume fstype empty, LunGetFSType returns error, will be empty
 	mockAPI = mockapi.NewMockOntapAPI(mockCtrl)
 	publishInfo = &tridentmodels.VolumePublishInfo{
 		BackendUUID: "fakeBackendUUID",
@@ -6150,7 +6150,7 @@ func TestPublishLun(t *testing.T) {
 	err = PublishLUN(ctx, mockAPI, config, ips, publishInfo, lunPath, igroupName, iSCSINodeName, volNoFsOrFmt)
 
 	assert.NoError(t, err)
-	assert.Equal(t, drivers.DefaultFileSystemType, publishInfo.FilesystemType)
+	assert.Equal(t, "", publishInfo.FilesystemType)
 
 	// Test 14 - volConfig "raw", LUN attribute returns "ext4": LUN attribute wins.
 	// Surfaces the real on-disk fstype so the node-side mismatch guard can fire.

utils/fcp/fcp.go

@@ -1,4 +1,4 @@
-// Copyright 2024 NetApp, Inc. All Rights Reserved.
+// Copyright 2026 NetApp, Inc. All Rights Reserved.
 
 package fcp
 
@@ -507,6 +507,7 @@ func (client *Client) AttachVolume(
 		devicePath = luksDevice.MappedDevicePath()
 	}
 
+	// No filesystem work is required for raw block; return early.
 	if publishInfo.FilesystemType == filesystem.Raw {
 		return mpathSize, nil
 	}
@@ -521,6 +522,17 @@ func (client *Client) AttachVolume(
 		}
 	}
 
+	fstype, err := filesystem.DetermineFSType(publishInfo.FilesystemType, existingFstype, publishInfo.VolumeMode)
+	if err != nil {
+		return mpathSize, fmt.Errorf("LUN %s, device %s is formatted with unknown filesystem type", name, devicePath)
+	}
+	publishInfo.FilesystemType = fstype
+
+	// No filesystem work is required for raw block; return early.
+	if publishInfo.FilesystemType == filesystem.Raw {
+		return mpathSize, nil
+	}
+
 	if existingFstype == "" {
 		if !isLUKSDevice {
 			if unformatted, err := client.deviceClient.IsDeviceUnformatted(ctx, devicePath); err != nil {

utils/filesystem/utils.go

@@ -1,11 +1,13 @@
-// Copyright 2025 NetApp, Inc. All Rights Reserved.
+// Copyright 2026 NetApp, Inc. All Rights Reserved.
 
 package filesystem
 
 import (
 	"fmt"
 	"regexp"
 	"strings"
+
+	"github.com/netapp/trident/config"
 )
 
 var permsRegex = regexp.MustCompile(`^[0-7]{4}$`)
@@ -27,3 +29,31 @@ func ValidateOctalUnixPermissions(perms string) error {
 	}
 	return nil
 }
+
+// DetermineFSType resolves the effective filesystem type to use for a volume.
+// Priority order:
+//  1. publishInfoType — use it as-is when provided (explicit caller intent).
+//  2. existingType — adopt the type already on disk when it is known (non-empty,
+//     non-UnknownFstype), so that subsequent format/mount logic stays consistent.
+//  3. volumeMode fallback — when no usable on-disk type is available, default to
+//     ext4 for Filesystem volumes or raw for Block volumes. A Filesystem volume
+//     whose on-disk type is UnknownFstype still defaults to ext4 but also returns
+//     an error because the LUN's existing format is unrecognisable.
+func DetermineFSType(publishInfoType, existingType, volumeMode string) (string, error) {
+	fsType := publishInfoType
+	if publishInfoType == "" {
+		switch {
+		case existingType != "" && existingType != UnknownFstype:
+			// Adopt whatever is on disk so subsequent format/mount logic uses it.
+			fsType = existingType
+		case volumeMode == string(config.Filesystem):
+			if existingType == UnknownFstype {
+				return "", fmt.Errorf("LUN is formatted with unknown filesystem type")
+			}
+			fsType = Ext4
+		case volumeMode == string(config.RawBlock):
+			fsType = Raw
+		}
+	}
+	return fsType, nil
+}

utils/filesystem/utils_test.go

@@ -6,6 +6,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+
+	"github.com/netapp/trident/config"
 )
 
 func TestVerifyFilesystemSupport(t *testing.T) {
@@ -66,3 +68,92 @@ func TestValidateOctalUnixPermissions(t *testing.T) {
 		assert.Equal(t, test.errNotNil, err != nil)
 	}
 }
+
+func TestDetermineFSType(t *testing.T) {
+	fsVolumeMode := string(config.Filesystem)
+	blockVolumeMode := string(config.RawBlock)
+
+	tests := []struct {
+		name            string
+		publishInfoType string
+		existingType    string
+		volumeMode      string
+		expectedFSType  string
+		errNotNil       bool
+	}{
+		// publishInfoType takes precedence regardless of other inputs.
+		{
+			name:            "publishInfoType provided — returned directly",
+			publishInfoType: Xfs,
+			existingType:    "",
+			volumeMode:      fsVolumeMode,
+			expectedFSType:  Xfs,
+		},
+		{
+			name:            "publishInfoType overrides existing on-disk type",
+			publishInfoType: Ext4,
+			existingType:    Xfs,
+			volumeMode:      fsVolumeMode,
+			expectedFSType:  Ext4,
+		},
+
+		// No publishInfoType — adopt the known on-disk type.
+		{
+			name:           "existing xfs adopted when publishInfoType absent",
+			existingType:   Xfs,
+			volumeMode:     fsVolumeMode,
+			expectedFSType: Xfs,
+		},
+		{
+			name:           "existing ext3 adopted when publishInfoType absent",
+			existingType:   Ext3,
+			volumeMode:     fsVolumeMode,
+			expectedFSType: Ext3,
+		},
+
+		// No publishInfoType, no usable existing type — fall back by volumeMode.
+		{
+			name:           "filesystem volume with empty existing type defaults to ext4",
+			existingType:   "",
+			volumeMode:     fsVolumeMode,
+			expectedFSType: Ext4,
+		},
+		{
+			name:           "raw-block volume with empty existing type defaults to raw",
+			existingType:   "",
+			volumeMode:     blockVolumeMode,
+			expectedFSType: Raw,
+		},
+		{
+			name:           "raw-block volume with unknown existing type defaults to raw",
+			existingType:   UnknownFstype,
+			volumeMode:     blockVolumeMode,
+			expectedFSType: Raw,
+		},
+
+		// Filesystem volume with an unknown on-disk type: default to ext4 but surface an error.
+		{
+			name:           "filesystem volume with unknown existing type returns ext4 and error",
+			existingType:   UnknownFstype,
+			volumeMode:     fsVolumeMode,
+			expectedFSType: "",
+			errNotNil:      true,
+		},
+
+		// No publishInfoType, no matching volumeMode — nothing to fall back to.
+		{
+			name:           "empty inputs yield empty fsType and no error",
+			existingType:   "",
+			volumeMode:     "",
+			expectedFSType: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fsType, err := DetermineFSType(tt.publishInfoType, tt.existingType, tt.volumeMode)
+			assert.Equal(t, tt.expectedFSType, fsType)
+			assert.Equal(t, tt.errNotNil, err != nil)
+		})
+	}
+}