nvmeof: add device tracking and disconnect in NodeUnstageVolume

Implement proper disconnect logic in NodeUnstageVolume that only
disconnects controllers when no other volumes are using them.

Changes:

1. Add getDeviceFromStagingPath() to find the Nvme
   device for a volume
   - Uses findmnt with JSON output for reliable parsing
   - Handles both filesystem and block volumes

2. Add getNVMeMountedDevices() to get all
   currently mounted NVMe devices
   - Single findmnt call scans entire mount table efficiently
   - Filters for NVMe-oF CSI staging paths only
   - Returns map of mounted devices for quick lookup

3. Update NodeUnstageVolume to call
   DisconnectIfLastMount after unmount
   - Gets device path from staging path
   - Gets list of all mounted NVMe devices
   - Passes both to DisconnectIfLastMount for
     safe disconnect decision
   - Disconnect failures are non-fatal (logged as warnings)

Signed-off-by: gadi-didi <gadi.didi@ibm.com>

Author: gadididi

internal/nvmeof/nodeserver/nodeserver.go

@@ -32,6 +32,7 @@ import (
 
 	csicommon "github.com/ceph/ceph-csi/internal/csi-common"
 	"github.com/ceph/ceph-csi/internal/nvmeof"
+	nvmeutil "github.com/ceph/ceph-csi/internal/nvmeof/util"
 	"github.com/ceph/ceph-csi/internal/util"
 	"github.com/ceph/ceph-csi/internal/util/log"
 )
@@ -326,6 +327,8 @@ func (ns *NodeServer) NodeUnstageVolume(
 
 	stagingTargetPath := getStagingTargetPath(req)
 
+	devPath := getDeviceFromStagingPath(ctx, stagingTargetPath)
+
 	isMnt, err := ns.Mounter.IsMountPoint(stagingTargetPath)
 	if err != nil {
 		if !os.IsNotExist(err) {
@@ -358,6 +361,20 @@ func (ns *NodeServer) NodeUnstageVolume(
 	}
 	log.DebugLog(ctx, "successfully removed staging path (%s)", stagingTargetPath)
 
+	// Disconnect controllers if this was the last mounted namespace on each controller.
+	// Non-fatal - a failed disconnect just means the connection lingers until the
+	// kernel's ctrl_loss_tmo expires or the next reconnect cycle.
+	if devPath != "" {
+		mountedDevices, err := getNVMeMountedDevices(ctx)
+		if err != nil {
+			log.WarningLog(ctx, "failed to get mounted devices: %v (skipping disconnect)", err)
+		} else {
+			if err := ns.initiator.DisconnectIfLastMount(ctx, devPath, mountedDevices); err != nil {
+				log.WarningLog(ctx, "failed to disconnect controller for device %s: %v", devPath, err)
+			}
+		}
+	}
+
 	return &csi.NodeUnstageVolumeResponse{}, nil
 }
 
@@ -394,18 +411,18 @@ func (ns *NodeServer) NodeExpandVolume(
 	mountPath := volumePath + "/" + volumeID
 
 	// Find device from mount (no metadata needed!)
-	devicePath, err := ns.getDeviceFromMount(ctx, mountPath)
-	if err != nil {
-		log.ErrorLog(ctx, "failed to find device for mount %s: %v", mountPath, err)
+	devicePath := getDeviceFromStagingPath(ctx, mountPath)
+	if devicePath == "" {
+		log.ErrorLog(ctx, "failed to find device for mount %s", mountPath)
 
-		return nil, status.Errorf(codes.Internal, "failed to find device: %v", err)
+		return nil, status.Errorf(codes.Internal, "failed to find device for mount %s", mountPath)
 	}
 
 	log.DebugLog(ctx, "nvmeof: resizing filesystem on device %s at mount path %s", devicePath, mountPath)
 
 	resizer := mount.NewResizeFs(utilexec.New())
 	var ok bool
-	ok, err = resizer.Resize(devicePath, mountPath)
+	ok, err := resizer.Resize(devicePath, mountPath)
 	if !ok {
 		return nil, status.Errorf(codes.Internal,
 			"nvmeof: resize failed on path %s, error: %v", req.GetVolumePath(), err)
@@ -758,20 +775,19 @@ func getStagingTargetPath(req interface{}) string {
 	return ""
 }
 
-// getDeviceFromMount finds the device path for a given mount path.
-func (ns *NodeServer) getDeviceFromMount(ctx context.Context, mountPath string) (string, error) {
-	mountPoints, err := ns.Mounter.List()
+// getDeviceFromStagingPath returns the device path for either filesystem or block volumes.
+func getDeviceFromStagingPath(ctx context.Context, stagingTargetPath string) string {
+	device, err := nvmeutil.GetDeviceFromMountpoint(ctx, stagingTargetPath)
 	if err != nil {
-		return "", fmt.Errorf("failed to list mounts: %w", err)
-	}
-
-	for _, mp := range mountPoints {
-		if mp.Path == mountPath {
-			log.DebugLog(ctx, "found device %s for mount path %s", mp.Device, mountPath)
+		log.DebugLog(ctx, "could not get device from staging path %s: %v", stagingTargetPath, err)
 
-			return mp.Device, nil
-		}
+		return ""
 	}
 
-	return "", fmt.Errorf("no mount found for path %s", mountPath)
+	return device
+}
+
+// getNVMeMountedDevices returns a map of all currently mounted NVMe devices.
+func getNVMeMountedDevices(ctx context.Context) (map[string]bool, error) {
+	return nvmeutil.GetAllNVMeMountedDevices(ctx)
 }