diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h
index 7315efd2a009550e9fce5531d8d6c374b42cb81e..180ab34c1451915fb247634f1fa88c2073815dfc 100644
--- a/frameworks/native/backup_ext/include/ext_extension.h
+++ b/frameworks/native/backup_ext/include/ext_extension.h
@@ -48,7 +48,7 @@ public:
     ErrCode PublishFile(const std::string &fileName) override;
     ErrCode HandleBackup(bool isClearData) override;
     ErrCode HandleRestore(bool isClearData) override;
-    ErrCode GetIncrementalFileHandle(const std::string &fileName) override;
+    std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncrementalFileHandle(const std::string &fileName) override;
     ErrCode PublishIncrementalFile(const std::string &fileName) override;
     ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) override;
     ErrCode IncrementalOnBackup(bool isClearData) override;
@@ -286,7 +286,7 @@ private:
 
     std::function<void(std::string, int)> ReportErrFileByProc(wptr<BackupExtExtension> obj,
         BackupRestoreScenario scenario);
-    ErrCode GetIncreFileHandleForNormalVersion(const std::string &fileName);
+    std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncreFileHandleForNormalVersion(const std::string &fileName);
     void RestoreOneBigFile(const std::string &path, const ExtManageInfo &item, const bool appendTargetPath);
     int DealIncreRestoreBigAndTarFile();
     ErrCode IncrementalTarFileReady(const TarMap &bigFileInfo, const vector<struct ReportFileInfo> &srcFiles,
diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp
index f92dbab7c8c4060c65aede57daff9306409fdac4..06f768f6baf3629c7f6d09ac31de5f5eec6b9242 100644
--- a/frameworks/native/backup_ext/src/ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/ext_extension.cpp
@@ -293,7 +293,7 @@ static string GetReportFileName(const string &fileName)
     return reportName;
 }
 
-static ErrCode GetIncreFileHandleForSpecialVersion(const string &fileName)
+static tuple<ErrCode, UniqueFd, UniqueFd> GetIncreFileHandleForSpecialVersion(const string &fileName)
 {
     ErrCode errCode = ERR_OK;
     UniqueFd fd = GetFileHandleForSpecialCloneCloud(fileName);
@@ -319,17 +319,7 @@ static ErrCode GetIncreFileHandleForSpecialVersion(const string &fileName)
         HILOGE("Failed to open report file = %{private}s, err = %{public}d", reportName.c_str(), errno);
         errCode = errno;
     }
-
-    auto proxy = ServiceProxy::GetInstance();
-    if (proxy == nullptr) {
-        HILOGE("Failed to get file handle for special version clone");
-        return BError(BError::Codes::EXT_BROKEN_BACKUP_SA).GetCode();
-    }
-    auto ret = proxy->AppIncrementalFileReady(fileName, move(fd), move(reportFd), errCode);
-    if (ret != ERR_OK) {
-        HILOGE("Failed to AppIncrementalFileReady %{public}d", ret);
-    }
-    return ERR_OK;
+    return {errCode, move(fd), move(reportFd)};
 }
 
 static ErrCode GetIncrementalFileHandlePath(const string &fileName, const string &bundleName, std::string &tarName)
@@ -354,13 +344,9 @@ static ErrCode GetIncrementalFileHandlePath(const string &fileName, const string
     return ERR_OK;
 }
 
-ErrCode BackupExtExtension::GetIncreFileHandleForNormalVersion(const std::string &fileName)
+tuple<ErrCode, UniqueFd, UniqueFd> BackupExtExtension::GetIncreFileHandleForNormalVersion(const std::string &fileName)
 {
     HILOGI("extension: GetIncrementalFileHandle single to single Name:%{public}s", GetAnonyPath(fileName).c_str());
-    auto proxy = ServiceProxy::GetInstance();
-    if (proxy == nullptr) {
-        throw BError(BError::Codes::EXT_BROKEN_IPC, string("Failed to AGetInstance"));
-    }
     std::string tarName;
     int32_t errCode = ERR_OK;
     UniqueFd fd(-1);
@@ -396,15 +382,10 @@ ErrCode BackupExtExtension::GetIncreFileHandleForNormalVersion(const std::string
             break;
         }
     } while (0);
-    HILOGI("extension: Will notify AppIncrementalFileReady");
-    auto ret = proxy->AppIncrementalFileReady(fileName, move(fd), move(reportFd), errCode);
-    if (ret != ERR_OK) {
-        HILOGE("Failed to AppIncrementalFileReady %{public}d", ret);
-    }
-    return ERR_OK;
+    return {errCode, move(fd), move(reportFd)};
 }
 
-ErrCode BackupExtExtension::GetIncrementalFileHandle(const string &fileName)
+tuple<ErrCode, UniqueFd, UniqueFd> BackupExtExtension::GetIncrementalFileHandle(const string &fileName)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     try {
@@ -428,7 +409,7 @@ ErrCode BackupExtExtension::GetIncrementalFileHandle(const string &fileName)
             if (ret != ERR_OK) {
                 HILOGE("Failed to notify app incre done. err = %{public}d", ret);
             }
-            return BError(BError::Codes::EXT_INVAL_ARG).GetCode();
+            return {BError(BError::Codes::EXT_INVAL_ARG).GetCode(), UniqueFd(-1), UniqueFd(-1)};
         }
         if (extension_->SpecialVersionForCloneAndCloud()) {
             return GetIncreFileHandleForSpecialVersion(fileName);
@@ -437,7 +418,7 @@ ErrCode BackupExtExtension::GetIncrementalFileHandle(const string &fileName)
     } catch (...) {
         HILOGE("Failed to get incremental file handle");
         DoClear();
-        return BError(BError::Codes::EXT_BROKEN_IPC).GetCode();
+        return {BError(BError::Codes::EXT_BROKEN_IPC).GetCode(), UniqueFd(-1), UniqueFd(-1)};
     }
 }
 
diff --git a/frameworks/native/backup_ext/src/ext_extension_stub.cpp b/frameworks/native/backup_ext/src/ext_extension_stub.cpp
index 9e7b43539084af27b2601d54a57ab45be298fd74..38f4ce2f3ab78ed7ead69c0f9d03c0349387178a 100644
--- a/frameworks/native/backup_ext/src/ext_extension_stub.cpp
+++ b/frameworks/native/backup_ext/src/ext_extension_stub.cpp
@@ -155,8 +155,14 @@ ErrCode ExtExtensionStub::CmdGetIncrementalFileHandle(MessageParcel &data, Messa
         return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName").GetCode();
     }
 
-    ErrCode res = GetIncrementalFileHandle(fileName);
-    if (!reply.WriteInt32(res)) {
+    auto[errCode, fd, reportFd] = GetIncrementalFileHandle(fileName);
+    if (!reply.WriteInt32(errCode)) {
+        return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode();
+    }
+    if (!reply.WriteFileDescriptor(fd)) {
+        return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode();
+    }
+    if (!reply.WriteFileDescriptor(reportFd)) {
         return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode();
     }
     return BError(BError::Codes::OK);
diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/i_extension.h b/interfaces/inner_api/native/backup_kit_inner/impl/i_extension.h
index a20fb4cdd8388441513338395e6db6281c5a4387..7ce72f1a3aaa28a87e7aaf04f84108617987e7ea 100644
--- a/interfaces/inner_api/native/backup_kit_inner/impl/i_extension.h
+++ b/interfaces/inner_api/native/backup_kit_inner/impl/i_extension.h
@@ -33,7 +33,7 @@ public:
     virtual ErrCode HandleBackup(bool isClearData) = 0;
     virtual ErrCode PublishFile(const std::string &fileName) = 0;
     virtual ErrCode HandleRestore(bool isClearData) = 0;
-    virtual ErrCode GetIncrementalFileHandle(const std::string &fileName) = 0;
+    virtual std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncrementalFileHandle(const std::string &fileName) = 0;
     virtual ErrCode PublishIncrementalFile(const std::string &fileName) = 0;
     virtual ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) = 0;
     virtual ErrCode IncrementalOnBackup(bool isClearData) = 0;
diff --git a/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h
index 1b92cc342064fb7333e4bf19fb8b695165fa3214..1d8c02a5354a6f482d3112759f9ecf79c8f439fe 100644
--- a/services/backup_sa/include/module_ipc/service.h
+++ b/services/backup_sa/include/module_ipc/service.h
@@ -301,6 +301,8 @@ public:
      */
     void RemoveExtensionMutex(const BundleName &bundleName);
     void StartRunningTimer(const std::string &bundleName);
+    ErrCode AppIncrementalFileReady(const std::string &bundleName, const std::string &fileName, UniqueFd fd,
+        UniqueFd manifestFd, int32_t errCode);
 public:
     explicit Service(int32_t saID, bool runOnCreate = false) : SystemAbility(saID, runOnCreate)
     {
diff --git a/services/backup_sa/include/module_ipc/svc_extension_proxy.h b/services/backup_sa/include/module_ipc/svc_extension_proxy.h
index 4e5b9932a424e392df16219593f29ec56ac91b66..dd38f936a2d9dd80175ec4d90f6ac35f33035ff5 100644
--- a/services/backup_sa/include/module_ipc/svc_extension_proxy.h
+++ b/services/backup_sa/include/module_ipc/svc_extension_proxy.h
@@ -28,7 +28,7 @@ public:
     ErrCode HandleBackup(bool isClearData) override;
     ErrCode PublishFile(const std::string &fileName) override;
     ErrCode HandleRestore(bool isClearData) override;
-    ErrCode GetIncrementalFileHandle(const std::string &fileName) override;
+    std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncrementalFileHandle(const std::string &fileName) override;
     ErrCode PublishIncrementalFile(const std::string &fileName) override;
     ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) override;
     ErrCode IncrementalOnBackup(bool isClearData) override;
diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp
index 5495e0f304608d53542455133b8f9f1707c4c8a8..9e046d7376bed619aaa3902d7299597e550836ab 100644
--- a/services/backup_sa/src/module_ipc/service_incremental.cpp
+++ b/services/backup_sa/src/module_ipc/service_incremental.cpp
@@ -482,6 +482,60 @@ ErrCode Service::PublishSAIncrementalFile(const BFileInfo &fileInfo, UniqueFd fd
     return saConnection->CallRestoreSA(move(fd));
 }
 
+ErrCode Service::AppIncrementalFileReady(const std::string &bundleName, const std::string &fileName, UniqueFd fd,
+    UniqueFd manifestFd, int32_t errCode)
+{
+    HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
+    try {
+        if (session_->GetScenario() == IServiceReverse::Scenario::RESTORE) {
+            session_->GetServiceReverseProxy()->IncrementalRestoreOnFileReady(bundleName, fileName, move(fd),
+                                                                              move(manifestFd), errCode);
+            FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverse::Scenario::RESTORE);
+            return BError(BError::Codes::OK);
+        }
+        if (fileName == BConstants::EXT_BACKUP_MANAGE) {
+            fd = session_->OnBundleExtManageInfo(bundleName, move(fd));
+        }
+        HILOGD("reverse: Will notify IncrementalBackupOnFileReady");
+        session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(bundleName, fileName, move(fd),
+            move(manifestFd), errCode);
+        FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverse::Scenario::BACKUP);
+        AuditLog auditLog = { false, "Backup File Ready", "ADD", "", 1, "SUCCESS", "AppIncrementalFileReady",
+            bundleName, GetAnonyPath(fileName) };
+        HiAudit::GetInstance(true).Write(auditLog);
+        if (session_->OnBundleFileReady(bundleName, fileName)) {
+            auto backUpConnection = session_->GetExtConnection(bundleName);
+            auto proxy = backUpConnection->GetBackupExtProxy();
+            if (!proxy) {
+                throw BError(BError::Codes::SA_INVAL_ARG, "Extension backup Proxy is empty");
+            }
+            // 通知extension清空缓存
+            proxy->HandleClear();
+            // 清除Timer
+            session_->StopFwkTimer(bundleName);
+            session_->StopExtTimer(bundleName);
+            // 通知TOOL 备份完成
+            HILOGI("reverse: Will notify IncrementalBackupOnBundleFinished");
+            session_->GetServiceReverseProxy()->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK),
+                                                                                  bundleName);
+            BundleEndRadarReport(bundleName, BError(BError::Codes::OK), IServiceReverse::Scenario::BACKUP);
+            // 断开extension
+            backUpConnection->DisconnectBackupExtAbility();
+            ClearSessionAndSchedInfo(bundleName);
+        }
+        OnAllBundlesFinished(BError(BError::Codes::OK));
+        return BError(BError::Codes::OK);
+    } catch (const BError &e) {
+        return e.GetCode(); // 任意异常产生，终止监听该任务
+    } catch (const exception &e) {
+        HILOGI("Catched an unexpected low-level exception %{public}s", e.what());
+        return EPERM;
+    } catch (...) {
+        HILOGI("Unexpected exception");
+        return EPERM;
+    }
+}
+
 ErrCode Service::AppIncrementalFileReady(const std::string &fileName, UniqueFd fd, UniqueFd manifestFd, int32_t errCode)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -605,12 +659,13 @@ ErrCode Service::GetIncrementalFileHandle(const std::string &bundleName, const s
                 HILOGE("GetIncrementalFileHandle error, Extension backup Proxy is empty");
                 return BError(BError::Codes::SA_INVAL_ARG);
             }
-            ErrCode res = proxy->GetIncrementalFileHandle(fileName);
-            if (res != ERR_OK) {
-                HILOGE("Failed to extension file handle");
+            auto[errCode, fd, reportFd] = proxy->GetIncrementalFileHandle(fileName);
+            auto err = AppIncrementalFileReady(bundleName, fileName, move(fd), move(reportFd), errCode);
+            if (err != ERR_OK) {
+                HILOGE("Failed to send file handle");
                 AppRadar::Info info (bundleName, "", "");
                 AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::GetIncrementalFileHandle",
-                    GetUserIdDefault(), BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, res);
+                    GetUserIdDefault(), BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, err);
             }
         } else {
             SvcRestoreDepsManager::GetInstance().UpdateToRestoreBundleMap(bundleName, fileName);
@@ -656,9 +711,10 @@ bool Service::IncrementalBackup(const string &bundleName)
         BundleBeginRadarReport(bundleName, ret, IServiceReverse::Scenario::RESTORE);
         auto fileNameVec = session_->GetExtFileNameRequest(bundleName);
         for (auto &fileName : fileNameVec) {
-            ret = proxy->GetIncrementalFileHandle(fileName);
+            auto[errCode, fd, reportFd] = proxy->GetIncrementalFileHandle(fileName);
+            ret = AppIncrementalFileReady(bundleName, fileName, move(fd), move(reportFd), errCode);
             if (ret) {
-                HILOGE("Failed to extension file handle %{public}s", GetAnonyString(fileName).c_str());
+                HILOGE("Failed to send file handle %{public}s", GetAnonyString(fileName).c_str());
             }
         }
         return true;
diff --git a/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp b/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp
index 03dbb4fe3133fdaf0f030579646aeaa0c6626272..c29b0e72b97fcb2584cb6eaba098c7b1751942ca 100644
--- a/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp
+++ b/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp
@@ -25,7 +25,7 @@
 namespace OHOS::FileManagement::Backup {
 using namespace std;
 
-ErrCode SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName)
+std::tuple<ErrCode, UniqueFd, UniqueFd> SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     HILOGD("Start");
@@ -35,7 +35,7 @@ ErrCode SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName)
 
     if (!data.WriteString(fileName)) {
         BError(BError::Codes::SDK_INVAL_ARG, "Failed to send the fileName");
-        return ErrCode(EPERM);
+        return {ErrCode(EPERM), UniqueFd(-1), UniqueFd(-1)};
     }
 
     MessageParcel reply;
@@ -44,11 +44,14 @@ ErrCode SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName)
                                         data, reply, option);
     if (ret != NO_ERROR) {
         HILOGE("Received error %{public}d when doing IPC", ret);
-        return ErrCode(ret);
+        return {ErrCode(ret), UniqueFd(-1), UniqueFd(-1)};
     }
 
     HILOGD("Successful");
-    return reply.ReadInt32();
+    ErrCode err(reply.ReadInt32());
+    UniqueFd fd(reply.ReadFileDescriptor());
+    UniqueFd reportFd(reply.ReadFileDescriptor());
+    return {err, move(fd), move(reportFd)};
 }
 
 ErrCode SvcExtensionProxy::PublishIncrementalFile(const string &fileName)
diff --git a/tests/mock/backup_ext/include/ext_extension_mock.h b/tests/mock/backup_ext/include/ext_extension_mock.h
index 1e97a71f6c7496c0a02a6f708ebef4596f3c1879..9f98a00074aa6556e75a5b566b61b5f7ffdd3795 100644
--- a/tests/mock/backup_ext/include/ext_extension_mock.h
+++ b/tests/mock/backup_ext/include/ext_extension_mock.h
@@ -77,7 +77,7 @@ public:
 class ExtExtensionMock : public BExtExtension {
 public:
     MOCK_METHOD(UniqueFd, GetFileHandle, (const string &, int32_t &));
-    MOCK_METHOD(ErrCode, GetIncrementalFileHandle, (const string &));
+    MOCK_METHOD(std::tuple<ErrCode, UniqueFd, UniqueFd>, GetIncrementalFileHandle, (const string &));
     MOCK_METHOD(ErrCode, HandleClear, ());
     MOCK_METHOD(ErrCode, BigFileReady, (sptr<IService>));
     MOCK_METHOD(ErrCode, PublishFile, (const std::string &));
diff --git a/tests/mock/module_ipc/include/svc_extension_proxy_mock.h b/tests/mock/module_ipc/include/svc_extension_proxy_mock.h
index fd4664e773b24ed83929ccffc93a0924ff6dd802..a042be3abb0f31dccf745a9fa158b9bb2b45e7b8 100644
--- a/tests/mock/module_ipc/include/svc_extension_proxy_mock.h
+++ b/tests/mock/module_ipc/include/svc_extension_proxy_mock.h
@@ -30,7 +30,7 @@ public:
     MOCK_METHOD(ErrCode, HandleBackup, (bool));
     MOCK_METHOD(ErrCode, PublishFile, (const std::string&));
     MOCK_METHOD(ErrCode, HandleRestore, (bool));
-    MOCK_METHOD(ErrCode, GetIncrementalFileHandle, (const std::string&));
+    MOCK_METHOD((std::tuple<ErrCode, UniqueFd, UniqueFd>), GetIncrementalFileHandle, (const std::string&));
     MOCK_METHOD(ErrCode, PublishIncrementalFile, (const std::string&));
     MOCK_METHOD(ErrCode, HandleIncrementalBackup, (UniqueFd, UniqueFd));
     MOCK_METHOD(ErrCode, IncrementalOnBackup, (bool));
diff --git a/tests/mock/module_ipc/svc_extension_proxy_mock.cpp b/tests/mock/module_ipc/svc_extension_proxy_mock.cpp
index bb000e0900a90ffe5f8b665150286f646df861f2..a2534d899d00a0718fcd3e3007a7a963d6a26b2e 100644
--- a/tests/mock/module_ipc/svc_extension_proxy_mock.cpp
+++ b/tests/mock/module_ipc/svc_extension_proxy_mock.cpp
@@ -48,9 +48,9 @@ ErrCode SvcExtensionProxy::GetBackupInfo(std::string &result)
     return 0;
 }
 
-ErrCode SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName)
+std::tuple<ErrCode, UniqueFd, UniqueFd> SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName)
 {
-    return 0;
+    return {0, UniqueFd(-1), UniqueFd(-1)};
 }
 
 ErrCode SvcExtensionProxy::PublishIncrementalFile(const string &fileName)
diff --git a/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h b/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h
index b5070b41f53fc228b3471e56955304860c2de76a..3399bc312d7e0747aa06365fc881ab46e5f40ff8 100644
--- a/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h
+++ b/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h
@@ -104,9 +104,9 @@ public:
         return BError(BError::Codes::OK);
     };
 
-    ErrCode GetIncrementalFileHandle(const std::string &fileName) override
+    std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncrementalFileHandle(const std::string &fileName) override
     {
-        return BError(BError::Codes::OK);
+        return {BError(BError::Codes::OK), UniqueFd(-1), UniqueFd(-1)};
     };
 
     ErrCode PublishIncrementalFile(const std::string &fileName) override
diff --git a/tests/unittests/backup_ext/ext_extension_stub_test.cpp b/tests/unittests/backup_ext/ext_extension_stub_test.cpp
index a721a50ed2edac4fa9b239182084f2a0feecd41d..6e07ddd4d1ccb59e9d565c239926e9b31462c8c6 100644
--- a/tests/unittests/backup_ext/ext_extension_stub_test.cpp
+++ b/tests/unittests/backup_ext/ext_extension_stub_test.cpp
@@ -31,7 +31,7 @@ public:
     MOCK_METHOD(ErrCode, HandleBackup, (bool isClearData));
     MOCK_METHOD(ErrCode, PublishFile, (const std::string &fileName));
     MOCK_METHOD(ErrCode, HandleRestore, (bool isClearData));
-    MOCK_METHOD(ErrCode, GetIncrementalFileHandle, (const std::string &fileName));
+    MOCK_METHOD((std::tuple<ErrCode, UniqueFd, UniqueFd>), GetIncrementalFileHandle, (const std::string &fileName));
     MOCK_METHOD(ErrCode, PublishIncrementalFile, (const std::string &fileName));
     MOCK_METHOD(ErrCode, HandleIncrementalBackup, (UniqueFd incrementalFd, UniqueFd manifestFd));
     MOCK_METHOD(ErrCode, IncrementalOnBackup, (bool isClearData));
@@ -318,14 +318,15 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncremental
         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
 
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
-        EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(0));
+        EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1))));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
         err = stub->CmdGetIncrementalFileHandle(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
 
         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
-        EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(0));
+        EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1))));
         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
+        EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
         err = stub->CmdGetIncrementalFileHandle(data, reply);
         EXPECT_EQ(err, BError(BError::Codes::OK));
     } catch (...) {
diff --git a/tests/unittests/backup_ext/ext_extension_test.cpp b/tests/unittests/backup_ext/ext_extension_test.cpp
index 9a73d1a97b1b0b50e0106cbf8a477b3808972fd8..5e4d814a2f4a0eeb0c6c8ba996f41ac263d4cd1a 100644
--- a/tests/unittests/backup_ext/ext_extension_test.cpp
+++ b/tests/unittests/backup_ext/ext_extension_test.cpp
@@ -604,11 +604,11 @@ HWTEST_F(ExtExtensionTest, Ext_Extension_Test_1000, testing::ext::TestSize.Level
     GTEST_LOG_(INFO) << "ExtExtensionTest-begin Ext_Extension_Test_1000";
     try {
         std::string fileName = "test.txt";
-        auto ret = GetIncreFileHandleForSpecialVersion(fileName);
-        EXPECT_EQ(ret, ERR_OK);
+        auto [ret, fd, reportFd] = GetIncreFileHandleForSpecialVersion(fileName);
+        EXPECT_NE(ret, ERR_OK);
         fileName = "/test.txt";
-        ret = GetIncreFileHandleForSpecialVersion(fileName);
-        EXPECT_EQ(ret, ERR_OK);
+        tie(ret, fd, reportFd) = GetIncreFileHandleForSpecialVersion(fileName);
+        EXPECT_NE(ret, ERR_OK);
     } catch (...) {
         EXPECT_TRUE(false);
         GTEST_LOG_(INFO) << "ExtExtensionTest-an exception occurred by construction.";
diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
index 9d43383b8e3e1b502305aba3dc479777e98a53a2..95d726a2099bf2f4a7f4f9b8f45a4a2b20555ad6 100644
--- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
@@ -706,7 +706,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_
 
         EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
         EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy));
-        EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
+        EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()).WillOnce(Return());
         EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
         EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
         EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
@@ -754,7 +754,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000,
         EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
 
         errCode = BError(BError::Codes::SA_INVAL_ARG).GetCode();
-        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false))
+            .WillOnce(Return(false)).WillOnce(Return(false));
         EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
         ret = service->AppIncrementalDone(errCode);
         EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
@@ -797,14 +798,19 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle
         EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
         EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
         EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
-        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(0));
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1))));
         ret = service->GetIncrementalFileHandle(bundleName, fileName);
         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
 
         EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
         EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
         EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
-        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(1));
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
+        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(1, UniqueFd(-1), UniqueFd(-1))));
         EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
             .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
         ret = service->GetIncrementalFileHandle(bundleName, fileName);
@@ -924,7 +930,13 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100,
         EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
         EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return());
         EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
-        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return());
+        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_))
+            .WillOnce(Return(make_tuple(BError(BError::Codes::OK).GetCode(), UniqueFd(-1), UniqueFd(-1))));
+        EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
         ret = service->IncrementalBackup(bundleName);
         EXPECT_TRUE(ret);
     } catch (...) {
@@ -959,8 +971,13 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200,
         EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
         EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return());
         EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return());
         EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_))
-            .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
+            .WillOnce(Return(make_tuple(BError(BError::Codes::SA_INVAL_ARG).GetCode(), UniqueFd(-1), UniqueFd(-1))));
+        EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
         auto ret = service->IncrementalBackup(bundleName);
         EXPECT_TRUE(ret);
     } catch (...) {
diff --git a/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp
index aa55e0dc00e928c014643a46ec7b341a0a453fa4..572c43f8554ef78abb6bc6f45ca4dbbc90e9e495 100644
--- a/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp
@@ -368,20 +368,21 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetIncrementalFileHandle
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
         EXPECT_TRUE(proxy_ != nullptr);
-        ErrCode ret = proxy_->GetIncrementalFileHandle(fileName);
+        auto [ret, fd, reportFd] = proxy_->GetIncrementalFileHandle(fileName);
         EXPECT_EQ(ret, ErrCode(EPERM));
 
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
-        ret = proxy_->GetIncrementalFileHandle(fileName);
+        tie(ret, fd, reportFd) = proxy_->GetIncrementalFileHandle(fileName);
         EXPECT_EQ(ret, ErrCode(EPERM));
 
         EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
         EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
         EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
         EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(NO_ERROR));
-        ret = proxy_->GetIncrementalFileHandle(fileName);
+        EXPECT_CALL(*messageParcelMock_, ReadFileDescriptor()).WillOnce(Return(-1)).WillOnce(Return(-1));
+        tie(ret, fd, reportFd) = proxy_->GetIncrementalFileHandle(fileName);
         EXPECT_EQ(ret, ErrCode(BError::Codes::OK));
     } catch (...) {
         EXPECT_TRUE(false);