Allow shared FS on any L40s slice count (CRUSOE-67560)

supportsFS() restricted shared-filesystem support on L40s to the full
l40s-48gb.10x node. That slice-count gate was a virtiofs-era constraint:
shared disks were backed per-host, so only a full node could share one.

Post-NFS-migration there is no host-locality requirement. region-coordinator
already encodes this — checkSharedVolumeSliceTypeandNumSlices only enforces
slice counts for projects still on virtiofs (gated on
IsProjectUsingVirtiofsForSharedDisks), and the node-side is-using-nfs check
reads the same source of truth (nfs-support-shared-disks flag +
tmp_nfs_migration table). A genuine virtiofs straggler still fails safe: the
node takes the virtiofs path, RC's attach gate rejects the sub-full-node
attach, and the pod stays in ContainerCreating — no data path risk.

Surfaced during INC-522 (Roboflow L40s): the customer pivoted impacted pools
to smaller L40s slices to dodge a kubelet GPU-allocation leak, and this CSI
gate blocked shared-FS on those slices.

Also add /internal/node/fs/ to CODEOWNERS so the slice gate + NFS mount path
route to storage, keeping the CSI-side gate aligned with the RC server side.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: npujari-crusoe

.gitlab/CODEOWNERS

@@ -17,3 +17,8 @@ Dockerfile.*       @crusoeenergy/squads/managed-orchestration @crusoeenergy/squa
 /internal/common/constants.go      @crusoeenergy/squads/storage @crusoeenergy/squads/managed-orchestration
 /internal/controller/controller.go @crusoeenergy/squads/storage @crusoeenergy/squads/managed-orchestration
 /internal/controller/util.go       @crusoeenergy/squads/storage @crusoeenergy/squads/managed-orchestration
+
+# Shared-filesystem support gating (supportsFS slice rules) and NFS mount path.
+# Coupled to region-coordinator's NFS migration + slice-type validation; storage
+# owns this so the CSI-side gate stays aligned with the server side (CRUSOE-67560).
+/internal/node/fs/                  @crusoeenergy/squads/storage @crusoeenergy/squads/managed-orchestration

internal/node/fs/util.go

@@ -52,8 +52,13 @@ func supportsFS(instance *crusoeapi.InstanceV1Alpha5) bool {
 		return true
 	}
 
-	// There are 10 slices in a L40s instance
-	if typeSegments[0] == "l40s-48gb" && typeSegments[1] == "10x" {
+	// L40s instances support shared filesystems on any slice count. The slice-count
+	// restriction was a virtiofs-era constraint (shared disk was backed per-host, so
+	// only a full node could share it). Post-NFS-migration there is no host-locality
+	// requirement, and region-coordinator already only enforces slice counts for
+	// projects still on virtiofs (see checkSharedVolumeSliceTypeandNumSlices, gated on
+	// IsProjectUsingVirtiofsForSharedDisks). CRUSOE-67560.
+	if typeSegments[0] == "l40s-48gb" {
 		return true
 	}
 

internal/node/fs/util_test.go

@@ -0,0 +1,52 @@
+package fs
+
+import (
+	"testing"
+
+	crusoeapi "github.com/crusoecloud/client-go/swagger/v1alpha5"
+)
+
+func TestSupportsFS(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name         string
+		instanceType string
+		want         bool
+	}{
+		// CPU instances always support shared FS, regardless of slice count.
+		{name: "c1a", instanceType: "c1a.16x", want: true},
+		{name: "s1a", instanceType: "s1a.8x", want: true},
+
+		// L40s: supported on any slice count (CRUSOE-67560). The full-node
+		// .10x case must keep working; smaller slices must now also pass.
+		{name: "l40s full node 10x", instanceType: "l40s-48gb.10x", want: true},
+		{name: "l40s single slice 1x", instanceType: "l40s-48gb.1x", want: true},
+		{name: "l40s partial 2x", instanceType: "l40s-48gb.2x", want: true},
+		{name: "l40s partial 5x", instanceType: "l40s-48gb.5x", want: true},
+
+		// GB200: only the full 4x node supports shared FS.
+		{name: "gb200 full node 4x", instanceType: "gb200-186gb-nvl.4x", want: true},
+		{name: "gb200 partial 1x", instanceType: "gb200-186gb-nvl.1x", want: false},
+
+		// Other GPU SKUs: only the full 8x node supports shared FS.
+		{name: "other gpu full node 8x", instanceType: "h100-80gb.8x", want: true},
+		{name: "other gpu partial 1x", instanceType: "h100-80gb.1x", want: false},
+
+		// Malformed type strings (not exactly two dot-separated segments).
+		{name: "missing slice segment", instanceType: "l40s-48gb", want: false},
+		{name: "too many segments", instanceType: "l40s-48gb.10x.foo", want: false},
+		{name: "empty", instanceType: "", want: false},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			instance := &crusoeapi.InstanceV1Alpha5{Type_: tc.instanceType}
+			if got := supportsFS(instance); got != tc.want {
+				t.Errorf("supportsFS(%q) = %v, want %v", tc.instanceType, got, tc.want)
+			}
+		})
+	}
+}