Merge branch 'main' of https://github.com/qiuming-best/velero into kopia-parallelism

pkg/controller/backup_controller.go

@@ -21,12 +21,11 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 
 	snapshotv1api "github.com/kubernetes-csi/external-snapshotter/client/v4/apis/volumesnapshot/v1"
-	snapshotterClientSet "github.com/kubernetes-csi/external-snapshotter/client/v4/clientset/versioned"
-	snapshotv1listers "github.com/kubernetes-csi/external-snapshotter/client/v4/listers/volumesnapshot/v1"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	corev1api "k8s.io/api/core/v1"
@@ -43,14 +42,18 @@ import (
 	"github.com/vmware-tanzu/velero/internal/resourcepolicies"
 	"github.com/vmware-tanzu/velero/internal/storage"
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
+	velerov2alpha1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v2alpha1"
 	pkgbackup "github.com/vmware-tanzu/velero/pkg/backup"
 	"github.com/vmware-tanzu/velero/pkg/discovery"
 	"github.com/vmware-tanzu/velero/pkg/features"
+	"github.com/vmware-tanzu/velero/pkg/itemoperation"
+	"github.com/vmware-tanzu/velero/pkg/kuberesource"
 	"github.com/vmware-tanzu/velero/pkg/label"
 	"github.com/vmware-tanzu/velero/pkg/metrics"
 	"github.com/vmware-tanzu/velero/pkg/persistence"
 	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt"
 	"github.com/vmware-tanzu/velero/pkg/plugin/framework"
+	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
 	"github.com/vmware-tanzu/velero/pkg/util/boolptr"
 	"github.com/vmware-tanzu/velero/pkg/util/collections"
 	"github.com/vmware-tanzu/velero/pkg/util/encode"
@@ -84,11 +87,10 @@ type backupReconciler struct {
 	metrics                     *metrics.ServerMetrics
 	backupStoreGetter           persistence.ObjectBackupStoreGetter
 	formatFlag                  logging.Format
-	volumeSnapshotLister        snapshotv1listers.VolumeSnapshotLister
-	volumeSnapshotClient        snapshotterClientSet.Interface
 	credentialFileStore         credentials.FileStore
 	maxConcurrentK8SConnections int
 	defaultSnapshotMoveData     bool
+	globalCRClient              kbclient.Client
 }
 
 func NewBackupReconciler(
@@ -110,10 +112,10 @@ func NewBackupReconciler(
 	metrics *metrics.ServerMetrics,
 	backupStoreGetter persistence.ObjectBackupStoreGetter,
 	formatFlag logging.Format,
-	volumeSnapshotLister snapshotv1listers.VolumeSnapshotLister,
 	credentialStore credentials.FileStore,
 	maxConcurrentK8SConnections int,
 	defaultSnapshotMoveData bool,
+	globalCRClient kbclient.Client,
 ) *backupReconciler {
 	b := &backupReconciler{
 		ctx:                         ctx,
@@ -135,10 +137,10 @@ func NewBackupReconciler(
 		metrics:                     metrics,
 		backupStoreGetter:           backupStoreGetter,
 		formatFlag:                  formatFlag,
-		volumeSnapshotLister:        volumeSnapshotLister,
 		credentialFileStore:         credentialStore,
 		maxConcurrentK8SConnections: maxConcurrentK8SConnections,
 		defaultSnapshotMoveData:     defaultSnapshotMoveData,
+		globalCRClient:              globalCRClient,
 	}
 	b.updateTotalBackupMetric()
 	return b
@@ -317,6 +319,7 @@ func (b *backupReconciler) prepareBackupRequest(backup *velerov1api.Backup, logg
 	request := &pkgbackup.Request{
 		Backup:           backup.DeepCopy(), // don't modify items in the cache
 		SkippedPVTracker: pkgbackup.NewSkipPVTracker(),
+		PVMap:            map[string]pkgbackup.PvcPvInfo{},
 	}
 
 	// set backup major version - deprecated, use Status.FormatVersion
@@ -665,7 +668,7 @@ func (b *backupReconciler) runBackup(backup *pkgbackup.Request) error {
 			backup.Status.VolumeSnapshotsCompleted++
 		}
 	}
-	volumeSnapshots, volumeSnapshotContents, volumeSnapshotClasses := pkgbackup.UpdateBackupCSISnapshotsStatus(b.kbClient, b.volumeSnapshotLister, backup.Backup, backupLog)
+	volumeSnapshots, volumeSnapshotContents, volumeSnapshotClasses := pkgbackup.UpdateBackupCSISnapshotsStatus(b.kbClient, b.globalCRClient, backup.Backup, backupLog)
 
 	// Iterate over backup item operations and update progress.
 	// Any errors on operations at this point should be added to backup errors.
@@ -734,6 +737,8 @@ func (b *backupReconciler) runBackup(backup *pkgbackup.Request) error {
 	if logFile, err := backupLog.GetPersistFile(); err != nil {
 		fatalErrs = append(fatalErrs, errors.Wrap(err, "error getting backup log file"))
 	} else {
+		backup.VolumeInfos.VolumeInfos = generateVolumeInfo(backup, volumeSnapshots, volumeSnapshotContents, volumeSnapshotClasses, b.globalCRClient, backupLog)
+
 		if errs := persistBackup(backup, backupFile, logFile, backupStore, volumeSnapshots, volumeSnapshotContents, volumeSnapshotClasses, results); len(errs) > 0 {
 			fatalErrs = append(fatalErrs, errs...)
 		}
@@ -796,7 +801,6 @@ func persistBackup(backup *pkgbackup.Request,
 ) []error {
 	persistErrs := []error{}
 	backupJSON := new(bytes.Buffer)
-	volumeInfos := make([]volume.VolumeInfo, 0)
 
 	if err := encode.To(backup.Backup, "json", backupJSON); err != nil {
 		persistErrs = append(persistErrs, errors.Wrap(err, "error encoding backup"))
@@ -843,7 +847,7 @@ func persistBackup(backup *pkgbackup.Request,
 		persistErrs = append(persistErrs, errs...)
 	}
 
-	volumeInfoJSON, errs := encode.ToJSONGzip(volumeInfos, "backup volumes information")
+	volumeInfoJSON, errs := encode.ToJSONGzip(backup.VolumeInfos, "backup volumes information")
 	if errs != nil {
 		persistErrs = append(persistErrs, errs...)
 	}
@@ -908,3 +912,328 @@ func oldAndNewFilterParametersUsedTogether(backupSpec velerov1api.BackupSpec) bo
 
 	return haveOldResourceFilterParameters && haveNewResourceFilterParameters
 }
+
+func generateVolumeInfo(backup *pkgbackup.Request, csiVolumeSnapshots []snapshotv1api.VolumeSnapshot,
+	csiVolumeSnapshotContents []snapshotv1api.VolumeSnapshotContent, csiVolumesnapshotClasses []snapshotv1api.VolumeSnapshotClass,
+	crClient kbclient.Client, logger logrus.FieldLogger) []volume.VolumeInfo {
+	volumeInfos := make([]volume.VolumeInfo, 0)
+
+	skippedVolumeInfos := generateVolumeInfoForSkippedPV(backup, logger)
+	volumeInfos = append(volumeInfos, skippedVolumeInfos...)
+
+	nativeSnapshotVolumeInfos := generateVolumeInfoForVeleroNativeSnapshot(backup, logger)
+	volumeInfos = append(volumeInfos, nativeSnapshotVolumeInfos...)
+
+	csiVolumeInfos := generateVolumeInfoForCSIVolumeSnapshot(backup, csiVolumeSnapshots, csiVolumeSnapshotContents, csiVolumesnapshotClasses, logger)
+	volumeInfos = append(volumeInfos, csiVolumeInfos...)
+
+	pvbVolumeInfos := generateVolumeInfoFromPVB(backup, crClient, logger)
+	volumeInfos = append(volumeInfos, pvbVolumeInfos...)
+
+	dataUploadVolumeInfos := generateVolumeInfoFromDataUpload(backup, crClient, logger)
+	volumeInfos = append(volumeInfos, dataUploadVolumeInfos...)
+
+	return volumeInfos
+}
+
+// generateVolumeInfoForSkippedPV generate VolumeInfos for SkippedPV.
+func generateVolumeInfoForSkippedPV(backup *pkgbackup.Request, logger logrus.FieldLogger) []volume.VolumeInfo {
+	tmpVolumeInfos := make([]volume.VolumeInfo, 0)
+
+	for _, skippedPV := range backup.SkippedPVTracker.Summary() {
+		if pvcPVInfo, ok := backup.PVMap[skippedPV.Name]; ok {
+			volumeInfo := volume.VolumeInfo{
+				PVCName:           pvcPVInfo.PVCName,
+				PVCNamespace:      pvcPVInfo.PVCNamespace,
+				PVName:            skippedPV.Name,
+				SnapshotDataMoved: false,
+				Skipped:           true,
+				SkippedReason:     skippedPV.SerializeSkipReasons(),
+				PVInfo: volume.PVInfo{
+					ReclaimPolicy: string(pvcPVInfo.PV.Spec.PersistentVolumeReclaimPolicy),
+					Labels:        pvcPVInfo.PV.Labels,
+				},
+			}
+			tmpVolumeInfos = append(tmpVolumeInfos, volumeInfo)
+		} else {
+			logger.Warnf("Cannot find info for PV %s", skippedPV.Name)
+			continue
+		}
+	}
+
+	return tmpVolumeInfos
+}
+
+// generateVolumeInfoForVeleroNativeSnapshot generate VolumeInfos for Velero native snapshot
+func generateVolumeInfoForVeleroNativeSnapshot(backup *pkgbackup.Request, logger logrus.FieldLogger) []volume.VolumeInfo {
+	tmpVolumeInfos := make([]volume.VolumeInfo, 0)
+
+	for _, nativeSnapshot := range backup.VolumeSnapshots {
+		var iops int64
+		if nativeSnapshot.Spec.VolumeIOPS != nil {
+			iops = *nativeSnapshot.Spec.VolumeIOPS
+		}
+
+		if pvcPVInfo, ok := backup.PVMap[nativeSnapshot.Spec.PersistentVolumeName]; ok {
+			volumeInfo := volume.VolumeInfo{
+				BackupMethod:      volume.NativeSnapshot,
+				PVCName:           pvcPVInfo.PVCName,
+				PVCNamespace:      pvcPVInfo.PVCNamespace,
+				PVName:            pvcPVInfo.PV.Name,
+				SnapshotDataMoved: false,
+				Skipped:           false,
+				NativeSnapshotInfo: volume.NativeSnapshotInfo{
+					SnapshotHandle: nativeSnapshot.Status.ProviderSnapshotID,
+					VolumeType:     nativeSnapshot.Spec.VolumeType,
+					VolumeAZ:       nativeSnapshot.Spec.VolumeAZ,
+					IOPS:           strconv.FormatInt(iops, 10),
+				},
+				PVInfo: volume.PVInfo{
+					ReclaimPolicy: string(pvcPVInfo.PV.Spec.PersistentVolumeReclaimPolicy),
+					Labels:        pvcPVInfo.PV.Labels,
+				},
+			}
+
+			tmpVolumeInfos = append(tmpVolumeInfos, volumeInfo)
+		} else {
+			logger.Warnf("cannot find info for PV %s", nativeSnapshot.Spec.PersistentVolumeName)
+			continue
+		}
+	}
+
+	return tmpVolumeInfos
+}
+
+// generateVolumeInfoForCSIVolumeSnapshot generate VolumeInfos for CSI VolumeSnapshot
+func generateVolumeInfoForCSIVolumeSnapshot(backup *pkgbackup.Request, csiVolumeSnapshots []snapshotv1api.VolumeSnapshot,
+	csiVolumeSnapshotContents []snapshotv1api.VolumeSnapshotContent, csiVolumesnapshotClasses []snapshotv1api.VolumeSnapshotClass,
+	logger logrus.FieldLogger) []volume.VolumeInfo {
+	tmpVolumeInfos := make([]volume.VolumeInfo, 0)
+
+	for _, volumeSnapshot := range csiVolumeSnapshots {
+		var volumeSnapshotClass *snapshotv1api.VolumeSnapshotClass
+		var volumeSnapshotContent *snapshotv1api.VolumeSnapshotContent
+
+		// This is protective logic. The passed-in VS should be all related
+		// to this backup.
+		if volumeSnapshot.Labels[velerov1api.BackupNameLabel] != backup.Name {
+			continue
+		}
+
+		if volumeSnapshot.Spec.VolumeSnapshotClassName == nil {
+			logger.Warnf("Cannot find VolumeSnapshotClass for VolumeSnapshot %s/%s", volumeSnapshot.Namespace, volumeSnapshot.Name)
+			continue
+		}
+
+		if volumeSnapshot.Status == nil || volumeSnapshot.Status.BoundVolumeSnapshotContentName == nil {
+			logger.Warnf("Cannot fine VolumeSnapshotContent for VolumeSnapshot %s/%s", volumeSnapshot.Namespace, volumeSnapshot.Name)
+			continue
+		}
+
+		if volumeSnapshot.Spec.Source.PersistentVolumeClaimName == nil {
+			logger.Warnf("VolumeSnapshot %s/%s doesn't have a source PVC", volumeSnapshot.Namespace, volumeSnapshot.Name)
+			continue
+		}
+
+		for index := range csiVolumesnapshotClasses {
+			if *volumeSnapshot.Spec.VolumeSnapshotClassName == csiVolumesnapshotClasses[index].Name {
+				volumeSnapshotClass = &csiVolumesnapshotClasses[index]
+			}
+		}
+
+		for index := range csiVolumeSnapshotContents {
+			if *volumeSnapshot.Status.BoundVolumeSnapshotContentName == csiVolumeSnapshotContents[index].Name {
+				volumeSnapshotContent = &csiVolumeSnapshotContents[index]
+			}
+		}
+
+		if volumeSnapshotClass == nil || volumeSnapshotContent == nil {
+			logger.Warnf("fail to get VolumeSnapshotContent or VolumeSnapshotClass for VolumeSnapshot: %s/%s",
+				volumeSnapshot.Namespace, volumeSnapshot.Name)
+			continue
+		}
+
+		var operation itemoperation.BackupOperation
+		for _, op := range *backup.GetItemOperationsList() {
+			if op.Spec.ResourceIdentifier.GroupResource.String() == kuberesource.VolumeSnapshots.String() &&
+				op.Spec.ResourceIdentifier.Name == volumeSnapshot.Name &&
+				op.Spec.ResourceIdentifier.Namespace == volumeSnapshot.Namespace {
+				operation = *op
+			}
+		}
+
+		var size int64
+		if volumeSnapshot.Status.RestoreSize != nil {
+			size = volumeSnapshot.Status.RestoreSize.Value()
+		}
+		snapshotHandle := ""
+		if volumeSnapshotContent.Status.SnapshotHandle != nil {
+			snapshotHandle = *volumeSnapshotContent.Status.SnapshotHandle
+		}
+		if pvcPVInfo, ok := backup.PVMap[volumeSnapshot.Namespace+"/"+*volumeSnapshot.Spec.Source.PersistentVolumeClaimName]; ok {
+			volumeInfo := volume.VolumeInfo{
+				BackupMethod:          volume.CSISnapshot,
+				PVCName:               pvcPVInfo.PVCName,
+				PVCNamespace:          pvcPVInfo.PVCNamespace,
+				PVName:                pvcPVInfo.PV.Name,
+				Skipped:               false,
+				SnapshotDataMoved:     false,
+				PreserveLocalSnapshot: true,
+				OperationID:           operation.Spec.OperationID,
+				StartTimestamp:        &volumeSnapshot.CreationTimestamp,
+				CSISnapshotInfo: volume.CSISnapshotInfo{
+					VSCName:        *volumeSnapshot.Status.BoundVolumeSnapshotContentName,
+					Size:           size,
+					Driver:         volumeSnapshotClass.Driver,
+					SnapshotHandle: snapshotHandle,
+				},
+				PVInfo: volume.PVInfo{
+					ReclaimPolicy: string(pvcPVInfo.PV.Spec.PersistentVolumeReclaimPolicy),
+					Labels:        pvcPVInfo.PV.Labels,
+				},
+			}
+
+			tmpVolumeInfos = append(tmpVolumeInfos, volumeInfo)
+		} else {
+			logger.Warnf("cannot find info for PVC %s/%s", volumeSnapshot.Namespace, volumeSnapshot.Spec.Source.PersistentVolumeClaimName)
+			continue
+		}
+	}
+
+	return tmpVolumeInfos
+}
+
+// generateVolumeInfoFromPVB generate VolumeInfo for PVB.
+func generateVolumeInfoFromPVB(backup *pkgbackup.Request, crClient kbclient.Client, logger logrus.FieldLogger) []volume.VolumeInfo {
+	tmpVolumeInfos := make([]volume.VolumeInfo, 0)
+
+	for _, pvb := range backup.PodVolumeBackups {
+		volumeInfo := volume.VolumeInfo{
+			BackupMethod:      volume.PodVolumeBackup,
+			SnapshotDataMoved: false,
+			Skipped:           false,
+			StartTimestamp:    pvb.Status.StartTimestamp,
+			PVBInfo: volume.PodVolumeBackupInfo{
+				SnapshotHandle: pvb.Status.SnapshotID,
+				Size:           pvb.Status.Progress.TotalBytes,
+				UploaderType:   pvb.Spec.UploaderType,
+				VolumeName:     pvb.Spec.Volume,
+				PodName:        pvb.Spec.Pod.Name,
+				PodNamespace:   pvb.Spec.Pod.Namespace,
+				NodeName:       pvb.Spec.Node,
+			},
+		}
+
+		pod := new(corev1api.Pod)
+		pvcName := ""
+		err := crClient.Get(context.TODO(), kbclient.ObjectKey{Namespace: pvb.Spec.Pod.Namespace, Name: pvb.Spec.Pod.Name}, pod)
+		if err != nil {
+			logger.WithError(err).Warn("Fail to get pod for PodVolumeBackup: ", pvb.Name)
+			continue
+		}
+		for _, volume := range pod.Spec.Volumes {
+			if volume.Name == pvb.Spec.Volume && volume.PersistentVolumeClaim != nil {
+				pvcName = volume.PersistentVolumeClaim.ClaimName
+			}
+		}
+
+		if pvcName != "" {
+			if pvcPVInfo, ok := backup.PVMap[pod.Namespace+"/"+pvcName]; ok {
+				volumeInfo.PVCName = pvcPVInfo.PVCName
+				volumeInfo.PVCNamespace = pvcPVInfo.PVCNamespace
+				volumeInfo.PVName = pvcPVInfo.PV.Name
+				volumeInfo.PVInfo = volume.PVInfo{
+					ReclaimPolicy: string(pvcPVInfo.PV.Spec.PersistentVolumeReclaimPolicy),
+					Labels:        pvcPVInfo.PV.Labels,
+				}
+			} else {
+				logger.Warnf("Cannot find info for PVC %s/%s", pod.Namespace, pvcName)
+				continue
+			}
+		} else {
+			logger.Debug("The PVB %s doesn't have a corresponding PVC", pvb.Name)
+		}
+
+		tmpVolumeInfos = append(tmpVolumeInfos, volumeInfo)
+	}
+
+	return tmpVolumeInfos
+}
+
+// generateVolumeInfoFromDataUpload generate VolumeInfo for DataUpload.
+func generateVolumeInfoFromDataUpload(backup *pkgbackup.Request, crClient kbclient.Client, logger logrus.FieldLogger) []volume.VolumeInfo {
+	tmpVolumeInfos := make([]volume.VolumeInfo, 0)
+	vsClassList := new(snapshotv1api.VolumeSnapshotClassList)
+	if err := crClient.List(context.TODO(), vsClassList); err != nil {
+		logger.WithError(err).Errorf("cannot list VolumeSnapshotClass %s", err.Error())
+		return tmpVolumeInfos
+	}
+
+	for _, operation := range *backup.GetItemOperationsList() {
+		if operation.Spec.ResourceIdentifier.GroupResource.String() == kuberesource.PersistentVolumeClaims.String() {
+			var duIdentifier velero.ResourceIdentifier
+
+			for _, identifier := range operation.Spec.PostOperationItems {
+				if identifier.GroupResource.String() == "datauploads.velero.io" {
+					duIdentifier = identifier
+				}
+			}
+			if duIdentifier.Empty() {
+				logger.Warnf("cannot find DataUpload for PVC %s/%s backup async operation",
+					operation.Spec.ResourceIdentifier.Namespace, operation.Spec.ResourceIdentifier.Name)
+				continue
+			}
+
+			dataUpload := new(velerov2alpha1.DataUpload)
+			err := crClient.Get(
+				context.TODO(),
+				kbclient.ObjectKey{
+					Namespace: duIdentifier.Namespace,
+					Name:      duIdentifier.Name},
+				dataUpload,
+			)
+			if err != nil {
+				logger.Warnf("fail to get DataUpload for operation %s: %s", operation.Spec.OperationID, err.Error())
+				continue
+			}
+
+			driverUsedByVSClass := ""
+			for index := range vsClassList.Items {
+				if vsClassList.Items[index].Name == dataUpload.Spec.CSISnapshot.SnapshotClass {
+					driverUsedByVSClass = vsClassList.Items[index].Driver
+				}
+			}
+
+			if pvcPVInfo, ok := backup.PVMap[operation.Spec.ResourceIdentifier.Namespace+"/"+operation.Spec.ResourceIdentifier.Name]; ok {
+				volumeInfo := volume.VolumeInfo{
+					BackupMethod:      volume.CSISnapshot,
+					PVCName:           pvcPVInfo.PVCName,
+					PVCNamespace:      pvcPVInfo.PVCNamespace,
+					PVName:            pvcPVInfo.PV.Name,
+					SnapshotDataMoved: true,
+					Skipped:           false,
+					OperationID:       operation.Spec.OperationID,
+					StartTimestamp:    operation.Status.Created,
+					CSISnapshotInfo: volume.CSISnapshotInfo{
+						Driver: driverUsedByVSClass,
+					},
+					SnapshotDataMovementInfo: volume.SnapshotDataMovementInfo{
+						DataMover:    dataUpload.Spec.DataMover,
+						UploaderType: "kopia",
+					},
+					PVInfo: volume.PVInfo{
+						ReclaimPolicy: string(pvcPVInfo.PV.Spec.PersistentVolumeReclaimPolicy),
+						Labels:        pvcPVInfo.PV.Labels,
+					},
+				}
+
+				tmpVolumeInfos = append(tmpVolumeInfos, volumeInfo)
+			} else {
+				logger.Warnf("Cannot find info for PVC %s/%s", operation.Spec.ResourceIdentifier.Namespace, operation.Spec.ResourceIdentifier.Name)
+				continue
+			}
+		}
+	}
+
+	return tmpVolumeInfos
+}

pkg/controller/backup_controller_test.go

@@ -29,15 +29,16 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	snapshotv1api "github.com/kubernetes-csi/external-snapshotter/client/v4/apis/volumesnapshot/v1"
-	snapshotfake "github.com/kubernetes-csi/external-snapshotter/client/v4/clientset/versioned/fake"
-	snapshotinformers "github.com/kubernetes-csi/external-snapshotter/client/v4/informers/externalversions"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
+	corev1api "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/version"
 	"k8s.io/utils/clock"
@@ -45,11 +46,14 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 
+	"github.com/vmware-tanzu/velero/pkg/backup"
 	kubeutil "github.com/vmware-tanzu/velero/pkg/util/kube"
+	"github.com/vmware-tanzu/velero/pkg/volume"
 
 	fakeClient "sigs.k8s.io/controller-runtime/pkg/client/fake"
 
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
+	velerov2alpha1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v2alpha1"
 	pkgbackup "github.com/vmware-tanzu/velero/pkg/backup"
 	"github.com/vmware-tanzu/velero/pkg/builder"
 	"github.com/vmware-tanzu/velero/pkg/discovery"
@@ -61,6 +65,7 @@ import (
 	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt"
 	"github.com/vmware-tanzu/velero/pkg/plugin/framework"
 	pluginmocks "github.com/vmware-tanzu/velero/pkg/plugin/mocks"
+	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
 	biav2 "github.com/vmware-tanzu/velero/pkg/plugin/velero/backupitemaction/v2"
 	velerotest "github.com/vmware-tanzu/velero/pkg/test"
 	"github.com/vmware-tanzu/velero/pkg/util/boolptr"
@@ -1062,12 +1067,11 @@ func TestProcessBackupCompletions(t *testing.T) {
 					CSIVolumeSnapshotsCompleted: 0,
 				},
 			},
-			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
+			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").VolumeSnapshotClass("testClass").Status().BoundVolumeSnapshotContentName("testVSC").RestoreSize("10G").SourcePVC("testPVC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
 		},
 		{
-			name:   "backup with snapshot data movement set to false when CSI feature is enabled",
-			backup: defaultBackup().SnapshotMoveData(false).Result(),
-			//backup:                   defaultBackup().Result(),
+			name:                     "backup with snapshot data movement set to false when CSI feature is enabled",
+			backup:                   defaultBackup().SnapshotMoveData(false).Result(),
 			backupLocation:           defaultBackupLocation,
 			defaultVolumesToFsBackup: false,
 			expectedResult: &velerov1api.Backup{
@@ -1103,7 +1107,7 @@ func TestProcessBackupCompletions(t *testing.T) {
 					CSIVolumeSnapshotsCompleted: 0,
 				},
 			},
-			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
+			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").VolumeSnapshotClass("testClass").Status().BoundVolumeSnapshotContentName("testVSC").RestoreSize("10G").SourcePVC("testPVC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
 		},
 		{
 			name:                     "backup with snapshot data movement not set when CSI feature is enabled",
@@ -1143,7 +1147,7 @@ func TestProcessBackupCompletions(t *testing.T) {
 					CSIVolumeSnapshotsCompleted: 0,
 				},
 			},
-			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
+			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").VolumeSnapshotClass("testClass").Status().BoundVolumeSnapshotContentName("testVSC").RestoreSize("10G").SourcePVC("testPVC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
 		},
 		{
 			name:                     "backup with snapshot data movement set to true and defaultSnapshotMoveData set to false",
@@ -1184,7 +1188,7 @@ func TestProcessBackupCompletions(t *testing.T) {
 					CSIVolumeSnapshotsCompleted: 0,
 				},
 			},
-			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
+			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").VolumeSnapshotClass("testClass").Status().BoundVolumeSnapshotContentName("testVSC").RestoreSize("10G").SourcePVC("testPVC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
 		},
 		{
 			name:                     "backup with snapshot data movement set to false and defaultSnapshotMoveData set to true",
@@ -1225,7 +1229,7 @@ func TestProcessBackupCompletions(t *testing.T) {
 					CSIVolumeSnapshotsCompleted: 0,
 				},
 			},
-			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
+			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").VolumeSnapshotClass("testClass").Status().BoundVolumeSnapshotContentName("testVSC").RestoreSize("10G").SourcePVC("testPVC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
 		},
 		{
 			name:                     "backup with snapshot data movement not set and defaultSnapshotMoveData set to true",
@@ -1266,35 +1270,43 @@ func TestProcessBackupCompletions(t *testing.T) {
 					CSIVolumeSnapshotsCompleted: 0,
 				},
 			},
-			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
+			volumeSnapshot: builder.ForVolumeSnapshot("velero", "testVS").VolumeSnapshotClass("testClass").Status().BoundVolumeSnapshotContentName("testVSC").RestoreSize("10G").SourcePVC("testPVC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).Result(),
 		},
 	}
 
+	snapshotHandle := "testSnapshotID"
+
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			formatFlag := logging.FormatText
 			var (
-				logger         = logging.DefaultLogger(logrus.DebugLevel, formatFlag)
-				pluginManager  = new(pluginmocks.Manager)
-				backupStore    = new(persistencemocks.BackupStore)
-				backupper      = new(fakeBackupper)
-				snapshotClient = snapshotfake.NewSimpleClientset()
-				sharedInformer = snapshotinformers.NewSharedInformerFactory(snapshotClient, 0)
-				snapshotLister = sharedInformer.Snapshot().V1().VolumeSnapshots().Lister()
+				logger           = logging.DefaultLogger(logrus.DebugLevel, formatFlag)
+				pluginManager    = new(pluginmocks.Manager)
+				backupStore      = new(persistencemocks.BackupStore)
+				backupper        = new(fakeBackupper)
+				fakeGlobalClient = velerotest.NewFakeControllerRuntimeClient(t)
 			)
 
 			var fakeClient kbclient.Client
 			// add the test's backup storage location if it's different than the default
 			if test.backupLocation != nil && test.backupLocation != defaultBackupLocation {
-				fakeClient = velerotest.NewFakeControllerRuntimeClient(t, test.backupLocation)
+				fakeClient = velerotest.NewFakeControllerRuntimeClient(t, test.backupLocation,
+					builder.ForVolumeSnapshotClass("testClass").Driver("testDriver").Result(),
+					builder.ForVolumeSnapshotContent("testVSC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).VolumeSnapshotClassName("testClass").Status(&snapshotv1api.VolumeSnapshotContentStatus{
+						SnapshotHandle: &snapshotHandle,
+					}).Result(),
+				)
 			} else {
-				fakeClient = velerotest.NewFakeControllerRuntimeClient(t)
+				fakeClient = velerotest.NewFakeControllerRuntimeClient(t,
+					builder.ForVolumeSnapshotClass("testClass").Driver("testDriver").Result(),
+					builder.ForVolumeSnapshotContent("testVSC").ObjectMeta(builder.WithLabels(velerov1api.BackupNameLabel, "backup-1")).VolumeSnapshotClassName("testClass").Status(&snapshotv1api.VolumeSnapshotContentStatus{
+						SnapshotHandle: &snapshotHandle,
+					}).Result(),
+				)
 			}
 
 			if test.volumeSnapshot != nil {
-				snapshotClient.SnapshotV1().VolumeSnapshots(test.volumeSnapshot.Namespace).Create(context.Background(), test.volumeSnapshot, metav1.CreateOptions{})
-				sharedInformer.Snapshot().V1().VolumeSnapshots().Informer().GetStore().Add(test.volumeSnapshot)
-				sharedInformer.WaitForCacheSync(make(chan struct{}))
+				require.NoError(t, fakeGlobalClient.Create(context.TODO(), test.volumeSnapshot))
 			}
 
 			apiServer := velerotest.NewAPIServer(t)
@@ -1328,8 +1340,7 @@ func TestProcessBackupCompletions(t *testing.T) {
 				backupStoreGetter:        NewFakeSingleObjectBackupStoreGetter(backupStore),
 				backupper:                backupper,
 				formatFlag:               formatFlag,
-				volumeSnapshotClient:     snapshotClient,
-				volumeSnapshotLister:     snapshotLister,
+				globalCRClient:           fakeGlobalClient,
 			}
 
 			pluginManager.On("GetBackupItemActionsV2").Return(nil, nil)
@@ -1731,3 +1742,749 @@ func TestPatchResourceWorksWithStatus(t *testing.T) {
 
 	}
 }
+func TestGenerateVolumeInfoForSkippedPV(t *testing.T) {
+	tests := []struct {
+		name                string
+		skippedPVName       string
+		pvMap               map[string]backup.PvcPvInfo
+		expectedVolumeInfos []volume.VolumeInfo
+	}{
+		{
+			name:                "Cannot find info for PV",
+			skippedPVName:       "testPV",
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name:          "Normal Skipped PV info",
+			skippedPVName: "testPV",
+			pvMap: map[string]backup.PvcPvInfo{
+				"velero/testPVC": {
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PV: corev1api.PersistentVolume{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:   "testPV",
+							Labels: map[string]string{"a": "b"},
+						},
+						Spec: corev1api.PersistentVolumeSpec{
+							PersistentVolumeReclaimPolicy: corev1api.PersistentVolumeReclaimDelete,
+						},
+					},
+				},
+				"testPV": {
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PV: corev1api.PersistentVolume{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:   "testPV",
+							Labels: map[string]string{"a": "b"},
+						},
+						Spec: corev1api.PersistentVolumeSpec{
+							PersistentVolumeReclaimPolicy: corev1api.PersistentVolumeReclaimDelete,
+						},
+					},
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{
+				{
+					PVCName:       "testPVC",
+					PVCNamespace:  "velero",
+					PVName:        "testPV",
+					Skipped:       true,
+					SkippedReason: "CSI: skipped for PodVolumeBackup;",
+					PVInfo: volume.PVInfo{
+						ReclaimPolicy: "Delete",
+						Labels: map[string]string{
+							"a": "b",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			request := new(backup.Request)
+			request.SkippedPVTracker = backup.NewSkipPVTracker()
+			if tc.skippedPVName != "" {
+				request.SkippedPVTracker.Track(tc.skippedPVName, "CSI", "skipped for PodVolumeBackup")
+			}
+			if tc.pvMap != nil {
+				request.PVMap = tc.pvMap
+			}
+			logger := logging.DefaultLogger(logrus.DebugLevel, logging.FormatJSON)
+
+			volumeInfos := generateVolumeInfoForSkippedPV(request, logger)
+			require.Equal(t, tc.expectedVolumeInfos, volumeInfos)
+		})
+	}
+}
+
+func TestGenerateVolumeInfoForCSIVolumeSnapshot(t *testing.T) {
+	resourceQuantity := resource.MustParse("100Gi")
+	now := metav1.Now()
+	tests := []struct {
+		name                  string
+		volumeSnapshot        snapshotv1api.VolumeSnapshot
+		volumeSnapshotContent snapshotv1api.VolumeSnapshotContent
+		volumeSnapshotClass   snapshotv1api.VolumeSnapshotClass
+		pvMap                 map[string]backup.PvcPvInfo
+		operation             *itemoperation.BackupOperation
+		expectedVolumeInfos   []volume.VolumeInfo
+	}{
+		{
+			name: "VS doesn't have VolumeSnapshotClass name",
+			volumeSnapshot: snapshotv1api.VolumeSnapshot{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "testVS",
+					Namespace: "velero",
+				},
+				Spec: snapshotv1api.VolumeSnapshotSpec{},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "VS doesn't have status",
+			volumeSnapshot: snapshotv1api.VolumeSnapshot{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "testVS",
+					Namespace: "velero",
+				},
+				Spec: snapshotv1api.VolumeSnapshotSpec{
+					VolumeSnapshotClassName: stringPtr("testClass"),
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "VS doesn't have PVC",
+			volumeSnapshot: snapshotv1api.VolumeSnapshot{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "testVS",
+					Namespace: "velero",
+				},
+				Spec: snapshotv1api.VolumeSnapshotSpec{
+					VolumeSnapshotClassName: stringPtr("testClass"),
+				},
+				Status: &snapshotv1api.VolumeSnapshotStatus{
+					BoundVolumeSnapshotContentName: stringPtr("testContent"),
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "Cannot find VSC for VS",
+			volumeSnapshot: snapshotv1api.VolumeSnapshot{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "testVS",
+					Namespace: "velero",
+				},
+				Spec: snapshotv1api.VolumeSnapshotSpec{
+					VolumeSnapshotClassName: stringPtr("testClass"),
+					Source: snapshotv1api.VolumeSnapshotSource{
+						PersistentVolumeClaimName: stringPtr("testPVC"),
+					},
+				},
+				Status: &snapshotv1api.VolumeSnapshotStatus{
+					BoundVolumeSnapshotContentName: stringPtr("testContent"),
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "Cannot find VolumeInfo for PVC",
+			volumeSnapshot: snapshotv1api.VolumeSnapshot{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "testVS",
+					Namespace: "velero",
+				},
+				Spec: snapshotv1api.VolumeSnapshotSpec{
+					VolumeSnapshotClassName: stringPtr("testClass"),
+					Source: snapshotv1api.VolumeSnapshotSource{
+						PersistentVolumeClaimName: stringPtr("testPVC"),
+					},
+				},
+				Status: &snapshotv1api.VolumeSnapshotStatus{
+					BoundVolumeSnapshotContentName: stringPtr("testContent"),
+				},
+			},
+			volumeSnapshotClass:   *builder.ForVolumeSnapshotClass("testClass").Driver("pd.csi.storage.gke.io").Result(),
+			volumeSnapshotContent: *builder.ForVolumeSnapshotContent("testContent").Status(&snapshotv1api.VolumeSnapshotContentStatus{SnapshotHandle: stringPtr("testSnapshotHandle")}).Result(),
+			expectedVolumeInfos:   []volume.VolumeInfo{},
+		},
+		{
+			name: "Normal VolumeSnapshot case",
+			volumeSnapshot: snapshotv1api.VolumeSnapshot{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "testVS",
+					Namespace:         "velero",
+					CreationTimestamp: now,
+				},
+				Spec: snapshotv1api.VolumeSnapshotSpec{
+					VolumeSnapshotClassName: stringPtr("testClass"),
+					Source: snapshotv1api.VolumeSnapshotSource{
+						PersistentVolumeClaimName: stringPtr("testPVC"),
+					},
+				},
+				Status: &snapshotv1api.VolumeSnapshotStatus{
+					BoundVolumeSnapshotContentName: stringPtr("testContent"),
+					RestoreSize:                    &resourceQuantity,
+				},
+			},
+			volumeSnapshotClass:   *builder.ForVolumeSnapshotClass("testClass").Driver("pd.csi.storage.gke.io").Result(),
+			volumeSnapshotContent: *builder.ForVolumeSnapshotContent("testContent").Status(&snapshotv1api.VolumeSnapshotContentStatus{SnapshotHandle: stringPtr("testSnapshotHandle")}).Result(),
+			pvMap: map[string]backup.PvcPvInfo{
+				"velero/testPVC": {
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PV: corev1api.PersistentVolume{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:   "testPV",
+							Labels: map[string]string{"a": "b"},
+						},
+						Spec: corev1api.PersistentVolumeSpec{
+							PersistentVolumeReclaimPolicy: corev1api.PersistentVolumeReclaimDelete,
+						},
+					},
+				},
+			},
+			operation: &itemoperation.BackupOperation{
+				Spec: itemoperation.BackupOperationSpec{
+					OperationID: "testID",
+					ResourceIdentifier: velero.ResourceIdentifier{
+						GroupResource: schema.GroupResource{
+							Group:    "snapshot.storage.k8s.io",
+							Resource: "volumesnapshots",
+						},
+						Namespace: "velero",
+						Name:      "testVS",
+					},
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{
+				{
+					PVCName:               "testPVC",
+					PVCNamespace:          "velero",
+					PVName:                "testPV",
+					BackupMethod:          volume.CSISnapshot,
+					OperationID:           "testID",
+					StartTimestamp:        &now,
+					PreserveLocalSnapshot: true,
+					CSISnapshotInfo: volume.CSISnapshotInfo{
+						Driver:         "pd.csi.storage.gke.io",
+						SnapshotHandle: "testSnapshotHandle",
+						Size:           107374182400,
+						VSCName:        "testContent",
+					},
+					PVInfo: volume.PVInfo{
+						ReclaimPolicy: "Delete",
+						Labels: map[string]string{
+							"a": "b",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			request := new(backup.Request)
+			request.Backup = new(velerov1api.Backup)
+			if tc.pvMap != nil {
+				request.PVMap = tc.pvMap
+			}
+			operationList := request.GetItemOperationsList()
+			if tc.operation != nil {
+				*operationList = append(*operationList, tc.operation)
+			}
+			logger := logging.DefaultLogger(logrus.DebugLevel, logging.FormatJSON)
+
+			volumeInfos := generateVolumeInfoForCSIVolumeSnapshot(request, []snapshotv1api.VolumeSnapshot{tc.volumeSnapshot}, []snapshotv1api.VolumeSnapshotContent{tc.volumeSnapshotContent}, []snapshotv1api.VolumeSnapshotClass{tc.volumeSnapshotClass}, logger)
+			require.Equal(t, tc.expectedVolumeInfos, volumeInfos)
+		})
+	}
+
+}
+
+func TestGenerateVolumeInfoForVeleroNativeSnapshot(t *testing.T) {
+	tests := []struct {
+		name                string
+		nativeSnapshot      volume.Snapshot
+		pvMap               map[string]backup.PvcPvInfo
+		expectedVolumeInfos []volume.VolumeInfo
+	}{
+		{
+			name: "Native snapshot's IPOS pointer is nil",
+			nativeSnapshot: volume.Snapshot{
+				Spec: volume.SnapshotSpec{
+					PersistentVolumeName: "testPV",
+					VolumeIOPS:           nil,
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "Cannot find info for the PV",
+			nativeSnapshot: volume.Snapshot{
+				Spec: volume.SnapshotSpec{
+					PersistentVolumeName: "testPV",
+					VolumeIOPS:           int64Ptr(100),
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "Normal native snapshot",
+			pvMap: map[string]backup.PvcPvInfo{
+				"testPV": {
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PV: corev1api.PersistentVolume{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:   "testPV",
+							Labels: map[string]string{"a": "b"},
+						},
+						Spec: corev1api.PersistentVolumeSpec{
+							PersistentVolumeReclaimPolicy: corev1api.PersistentVolumeReclaimDelete,
+						},
+					},
+				},
+			},
+			nativeSnapshot: volume.Snapshot{
+				Spec: volume.SnapshotSpec{
+					PersistentVolumeName: "testPV",
+					VolumeIOPS:           int64Ptr(100),
+					VolumeType:           "ssd",
+					VolumeAZ:             "us-central1-a",
+				},
+				Status: volume.SnapshotStatus{
+					ProviderSnapshotID: "pvc-b31e3386-4bbb-4937-95d-7934cd62-b0a1-494b-95d7-0687440e8d0c",
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{
+				{
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PVName:       "testPV",
+					BackupMethod: volume.NativeSnapshot,
+					PVInfo: volume.PVInfo{
+						ReclaimPolicy: "Delete",
+						Labels: map[string]string{
+							"a": "b",
+						},
+					},
+					NativeSnapshotInfo: volume.NativeSnapshotInfo{
+						SnapshotHandle: "pvc-b31e3386-4bbb-4937-95d-7934cd62-b0a1-494b-95d7-0687440e8d0c",
+						VolumeType:     "ssd",
+						VolumeAZ:       "us-central1-a",
+						IOPS:           "100",
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			request := new(backup.Request)
+			request.VolumeSnapshots = append(request.VolumeSnapshots, &tc.nativeSnapshot)
+			if tc.pvMap != nil {
+				request.PVMap = tc.pvMap
+			}
+			logger := logging.DefaultLogger(logrus.DebugLevel, logging.FormatJSON)
+
+			volumeInfos := generateVolumeInfoForVeleroNativeSnapshot(request, logger)
+			require.Equal(t, tc.expectedVolumeInfos, volumeInfos)
+		})
+	}
+}
+
+func TestGenerateVolumeInfoFromPVB(t *testing.T) {
+	tests := []struct {
+		name                string
+		pvb                 *velerov1api.PodVolumeBackup
+		pod                 *corev1api.Pod
+		pvMap               map[string]backup.PvcPvInfo
+		expectedVolumeInfos []volume.VolumeInfo
+	}{
+		{
+			name:                "cannot find PVB's pod, should fail",
+			pvb:                 builder.ForPodVolumeBackup("velero", "testPVB").PodName("testPod").PodNamespace("velero").Result(),
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "PVB doesn't have a related PVC",
+			pvb:  builder.ForPodVolumeBackup("velero", "testPVB").PodName("testPod").PodNamespace("velero").Result(),
+			pod: builder.ForPod("velero", "testPod").Containers(&corev1api.Container{
+				Name: "test",
+				VolumeMounts: []corev1api.VolumeMount{
+					{
+						Name:      "testVolume",
+						MountPath: "/data",
+					},
+				},
+			}).Volumes(
+				&corev1api.Volume{
+					Name: "",
+					VolumeSource: corev1api.VolumeSource{
+						HostPath: &corev1api.HostPathVolumeSource{},
+					},
+				},
+			).Result(),
+			expectedVolumeInfos: []volume.VolumeInfo{
+				{
+					PVCName:      "",
+					PVCNamespace: "",
+					PVName:       "",
+					BackupMethod: volume.PodVolumeBackup,
+					PVBInfo: volume.PodVolumeBackupInfo{
+						PodName:      "testPod",
+						PodNamespace: "velero",
+					},
+				},
+			},
+		},
+		{
+			name: "Backup doesn't have information for PVC",
+			pvb:  builder.ForPodVolumeBackup("velero", "testPVB").PodName("testPod").PodNamespace("velero").Result(),
+			pod: builder.ForPod("velero", "testPod").Containers(&corev1api.Container{
+				Name: "test",
+				VolumeMounts: []corev1api.VolumeMount{
+					{
+						Name:      "testVolume",
+						MountPath: "/data",
+					},
+				},
+			}).Volumes(
+				&corev1api.Volume{
+					Name: "",
+					VolumeSource: corev1api.VolumeSource{
+						PersistentVolumeClaim: &corev1api.PersistentVolumeClaimVolumeSource{
+							ClaimName: "testPVC",
+						},
+					},
+				},
+			).Result(),
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "PVB's volume has a PVC",
+			pvMap: map[string]backup.PvcPvInfo{
+				"velero/testPVC": {
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PV: corev1api.PersistentVolume{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:   "testPV",
+							Labels: map[string]string{"a": "b"},
+						},
+						Spec: corev1api.PersistentVolumeSpec{
+							PersistentVolumeReclaimPolicy: corev1api.PersistentVolumeReclaimDelete,
+						},
+					},
+				},
+			},
+			pvb: builder.ForPodVolumeBackup("velero", "testPVB").PodName("testPod").PodNamespace("velero").Result(),
+			pod: builder.ForPod("velero", "testPod").Containers(&corev1api.Container{
+				Name: "test",
+				VolumeMounts: []corev1api.VolumeMount{
+					{
+						Name:      "testVolume",
+						MountPath: "/data",
+					},
+				},
+			}).Volumes(
+				&corev1api.Volume{
+					Name: "",
+					VolumeSource: corev1api.VolumeSource{
+						PersistentVolumeClaim: &corev1api.PersistentVolumeClaimVolumeSource{
+							ClaimName: "testPVC",
+						},
+					},
+				},
+			).Result(),
+			expectedVolumeInfos: []volume.VolumeInfo{
+				{
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PVName:       "testPV",
+					BackupMethod: volume.PodVolumeBackup,
+					PVBInfo: volume.PodVolumeBackupInfo{
+						PodName:      "testPod",
+						PodNamespace: "velero",
+					},
+					PVInfo: volume.PVInfo{
+						ReclaimPolicy: string(corev1api.PersistentVolumeReclaimDelete),
+						Labels:        map[string]string{"a": "b"},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			crClient := velerotest.NewFakeControllerRuntimeClient(t)
+			logger := logging.DefaultLogger(logrus.DebugLevel, logging.FormatJSON)
+			request := new(pkgbackup.Request)
+			request.PodVolumeBackups = append(request.PodVolumeBackups, tc.pvb)
+			if tc.pvMap != nil {
+				request.PVMap = tc.pvMap
+			}
+			if tc.pod != nil {
+				require.NoError(t, crClient.Create(context.TODO(), tc.pod))
+			}
+
+			volumeInfos := generateVolumeInfoFromPVB(request, crClient, logger)
+			require.Equal(t, tc.expectedVolumeInfos, volumeInfos)
+		})
+	}
+}
+
+func TestGenerateVolumeInfoFromDataUpload(t *testing.T) {
+	now := metav1.Now()
+	tests := []struct {
+		name                string
+		volumeSnapshotClass *snapshotv1api.VolumeSnapshotClass
+		dataUpload          *velerov2alpha1.DataUpload
+		operation           *itemoperation.BackupOperation
+		pvMap               map[string]backup.PvcPvInfo
+		expectedVolumeInfos []volume.VolumeInfo
+	}{
+		{
+			name: "Operation is not for PVC",
+			operation: &itemoperation.BackupOperation{
+				Spec: itemoperation.BackupOperationSpec{
+					ResourceIdentifier: velero.ResourceIdentifier{
+						GroupResource: schema.GroupResource{
+							Group:    "",
+							Resource: "configmaps",
+						},
+					},
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "Operation doesn't have DataUpload PostItemOperation",
+			operation: &itemoperation.BackupOperation{
+				Spec: itemoperation.BackupOperationSpec{
+					ResourceIdentifier: velero.ResourceIdentifier{
+						GroupResource: schema.GroupResource{
+							Group:    "",
+							Resource: "persistentvolumeclaims",
+						},
+						Namespace: "velero",
+						Name:      "testPVC",
+					},
+					PostOperationItems: []velero.ResourceIdentifier{
+						{
+							GroupResource: schema.GroupResource{
+								Group:    "",
+								Resource: "configmaps",
+							},
+						},
+					},
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "DataUpload cannot be found for operation",
+			operation: &itemoperation.BackupOperation{
+				Spec: itemoperation.BackupOperationSpec{
+					OperationID: "testOperation",
+					ResourceIdentifier: velero.ResourceIdentifier{
+						GroupResource: schema.GroupResource{
+							Group:    "",
+							Resource: "persistentvolumeclaims",
+						},
+						Namespace: "velero",
+						Name:      "testPVC",
+					},
+					PostOperationItems: []velero.ResourceIdentifier{
+						{
+							GroupResource: schema.GroupResource{
+								Group:    "velero.io",
+								Resource: "datauploads",
+							},
+							Namespace: "velero",
+							Name:      "testDU",
+						},
+					},
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{},
+		},
+		{
+			name: "VolumeSnapshotClass cannot be found for operation",
+			dataUpload: builder.ForDataUpload("velero", "testDU").DataMover("velero").CSISnapshot(&velerov2alpha1.CSISnapshotSpec{
+				VolumeSnapshot: "testVS",
+			}).SnapshotID("testSnapshotHandle").Result(),
+			operation: &itemoperation.BackupOperation{
+				Spec: itemoperation.BackupOperationSpec{
+					OperationID: "testOperation",
+					ResourceIdentifier: velero.ResourceIdentifier{
+						GroupResource: schema.GroupResource{
+							Group:    "",
+							Resource: "persistentvolumeclaims",
+						},
+						Namespace: "velero",
+						Name:      "testPVC",
+					},
+					PostOperationItems: []velero.ResourceIdentifier{
+						{
+							GroupResource: schema.GroupResource{
+								Group:    "velero.io",
+								Resource: "datauploads",
+							},
+							Namespace: "velero",
+							Name:      "testDU",
+						},
+					},
+				},
+			},
+			pvMap: map[string]backup.PvcPvInfo{
+				"velero/testPVC": {
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PV: corev1api.PersistentVolume{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:   "testPV",
+							Labels: map[string]string{"a": "b"},
+						},
+						Spec: corev1api.PersistentVolumeSpec{
+							PersistentVolumeReclaimPolicy: corev1api.PersistentVolumeReclaimDelete,
+						},
+					},
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{
+				{
+					PVCName:           "testPVC",
+					PVCNamespace:      "velero",
+					PVName:            "testPV",
+					BackupMethod:      volume.CSISnapshot,
+					SnapshotDataMoved: true,
+					OperationID:       "testOperation",
+					SnapshotDataMovementInfo: volume.SnapshotDataMovementInfo{
+						DataMover:    "velero",
+						UploaderType: "kopia",
+					},
+					PVInfo: volume.PVInfo{
+						ReclaimPolicy: string(corev1api.PersistentVolumeReclaimDelete),
+						Labels:        map[string]string{"a": "b"},
+					},
+				},
+			},
+		},
+		{
+			name: "Normal DataUpload case",
+			dataUpload: builder.ForDataUpload("velero", "testDU").DataMover("velero").CSISnapshot(&velerov2alpha1.CSISnapshotSpec{
+				VolumeSnapshot: "testVS",
+				SnapshotClass:  "testClass",
+			}).SnapshotID("testSnapshotHandle").Result(),
+			volumeSnapshotClass: builder.ForVolumeSnapshotClass("testClass").Driver("pd.csi.storage.gke.io").Result(),
+			operation: &itemoperation.BackupOperation{
+				Spec: itemoperation.BackupOperationSpec{
+					OperationID: "testOperation",
+					ResourceIdentifier: velero.ResourceIdentifier{
+						GroupResource: schema.GroupResource{
+							Group:    "",
+							Resource: "persistentvolumeclaims",
+						},
+						Namespace: "velero",
+						Name:      "testPVC",
+					},
+					PostOperationItems: []velero.ResourceIdentifier{
+						{
+							GroupResource: schema.GroupResource{
+								Group:    "velero.io",
+								Resource: "datauploads",
+							},
+							Namespace: "velero",
+							Name:      "testDU",
+						},
+					},
+				},
+				Status: itemoperation.OperationStatus{
+					Created: &now,
+				},
+			},
+			pvMap: map[string]backup.PvcPvInfo{
+				"velero/testPVC": {
+					PVCName:      "testPVC",
+					PVCNamespace: "velero",
+					PV: corev1api.PersistentVolume{
+						ObjectMeta: metav1.ObjectMeta{
+							Name:   "testPV",
+							Labels: map[string]string{"a": "b"},
+						},
+						Spec: corev1api.PersistentVolumeSpec{
+							PersistentVolumeReclaimPolicy: corev1api.PersistentVolumeReclaimDelete,
+						},
+					},
+				},
+			},
+			expectedVolumeInfos: []volume.VolumeInfo{
+				{
+					PVCName:           "testPVC",
+					PVCNamespace:      "velero",
+					PVName:            "testPV",
+					BackupMethod:      volume.CSISnapshot,
+					SnapshotDataMoved: true,
+					OperationID:       "testOperation",
+					StartTimestamp:    &now,
+					CSISnapshotInfo: volume.CSISnapshotInfo{
+						Driver: "pd.csi.storage.gke.io",
+					},
+					SnapshotDataMovementInfo: volume.SnapshotDataMovementInfo{
+						DataMover:    "velero",
+						UploaderType: "kopia",
+					},
+					PVInfo: volume.PVInfo{
+						ReclaimPolicy: string(corev1api.PersistentVolumeReclaimDelete),
+						Labels:        map[string]string{"a": "b"},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			request := new(backup.Request)
+			operationList := request.GetItemOperationsList()
+			if tc.operation != nil {
+				*operationList = append(*operationList, tc.operation)
+			}
+			if tc.pvMap != nil {
+				request.PVMap = tc.pvMap
+			}
+			logger := logging.DefaultLogger(logrus.DebugLevel, logging.FormatJSON)
+
+			crClient := velerotest.NewFakeControllerRuntimeClient(t)
+			if tc.dataUpload != nil {
+				crClient.Create(context.TODO(), tc.dataUpload)
+			}
+
+			if tc.volumeSnapshotClass != nil {
+				crClient.Create(context.TODO(), tc.volumeSnapshotClass)
+			}
+
+			volumeInfos := generateVolumeInfoFromDataUpload(request, crClient, logger)
+			require.Equal(t, tc.expectedVolumeInfos, volumeInfos)
+		})
+	}
+}
+
+func int64Ptr(val int) *int64 {
+	i := int64(val)
+	return &i
+}
+
+func stringPtr(str string) *string {
+	return &str
+}

pkg/controller/backup_finalizer_controller.go

@@ -29,8 +29,6 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 
-	snapshotv1listers "github.com/kubernetes-csi/external-snapshotter/client/v4/listers/volumesnapshot/v1"
-
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	pkgbackup "github.com/vmware-tanzu/velero/pkg/backup"
 	"github.com/vmware-tanzu/velero/pkg/metrics"
@@ -42,21 +40,21 @@ import (
 
 // backupFinalizerReconciler reconciles a Backup object
 type backupFinalizerReconciler struct {
-	client               kbclient.Client
-	volumeSnapshotLister snapshotv1listers.VolumeSnapshotLister
-	clock                clocks.WithTickerAndDelayedExecution
-	backupper            pkgbackup.Backupper
-	newPluginManager     func(logrus.FieldLogger) clientmgmt.Manager
-	backupTracker        BackupTracker
-	metrics              *metrics.ServerMetrics
-	backupStoreGetter    persistence.ObjectBackupStoreGetter
-	log                  logrus.FieldLogger
+	client            kbclient.Client
+	globalCRClient    kbclient.Client
+	clock             clocks.WithTickerAndDelayedExecution
+	backupper         pkgbackup.Backupper
+	newPluginManager  func(logrus.FieldLogger) clientmgmt.Manager
+	backupTracker     BackupTracker
+	metrics           *metrics.ServerMetrics
+	backupStoreGetter persistence.ObjectBackupStoreGetter
+	log               logrus.FieldLogger
 }
 
 // NewBackupFinalizerReconciler initializes and returns backupFinalizerReconciler struct.
 func NewBackupFinalizerReconciler(
 	client kbclient.Client,
-	volumeSnapshotLister snapshotv1listers.VolumeSnapshotLister,
+	globalCRClient kbclient.Client,
 	clock clocks.WithTickerAndDelayedExecution,
 	backupper pkgbackup.Backupper,
 	newPluginManager func(logrus.FieldLogger) clientmgmt.Manager,
@@ -67,6 +65,7 @@ func NewBackupFinalizerReconciler(
 ) *backupFinalizerReconciler {
 	return &backupFinalizerReconciler{
 		client:            client,
+		globalCRClient:    globalCRClient,
 		clock:             clock,
 		backupper:         backupper,
 		newPluginManager:  newPluginManager,
@@ -191,7 +190,7 @@ func (r *backupFinalizerReconciler) Reconcile(ctx context.Context, req ctrl.Requ
 	backup.Status.CompletionTimestamp = &metav1.Time{Time: r.clock.Now()}
 	recordBackupMetrics(log, backup, outBackupFile, r.metrics, true)
 
-	pkgbackup.UpdateBackupCSISnapshotsStatus(r.client, r.volumeSnapshotLister, backup, log)
+	pkgbackup.UpdateBackupCSISnapshotsStatus(r.client, r.globalCRClient, backup, log)
 	// update backup metadata in object store
 	backupJSON := new(bytes.Buffer)
 	if err := encode.To(backup, "json", backupJSON); err != nil {

pkg/controller/backup_finalizer_controller_test.go

@@ -23,7 +23,6 @@ import (
 	"testing"
 	"time"
 
-	snapshotv1listers "github.com/kubernetes-csi/external-snapshotter/client/v4/listers/volumesnapshot/v1"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
@@ -44,14 +43,13 @@ import (
 	"github.com/vmware-tanzu/velero/pkg/plugin/framework"
 	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
 	velerotest "github.com/vmware-tanzu/velero/pkg/test"
-	velerotestmocks "github.com/vmware-tanzu/velero/pkg/test/mocks"
 )
 
-func mockBackupFinalizerReconciler(fakeClient kbclient.Client, fakeVolumeSnapshotLister snapshotv1listers.VolumeSnapshotLister, fakeClock *testclocks.FakeClock) (*backupFinalizerReconciler, *fakeBackupper) {
+func mockBackupFinalizerReconciler(fakeClient kbclient.Client, fakeGlobalClient kbclient.Client, fakeClock *testclocks.FakeClock) (*backupFinalizerReconciler, *fakeBackupper) {
 	backupper := new(fakeBackupper)
 	return NewBackupFinalizerReconciler(
 		fakeClient,
-		fakeVolumeSnapshotLister,
+		fakeGlobalClient,
 		fakeClock,
 		backupper,
 		func(logrus.FieldLogger) clientmgmt.Manager { return pluginManager },
@@ -164,9 +162,9 @@ func TestBackupFinalizerReconcile(t *testing.T) {
 
 			fakeClient := velerotest.NewFakeControllerRuntimeClient(t, initObjs...)
 
-			fakeVolumeSnapshotLister := velerotestmocks.NewVolumeSnapshotLister(t)
+			fakeGlobalClient := velerotest.NewFakeControllerRuntimeClient(t, initObjs...)
 
-			reconciler, backupper := mockBackupFinalizerReconciler(fakeClient, fakeVolumeSnapshotLister, fakeClock)
+			reconciler, backupper := mockBackupFinalizerReconciler(fakeClient, fakeGlobalClient, fakeClock)
 			pluginManager.On("CleanupClients").Return(nil)
 			backupStore.On("GetBackupItemOperations", test.backup.Name).Return(test.backupOperations, nil)
 			backupStore.On("GetBackupContents", mock.Anything).Return(io.NopCloser(bytes.NewReader([]byte("hello world"))), nil)