MTV-5556: Warm precopy on Pure FlashArray vVol falls back to slow vmkfstools clone instead of array offload

When a precopy snapshot is active, the top-of-chain backing's filename
is the child disk (foo-000001.vmdk) while forklift passes the base
path (foo.vmdk). The old top-only path comparison missed this and the
populator fell through to the VMDK/vmkfstools fallback. vmkfstools
still produced correct bytes (it opens foo.vmdk on the host and VASA
serves the snap-vVol), but at host-mediated speed.

Walk the Parent chain and return the BackingObjectId of the node
whose filename matches the caller's vmdkPath. Warm precopy now matches
at the parent, identifies the snap-vVol, and copies it via Pure REST.

Signed-off-by: Wanru Liu <waliu@purestorage.com>

Author: Wanru Liu

cmd/vsphere-xcopy-volume-populator/internal/pure/flashArray.go

@@ -243,25 +243,43 @@ func (f *FlashArrayClonner) getSourceVolume(vsphereClient vmware.Client, vmId st
 		if disk, ok := device.(*types.VirtualDisk); ok {
 			if backing, ok := disk.Backing.(*types.VirtualDiskFlatVer2BackingInfo); ok {
 				// Check if this is a VVol backing and matches our target VMDK
-				if backing.BackingObjectId != "" && f.matchesVMDKPath(backing.FileName, vmDisk) {
-					klog.Infof("Found VVol backing for VMDK %s with ID %s", vmDisk.VmdkFile, backing.BackingObjectId)
-
-					// Use REST client to find the volume by VVol ID
-					volumeName, err := f.restClient.FindVolumeByVVolID(backing.BackingObjectId)
-					if err != nil {
-						klog.Warningf("Failed to find volume by VVol ID %s: %v", backing.BackingObjectId, err)
-						continue
-					}
+				matched := f.findMatchingFlatBacking(backing, vmDisk)
+				if matched == nil || matched.BackingObjectId == "" {
+					continue
+				}
+				klog.Infof("Found VVol backing for VMDK %s with ID %s (matched at FileName %s)",
+					vmDisk.VmdkFile, matched.BackingObjectId, matched.FileName)
 
-					return volumeName, nil
+				// Use REST client to find the volume by VVol ID
+				volumeName, err := f.restClient.FindVolumeByVVolID(matched.BackingObjectId)
+				if err != nil {
+					klog.Warningf("Failed to find volume by VVol ID %s: %v", matched.BackingObjectId, err)
+					continue
 				}
+				return volumeName, nil
 			}
 		}
 	}
 
 	return "", fmt.Errorf("VVol backing for VMDK %s not found", vmDisk.VmdkFile)
 }
 
+// findMatchingFlatBacking returns the first node in b's Parent chain whose
+// filename matches vmDisk, or nil if none does.
+//
+// While a snapshot is active the chain is "child disk (foo-000001.vmdk) ->
+// parent (foo.vmdk)", and VASA reports a different BackingObjectId per level:
+// child -> base vVol (current writes), parent -> snap-vVol (frozen). The
+// caller's vmdkPath picks which level matches.
+func (f *FlashArrayClonner) findMatchingFlatBacking(b *types.VirtualDiskFlatVer2BackingInfo, vmDisk populator.VMDisk) *types.VirtualDiskFlatVer2BackingInfo {
+	for cur := b; cur != nil; cur = cur.Parent {
+		if f.matchesVMDKPath(cur.FileName, vmDisk) {
+			return cur
+		}
+	}
+	return nil
+}
+
 // matchesVMDKPath checks if a vSphere VVol filename matches the target VMDK
 func (f *FlashArrayClonner) matchesVMDKPath(fileName string, vmDisk populator.VMDisk) bool {
 	fileBase := filepath.Base(fileName)

cmd/vsphere-xcopy-volume-populator/internal/vmware/client.go

@@ -3,11 +3,10 @@ package vmware
 import (
 	"context"
 	"encoding/xml"
+	"fmt"
 	"net/url"
 	"strings"
 
-	"fmt"
-
 	"github.com/vmware/govmomi"
 	"github.com/vmware/govmomi/cli/esx"
 	"github.com/vmware/govmomi/find"
@@ -24,7 +23,7 @@ type Client interface {
 	GetEsxByVm(ctx context.Context, vmName string) (*object.HostSystem, error)
 	RunEsxCommand(ctx context.Context, host *object.HostSystem, command []string) ([]esx.Values, error)
 	GetDatastore(ctx context.Context, dc *object.Datacenter, datastore string) (*object.Datastore, error)
-	// GetVMDiskBacking returns disk backing information for detecting disk type (VVol, RDM, VMDK)
+	// GetVMDiskBacking returns disk backing information for detecting disk type (VVol, RDM, VMDK).
 	GetVMDiskBacking(ctx context.Context, vmId string, vmdkPath string) (*DiskBacking, error)
 }
 
@@ -193,31 +192,28 @@ func (c *VSphereClient) GetVMDiskBacking(ctx context.Context, vmId string, vmdkP
 		// Check different backing types
 		switch backing := disk.Backing.(type) {
 		case *types.VirtualDiskFlatVer2BackingInfo:
-			// Check if this disk matches the requested path
-			if !strings.Contains(strings.ToLower(backing.FileName), normalizedPath) &&
-				!strings.Contains(normalizedPath, strings.ToLower(backing.FileName)) {
-				// Try to match by extracting datastore and path
-				if !diskPathMatches(backing.FileName, vmdkPath) {
-					continue
-				}
+			// Walk the chain to handle warm precopy. While a precopy snapshot is active,
+			// vSphere adds a child disk (foo-000001.vmdk) on top of the original
+			// (foo.vmdk). vmdkPath is the base path, so the match lives at the parent
+			// level, not the top.
+			matched := findMatchingFlatBacking(backing, normalizedPath, vmdkPath)
+			if matched == nil {
+				continue
 			}
 
-			// Check for VVol backing
-			if backing.BackingObjectId != "" {
+			if matched.BackingObjectId != "" {
 				klog.V(2).Infof("Disk %s is VVol-backed (BackingObjectId: %s)", vmdkPath, backing.BackingObjectId)
 				return &DiskBacking{
-					VVolId:     backing.BackingObjectId,
+					VVolId:     matched.BackingObjectId,
 					IsRDM:      false,
-					DeviceName: backing.FileName,
+					DeviceName: matched.FileName,
 				}, nil
 			}
-
-			// Regular VMDK
 			klog.V(2).Infof("Disk %s is VMDK-backed", vmdkPath)
 			return &DiskBacking{
 				VVolId:     "",
 				IsRDM:      false,
-				DeviceName: backing.FileName,
+				DeviceName: matched.FileName,
 			}, nil
 
 		case *types.VirtualDiskRawDiskMappingVer1BackingInfo:
@@ -247,6 +243,25 @@ func (c *VSphereClient) GetVMDiskBacking(ctx context.Context, vmId string, vmdkP
 	}, nil
 }
 
+// findMatchingFlatBacking returns the first node in b's Parent chain whose
+// filename matches vmdkPath, or nil if none does.
+//
+// While a snapshot is active the chain is "child disk (foo-000001.vmdk) ->
+// parent (foo.vmdk)", and VASA reports a different BackingObjectId per level:
+// child -> base vVol (current writes), parent -> snap-vVol (frozen). The
+// caller's vmdkPath picks which level matches.
+func findMatchingFlatBacking(b *types.VirtualDiskFlatVer2BackingInfo, normalizedPath, vmdkPath string) *types.VirtualDiskFlatVer2BackingInfo {
+	for cur := b; cur != nil; cur = cur.Parent {
+		fn := strings.ToLower(cur.FileName)
+		if strings.Contains(fn, normalizedPath) ||
+			strings.Contains(normalizedPath, fn) ||
+			diskPathMatches(cur.FileName, vmdkPath) {
+			return cur
+		}
+	}
+	return nil
+}
+
 // diskPathMatches compares two VMDK paths accounting for different formats
 func diskPathMatches(path1, path2 string) bool {
 	// Extract datastore and filename from both paths