diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h
index b93bdbb3e3c7a906f7df550b377b5d8b5ad0d8d3..25df4f6639fa79c5b4f76b585f8fd4c237b7e777 100644
--- a/frameworks/native/backup_ext/include/ext_extension.h
+++ b/frameworks/native/backup_ext/include/ext_extension.h
@@ -155,10 +155,11 @@ private:
     void AsyncTaskOnIncrementalBackup();
     ErrCode IncrementalBigFileReady(const TarMap &pkgInfo, const vector<struct ReportFileInfo> &bigInfos,
         sptr<IService> proxy);
-    ErrCode BigFileReady(sptr<IService> proxy);
+    ErrCode BigFileReady(const TarMap &bigFileInfo, sptr<IService> proxy);
     void WaitToSendFd(std::chrono::system_clock::time_point &startTime, int &fdSendNum);
     void RefreshTimeInfo(std::chrono::system_clock::time_point &startTime, int &fdSendNum);
     void IncrementalPacket(const vector<struct ReportFileInfo> &infos, TarMap &tar, sptr<IService> proxy);
+    void DoPacket(const map<string, double> &srcFiles, TarMap &tar, sptr<IService> proxy);
 
     /**
      * @brief extension incremental backup restore is done
diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp
index 723d18df176664fa8dba2b3e41095f89a628ed25..e66b76e81c0ed2c8a0c15df74ab0ea1cb58408db 100644
--- a/frameworks/native/backup_ext/src/ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/ext_extension.cpp
@@ -352,36 +352,26 @@ static ErrCode IndexFileReady(const TarMap &pkgInfo, sptr<IService> proxy)
     return ret;
 }
 
-ErrCode BackupExtExtension::BigFileReady(sptr<IService> proxy)
+ErrCode BackupExtExtension::BigFileReady(const TarMap &bigFileInfo, sptr<IService> proxy)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
-    UniqueFd fd(open(INDEX_FILE_BACKUP.data(), O_RDONLY));
-    if (fd < 0) {
-        HILOGE("Failed to open index json file = %{private}s, err = %{public}d", INDEX_FILE_BACKUP.c_str(), errno);
-        return BError::GetCodeByErrno(errno);
-    }
-    BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(move(fd));
-    auto cache = cachedEntity.Structuralize();
-    auto pkgInfo = cache.GetExtManageInfo();
-    HILOGI("BigFileReady Begin: pkgInfo file size is: %{public}zu", pkgInfo.size());
+    HILOGI("BigFileReady Begin: bigFileInfo file size is: %{public}zu", bigFileInfo.size());
     ErrCode ret {ERR_OK};
     auto startTime = std::chrono::system_clock::now();
     int fdNum = 0;
-    for (auto &item : pkgInfo) {
-        if (item.hashName.empty() || item.fileName.empty()) {
-            continue;
-        }
+    for (auto &item : bigFileInfo) {
         WaitToSendFd(startTime, fdNum);
         int32_t errCode = ERR_OK;
-        UniqueFd fd(open(item.fileName.data(), O_RDONLY));
+        string fllePath = std::get<0>(item.second);
+        UniqueFd fd(open(fllePath.data(), O_RDONLY));
         if (fd < 0) {
-            HILOGE("open file failed, file name is %{public}s, err = %{public}d", item.fileName.c_str(), errno);
+            HILOGE("open file failed, file name is %{public}s, err = %{public}d", fllePath.c_str(), errno);
             errCode = errno;
         }
 
-        ret = proxy->AppFileReady(item.hashName, std::move(fd), errCode);
+        ret = proxy->AppFileReady(item.first, std::move(fd), errCode);
         if (SUCCEEDED(ret)) {
-            HILOGI("The application is packaged successfully, package name is %{public}s", item.hashName.c_str());
+            HILOGI("The application is packaged successfully, package name is %{public}s", item.first.c_str());
         } else {
             HILOGW("Current file execute app file ready interface failed, ret is:%{public}d", ret);
         }
@@ -501,7 +491,7 @@ static bool IsUserTar(const string &tarFile, const std::vector<ExtManageInfo> &e
     return false;
 }
 
-static pair<TarMap, vector<string>> GetFileInfos(const vector<string> &includes, const vector<string> &excludes)
+static pair<TarMap, map<string, double>> GetFileInfos(const vector<string> &includes, const vector<string> &excludes)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     auto [errCode, files, smallFiles] = BDir::GetBigFiles(includes, excludes);
@@ -537,6 +527,76 @@ static pair<TarMap, vector<string>> GetFileInfos(const vector<string> &includes,
     return {bigFiles, smallFiles};
 }
 
+/**
+ * 全量tar包回传
+ */
+static ErrCode TarFileReady(const TarMap &tarFileInfo, sptr<IService> proxy)
+{
+    if (tarFileInfo.empty()) {
+        HILOGI("TarFileReady: No tar file found");
+        return ERR_OK;
+    }
+    string tarName = tarFileInfo.begin()->first;
+    string path = string(BConstants::PATH_BUNDLE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_BACKUP);
+    string tarPath = path + tarName;
+    int32_t errCode = ERR_OK;
+    UniqueFd fd(open(tarPath.data(), O_RDONLY));
+    if (fd < 0) {
+        HILOGE("TarFileReady open file failed, file name is %{public}s, err = %{public}d", tarName.c_str(), errno);
+        errCode = errno;
+    }
+    int ret = proxy->AppFileReady(tarName, std::move(fd), errCode);
+    if (SUCCEEDED(ret)) {
+        HILOGI("TarFileReady: AppFileReady success for %{public}s", tarName.c_str());
+        // 删除文件
+        RemoveFile(tarName);
+    } else {
+        HILOGE("TarFileReady AppFileReady fail to be invoked for %{public}s: ret = %{public}d", tarName.c_str(), ret);
+    }
+    return ret;
+}
+
+void BackupExtExtension::DoPacket(const map<string, double> &srcFiles, TarMap &tar, sptr<IService> proxy)
+{
+    HILOGI("DoPacket begin, infos count: %{public}zu", srcFiles.size());
+    string path = string(BConstants::PATH_BUNDLE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_BACKUP);
+    int64_t totalSize = 0;
+    uint32_t fileCount = 0;
+    vector<string> packFiles;
+    TarFile::GetInstance().SetPacketMode(true); // 设置下打包模式
+    auto startTime = std::chrono::system_clock::now();
+    int fdNum = 0;
+    for (auto small : srcFiles) {
+        totalSize += small.second;
+        fileCount += 1;
+        packFiles.emplace_back(small.first);
+        if (totalSize >= DEFAULT_SLICE_SIZE || fileCount >= MAX_FILE_COUNT) {
+            TarMap tarMap {};
+            TarFile::GetInstance().Packet(packFiles, "part", path, tarMap);
+            tar.insert(tarMap.begin(), tarMap.end());
+            // 执行tar包回传功能
+            WaitToSendFd(startTime, fdNum);
+            TarFileReady(tarMap, proxy);
+            totalSize = 0;
+            fileCount = 0;
+            packFiles.clear();
+            fdNum += FILE_AND_MANIFEST_FD_COUNT;
+            RefreshTimeInfo(startTime, fdNum);
+        }
+    }
+    if (fileCount > 0) {
+        // 打包回传
+        TarMap tarMap {};
+        TarFile::GetInstance().Packet(packFiles, "part", path, tarMap);
+        TarFileReady(tarMap, proxy);
+        fdNum = 1;
+        WaitToSendFd(startTime, fdNum);
+        tar.insert(tarMap.begin(), tarMap.end());
+        packFiles.clear();
+        RefreshTimeInfo(startTime, fdNum);
+    }
+}
+
 int BackupExtExtension::DoBackup(const BJsonEntityExtensionConfig &usrConfig)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -557,6 +617,11 @@ int BackupExtExtension::DoBackup(const BJsonEntityExtensionConfig &usrConfig)
     vector<string> includes = usrConfig.GetIncludes();
     vector<string> excludes = usrConfig.GetExcludes();
 
+    auto proxy = ServiceProxy::GetInstance();
+    if (proxy == nullptr) {
+        throw BError(BError::Codes::EXT_BROKEN_BACKUP_SA, std::generic_category().message(errno));
+    }
+
     // 大文件处理
     HILOGI("Start packet bigfiles and small files");
     auto [bigFileInfo, smallFiles] = GetFileInfos(includes, excludes);
@@ -567,21 +632,22 @@ int BackupExtExtension::DoBackup(const BJsonEntityExtensionConfig &usrConfig)
         }
     }
 
+    // 回传大文件
+    HILOGI("Will notify BigFileReady");
+    auto res = BigFileReady(bigFileInfo, proxy);
+
     HILOGI("Start packet Tar files");
-    // 分片打包
+    // 分片打包， 回传tar包
     TarMap tarMap {};
-    TarFile::GetInstance().Packet(smallFiles, "part", path, tarMap);
+    DoPacket(smallFiles, tarMap, proxy);
     bigFileInfo.insert(tarMap.begin(), tarMap.end());
-    auto proxy = ServiceProxy::GetInstance();
-    if (proxy == nullptr) {
-        throw BError(BError::Codes::EXT_BROKEN_BACKUP_SA, std::generic_category().message(errno));
-    }
+    HILOGI("Do backup, DoPacket end");
+
     HILOGI("Will notify IndexFileReady");
     if (auto ret = IndexFileReady(bigFileInfo, proxy); ret) {
         return ret;
     }
-    HILOGI("Will notify BigFileReady");
-    auto res = BigFileReady(proxy);
+
     HILOGI("HandleBackup finish, ret = %{public}d", res);
     return res;
 }
diff --git a/utils/include/b_filesystem/b_dir.h b/utils/include/b_filesystem/b_dir.h
index 753529cb63e2eb48567c061412314a7ceb966072..67fa5428abcb4c511d8f5fa306fa2e150c757203 100644
--- a/utils/include/b_filesystem/b_dir.h
+++ b/utils/include/b_filesystem/b_dir.h
@@ -46,7 +46,7 @@ public:
      * @param excludes 需要排除的文件及目录集合
      * @return 错误码、大文件名集合
      */
-    static std::tuple<ErrCode, std::map<std::string, struct stat>, std::vector<std::string>> GetBigFiles(
+    static std::tuple<ErrCode, std::map<std::string, struct stat>, std::map<std::string, double>> GetBigFiles(
         const std::vector<std::string> &includes, const std::vector<std::string> &excludes);
 
     /**
diff --git a/utils/src/b_filesystem/b_dir.cpp b/utils/src/b_filesystem/b_dir.cpp
index 23d9b525c33672b6d27307c528d9a027d53efc39..c199715031cf3e227b738c439c5646d31f02d8d4 100644
--- a/utils/src/b_filesystem/b_dir.cpp
+++ b/utils/src/b_filesystem/b_dir.cpp
@@ -55,10 +55,10 @@ static bool IsEmptyDirectory(const string &path)
     return isEmpty;
 }
 
-static tuple<ErrCode, map<string, struct stat>, vector<string>> GetFile(const string &path, off_t size = -1)
+static tuple<ErrCode, map<string, struct stat>, map<string, double>> GetFile(const string &path, off_t size = -1)
 {
     map<string, struct stat> files;
-    vector<string> smallFiles;
+    map<string, double> smallFiles;
     struct stat sta = {};
     if (stat(path.data(), &sta) == -1) {
         return {BError(errno).GetCode(), files, smallFiles};
@@ -67,7 +67,7 @@ static tuple<ErrCode, map<string, struct stat>, vector<string>> GetFile(const st
         return {BError(BError::Codes::OK).GetCode(), files, smallFiles};
     }
     if (sta.st_size <= size) {
-        smallFiles.emplace_back(path);
+        smallFiles.insert(make_pair(path, sta.st_size));
     } else {
         files.try_emplace(path, sta);
     }
@@ -85,19 +85,35 @@ static uint32_t CheckOverLongPath(const string &path)
     return len;
 }
 
-static tuple<ErrCode, map<string, struct stat>, vector<string>> GetDirFilesDetail(const string &path,
-                                                                                  bool recursion,
-                                                                                  off_t size = -1)
+// static void GetFileDetail(const string &path, const string &dirName, off_t size, map<string, double> &smallFiles,
+//                           map<string, struct stat> &files)
+// {
+//     struct stat sta = {};
+//     string fileName = IncludeTrailingPathDelimiter(path) + string(dirName);
+//     if (CheckOverLongPath(fileName) >= PATH_MAX_LEN || stat(fileName.data(), &sta) == -1) {
+//         continue;
+//     }
+//     if (sta.st_size <= size) {
+//         smallFiles.insert(make_pair(fileName, sta.st_size));
+//         continue;
+//     }
+
+//     files.try_emplace(fileName, sta);
+// }
+
+static tuple<ErrCode, map<string, struct stat>, map<string, double>> GetDirFilesDetail(const string &path,
+                                                                                       bool recursion,
+                                                                                       off_t size = -1)
 {
     map<string, struct stat> files;
-    vector<string> smallFiles;
+    map<string, double> smallFiles;
 
     if (IsEmptyDirectory(path)) {
         string newPath = path;
         if (path.at(path.size()-1) != '/') {
             newPath += '/';
         }
-        smallFiles.emplace_back(newPath);
+        smallFiles.insert(make_pair(newPath, 0));
         return {ERR_OK, files, smallFiles};
     }
 
@@ -111,32 +127,32 @@ static tuple<ErrCode, map<string, struct stat>, vector<string>> GetDirFilesDetai
         // current dir OR parent dir
         if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0)) {
             continue;
-        } else if (ptr->d_type == DT_DIR) {
-            if (!recursion) {
-                continue;
-            }
-            auto [errCode, subFiles, subSmallFiles] =
-                GetDirFilesDetail(IncludeTrailingPathDelimiter(path) + string(ptr->d_name), recursion, size);
-            if (errCode != 0) {
-                return {errCode, files, smallFiles};
-            }
-            files.merge(subFiles);
-            smallFiles.insert(smallFiles.end(), subSmallFiles.begin(), subSmallFiles.end());
         } else if (ptr->d_type == DT_LNK) {
             continue;
-        } else {
+        } else if (ptr->d_type != DT_DIR) {
             struct stat sta = {};
             string fileName = IncludeTrailingPathDelimiter(path) + string(ptr->d_name);
             if (CheckOverLongPath(fileName) >= PATH_MAX_LEN || stat(fileName.data(), &sta) == -1) {
                 continue;
             }
             if (sta.st_size <= size) {
-                smallFiles.emplace_back(fileName);
+                smallFiles.insert(make_pair(fileName, sta.st_size));
                 continue;
             }
 
             files.try_emplace(fileName, sta);
         }
+        // type is DT_DIR
+        if (!recursion) {
+            continue;
+        }
+        auto [errCode, subFiles, subSmallFiles] =
+            GetDirFilesDetail(IncludeTrailingPathDelimiter(path) + string(ptr->d_name), recursion, size);
+        if (errCode != 0) {
+            return {errCode, files, smallFiles};
+        }
+        files.merge(subFiles);
+        smallFiles.insert(subSmallFiles.begin(), subSmallFiles.end());
     }
     return {ERR_OK, files, smallFiles};
 }
@@ -198,20 +214,20 @@ static set<string> ExpandPathWildcard(const vector<string> &vec, bool onlyPath)
     return filteredPath;
 }
 
-tuple<ErrCode, map<string, struct stat>, vector<string>> BDir::GetBigFiles(const vector<string> &includes,
-                                                                           const vector<string> &excludes)
+tuple<ErrCode, map<string, struct stat>, map<string, double>> BDir::GetBigFiles(const vector<string> &includes,
+                                                                                const vector<string> &excludes)
 {
     set<string> inc = ExpandPathWildcard(includes, false);
 
     map<string, struct stat> incFiles;
-    vector<string> incSmallFiles;
+    map<string, double> incSmallFiles;
     for (const auto &item : inc) {
         auto [errCode, files, smallFiles] = GetDirFilesDetail(item, true, BConstants::BIG_FILE_BOUNDARY);
         if (errCode == 0) {
             int32_t num = static_cast<int32_t>(files.size());
             incFiles.merge(move(files));
             HILOGI("big files: %{public}d; small files: %{public}d", num, static_cast<int32_t>(smallFiles.size()));
-            incSmallFiles.insert(incSmallFiles.end(), smallFiles.begin(), smallFiles.end());
+            incSmallFiles.insert(smallFiles.begin(), smallFiles.end());
         }
     }
 
@@ -234,10 +250,10 @@ tuple<ErrCode, map<string, struct stat>, vector<string>> BDir::GetBigFiles(const
         return false;
     };
 
-    vector<string> resSmallFiles;
+    map<string, double> resSmallFiles;
     for (const auto &item : incSmallFiles) {
-        if (!isMatch(excludes, item)) {
-            resSmallFiles.emplace_back(item);
+        if (!isMatch(excludes, item.first)) {
+            resSmallFiles.insert(make_pair(item.first, item.second));
         }
     }