From 9f26aa4f1f301745b40f0e51a0b1f056d211d2c9 Mon Sep 17 00:00:00 2001
From: hunili <lihucheng2@huawei.com>
Date: Thu, 25 Jul 2024 11:44:04 +0800
Subject: [PATCH] Add check after publishFile issue:
 https://gitee.com/openharmony/filemanagement_app_file_service/issues/IAFGMS
 Signed-off-by: hunili <lihucheng2@huawei.com>

---
 .../native/backup_ext/include/ext_extension.h |  11 +-
 .../native/backup_ext/include/untar_file.h    |   6 +-
 .../native/backup_ext/src/ext_extension.cpp   | 142 ++++++++++++++++--
 frameworks/native/backup_ext/src/tar_file.cpp |   1 +
 .../native/backup_ext/src/untar_file.cpp      |  30 ++--
 .../js/backup/session_restore_n_exporter.cpp  |   6 +-
 .../unittests/backup_ext/untar_file_test.cpp  |  10 +-
 utils/include/b_filesystem/b_dir.h            |  13 ++
 utils/include/b_json/b_json_cached_entity.h   |   1 +
 .../include/b_json/b_json_entity_ext_manage.h |   7 +
 utils/include/b_ohos/startup/backup_para.h    |   7 +
 utils/src/b_filesystem/b_dir.cpp              |   3 +-
 utils/src/b_json/b_json_entity_ext_manage.cpp |  40 +++++
 utils/src/b_ohos/startup/backup_para.cpp      |  16 +-
 14 files changed, 250 insertions(+), 43 deletions(-)

diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h
index b93bdbb3e..27f043c63 100644
--- a/frameworks/native/backup_ext/include/ext_extension.h
+++ b/frameworks/native/backup_ext/include/ext_extension.h
@@ -52,7 +52,6 @@ public:
     std::tuple<UniqueFd, UniqueFd> GetIncrementalBackupFileHandle() override;
     ErrCode GetBackupInfo(std::string &result) override;
     ErrCode UpdateFdSendRate(std::string &bundleName, int32_t sendRate) override;
-
     void AsyncTaskRestoreForUpgrade(void);
     void ExtClear(void);
     void AsyncTaskIncrementalRestoreForUpgrade(void);
@@ -159,7 +158,9 @@ private:
     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);
-
+    tuple<bool, vector<string>> CheckTmpDirFileInfos(bool isSpecialVersion = false);
+    std::map<std::string, off_t> GetIdxFileInfos(bool isSpecialVersion = false);
+    tuple<bool, vector<string>> CheckRestoreFileInfos();
     /**
      * @brief extension incremental backup restore is done
      *
@@ -194,6 +195,11 @@ private:
     std::function<void(ErrCode, std::string)> AppDoneCallbackEx(wptr<BackupExtExtension> obj);
     std::function<void(ErrCode, const std::string)> HandleBackupEx(wptr<BackupExtExtension> obj);
     std::function<void(ErrCode, const std::string)> HandleTaskBackupEx(wptr<BackupExtExtension> obj);
+    ErrCode RestoreFilesForSpecialCloneCloud();
+    void RestoreBigFilesForSpecialCloneCloud(ExtManageInfo item);
+    ErrCode RestoreTarForSpecialCloneCloud(ExtManageInfo item);
+    void RestoreBigFiles(bool appendTargetPath);
+    void FillEndFileInfos(const unordered_map<string, struct ReportFileInfo> &result);
 private:
     std::shared_mutex lock_;
     std::shared_ptr<ExtBackup> extension_;
@@ -207,6 +213,7 @@ private:
     std::mutex waitTimeLock_;
     std::string bundleName_;
     int32_t sendRate_ = BConstants::DEFAULT_FD_SEND_RATE;
+    std::map<std::string, off_t> endFileInfos_;
 };
 } // namespace OHOS::FileManagement::Backup
 
diff --git a/frameworks/native/backup_ext/include/untar_file.h b/frameworks/native/backup_ext/include/untar_file.h
index 8d890b833..c4bba51a5 100644
--- a/frameworks/native/backup_ext/include/untar_file.h
+++ b/frameworks/native/backup_ext/include/untar_file.h
@@ -32,7 +32,7 @@ class UntarFile {
 public:
     typedef enum { ERR_FORMAT = -1 } ErrorCode;
     static UntarFile &GetInstance();
-    int UnPacket(const std::string &tarFile, const std::string &rootPath);
+    std::tuple<int, std::map<std::string, off_t>> UnPacket(const std::string &tarFile, const std::string &rootPath);
     int IncrementalUnPacket(const std::string &tarFile, const std::string &rootPath,
                             const std::unordered_map<std::string, struct ReportFileInfo> &includes);
 
@@ -47,7 +47,7 @@ private:
      *
      * @param rootpath 解包的目标路径
      */
-    int ParseTarFile(const std::string &rootPath);
+    std::tuple<int, std::map<std::string, off_t>> ParseTarFile(const std::string &rootPath);
 
     /**
      * @brief parse incremental tar file
@@ -110,7 +110,7 @@ private:
      * @param name 文件名
      * @param info 文件属性结构体
      */
-    void HandleTarBuffer(const std::string &buff, const std::string &name, FileStatInfo &info);
+    off_t HandleTarBuffer(const std::string &buff, const std::string &name, FileStatInfo &info);
 
     /**
      * @brief parse file by typeFlag
diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp
index 6b69f1f93..e8190eae5 100644
--- a/frameworks/native/backup_ext/src/ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/ext_extension.cpp
@@ -46,6 +46,7 @@
 #include "b_filesystem/b_file_hash.h"
 #include "b_json/b_json_cached_entity.h"
 #include "b_jsonutil/b_jsonutil.h"
+#include "b_ohos/startup/backup_para.h"
 #include "b_tarball/b_tarball_factory.h"
 #include "filemgmt_libhilog.h"
 #include "hitrace_meter.h"
@@ -66,6 +67,8 @@ const string INDEX_FILE_RESTORE = string(BConstants::PATH_BUNDLE_BACKUP_HOME).
                                   append(BConstants::EXT_BACKUP_MANAGE);
 const string INDEX_FILE_INCREMENTAL_BACKUP = string(BConstants::PATH_BUNDLE_BACKUP_HOME).
                                              append(BConstants::SA_BUNDLE_BACKUP_BACKUP);
+const std::string MEDIA_BUNDLE_NAME = "com.ohos.medialibrary.medialibrarydata";
+const std::string MEDIA_LIBRARY_PATH = "storage/media/local/files/data";
 using namespace std;
 
 namespace {
@@ -80,7 +83,7 @@ static std::set<std::string> GetIdxFileData()
     UniqueFd idxFd(open(INDEX_FILE_RESTORE.data(), O_RDONLY));
     if (idxFd < 0) {
         HILOGE("Failed to open idxFile = %{private}s, err = %{public}d", INDEX_FILE_RESTORE.c_str(), errno);
-        return std::set<std::string>();
+        return {};
     }
     BJsonCachedEntity<BJsonEntityExtManage> cachedEntity(std::move(idxFd));
     auto cache = cachedEntity.Structuralize();
@@ -604,9 +607,15 @@ int BackupExtExtension::DoRestore(const string &fileName)
 
     // 当用户指定fullBackupOnly字段或指定版本的恢复，解压目录当前在/backup/restore
     if (extension_->SpecialVersionForCloneAndCloud() || extension_->UseFullBackupOnly()) {
-        UntarFile::GetInstance().UnPacket(tarName, path);
+        auto [ret, fileInfos] = UntarFile::GetInstance().UnPacket(tarName, path);
+        if (BackupPara::GetBackupDebugState()) {
+            endFileInfos_.merge(fileInfos);
+        }
     } else {
-        UntarFile::GetInstance().UnPacket(tarName, "/");
+        auto [ret, fileInfos] = UntarFile::GetInstance().UnPacket(tarName, "/");
+        if (BackupPara::GetBackupDebugState()) {
+            endFileInfos_.merge(fileInfos);
+        }
     }
     HILOGI("Application recovered successfully, package path is %{public}s", tarName.c_str());
 
@@ -621,6 +630,7 @@ static unordered_map<string, struct ReportFileInfo> GetTarIncludes(const string
     UniqueFd fd(open(reportName.data(), O_RDONLY));
     if (fd < 0) {
         HILOGE("Failed to open report file = %{private}s, err = %{public}d", reportName.c_str(), errno);
+        HILOGE("LHC...Failed to open report file = %{public}s, err = %{public}d", reportName.c_str(), errno);
         return {};
     }
 
@@ -649,10 +659,14 @@ int BackupExtExtension::DoIncrementalRestore()
             string tarName = path + item;
 
             // 当用户指定fullBackupOnly字段或指定版本的恢复，解压目录当前在/backup/restore
+            unordered_map<string, struct ReportFileInfo> result = GetTarIncludes(tarName);
+            if (BackupPara::GetBackupDebugState()) {
+                FillEndFileInfos(result);
+            }
             if (extension_->SpecialVersionForCloneAndCloud() || extension_->UseFullBackupOnly()) {
-                UntarFile::GetInstance().IncrementalUnPacket(tarName, path, GetTarIncludes(tarName));
+                UntarFile::GetInstance().IncrementalUnPacket(tarName, path, result);
             } else {
-                UntarFile::GetInstance().IncrementalUnPacket(tarName, "/", GetTarIncludes(tarName));
+                UntarFile::GetInstance().IncrementalUnPacket(tarName, "/", result);
             }
             HILOGI("Application recovered successfully, package path is %{public}s", tarName.c_str());
         }
@@ -699,9 +713,13 @@ void BackupExtExtension::AsyncTaskBackup(const string config)
     });
 }
 
-static void RestoreBigFilesForSpecialCloneCloud(ExtManageInfo item)
+void BackupExtExtension::RestoreBigFilesForSpecialCloneCloud(ExtManageInfo item)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
+    if (BackupPara::GetBackupDebugState()) {
+        HILOGE("LHC... special big files %{public}s -> size(%{public}lu)", item.hashName.c_str(), item.sta.st_size);
+        endFileInfos_[item.hashName] = item.sta.st_size;
+    }
     struct stat &sta = item.sta;
     string fileName = item.hashName;
     if (chmod(fileName.c_str(), sta.st_mode) != 0) {
@@ -719,7 +737,7 @@ static void RestoreBigFilesForSpecialCloneCloud(ExtManageInfo item)
     }
 }
 
-static ErrCode RestoreTarForSpecialCloneCloud(ExtManageInfo item)
+ErrCode BackupExtExtension::RestoreTarForSpecialCloneCloud(ExtManageInfo item)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     string tarName = item.hashName;
@@ -739,11 +757,10 @@ static ErrCode RestoreTarForSpecialCloneCloud(ExtManageInfo item)
     return ERR_OK;
 }
 
-static ErrCode RestoreFilesForSpecialCloneCloud()
+ErrCode BackupExtExtension::RestoreFilesForSpecialCloneCloud()
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     // 获取索引文件内容
-    string path = string(BConstants::PATH_BUNDLE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE);
     UniqueFd fd(open(INDEX_FILE_RESTORE.data(), O_RDONLY));
     if (fd < 0) {
         HILOGE("Failed to open index json file = %{private}s, err = %{public}d", INDEX_FILE_RESTORE.c_str(), errno);
@@ -834,7 +851,7 @@ static void RestoreBigFileAfter(const string &fileName,
     }
 }
 
-static void RestoreBigFiles(bool appendTargetPath)
+void BackupExtExtension::RestoreBigFiles(bool appendTargetPath)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
     // 获取索引文件内容
@@ -871,7 +888,10 @@ static void RestoreBigFiles(bool appendTargetPath)
         if (!RestoreBigFilePrecheck(fileName, path, item.hashName, filePath)) {
             continue;
         }
-
+        if (BackupPara::GetBackupDebugState()) {
+            HILOGE("LHC... big files %{public}s -> size(%{public}lu)", filePath.c_str(), item.sta.st_size);
+            endFileInfos_[filePath] = item.sta.st_size;
+        }
         if (!BFile::CopyFile(fileName, filePath)) {
             HILOGE("failed to copy the file. err = %{public}d", errno);
             continue;
@@ -882,6 +902,19 @@ static void RestoreBigFiles(bool appendTargetPath)
     HILOGI("End Restore Big Files");
 }
 
+void BackupExtExtension::FillEndFileInfos(const unordered_map<string, struct ReportFileInfo> &result)
+{
+    for (const auto &it : result) {
+        std::string filePath = it.first;
+        if (!filePath.empty() && filePath.size() <= PATH_MAX) {
+            HILOGE("LHC... big files %{public}s -> size(%{public}lu)", filePath.c_str(), it.second.size);
+            endFileInfos_[filePath] = it.second.size;
+        } else {
+            HILOGE("FileName : %{public}s error", GetAnonyPath(filePath).c_str());
+        }
+    }
+}
+
 static void DeleteBackupTars()
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -957,7 +990,7 @@ void BackupExtExtension::AsyncTaskRestore(std::set<std::string> fileSet,
         try {
             int ret = ERR_OK;
             if (ptr->extension_->SpecialVersionForCloneAndCloud()) {
-                ret = RestoreFilesForSpecialCloneCloud();
+                ret = ptr->RestoreFilesForSpecialCloneCloud();
                 if (ret == ERR_OK) {
                     ptr->AsyncTaskRestoreForUpgrade();
                 } else {
@@ -967,6 +1000,9 @@ void BackupExtExtension::AsyncTaskRestore(std::set<std::string> fileSet,
                 return;
             }
             // 解压
+            // if (BackupPara::GetBackupDebugState()) {
+            //     ptr->CheckTmpDirFileInfos();
+            // }
             for (auto item : fileSet) { // 处理要解压的tar文件
                 if (ExtractFileExt(item) == "tar" && !IsUserTar(item, extManageInfo)) {
                     ret = ptr->DoRestore(item);
@@ -976,8 +1012,12 @@ void BackupExtExtension::AsyncTaskRestore(std::set<std::string> fileSet,
             // 目的地址是否需要拼接path(临时目录)，FullBackupOnly为true并且非特殊场景
             bool appendTargetPath =
                 ptr->extension_->UseFullBackupOnly() && !ptr->extension_->SpecialVersionForCloneAndCloud();
-            RestoreBigFiles(appendTargetPath);
+            ptr->RestoreBigFiles(appendTargetPath);
             DeleteBackupTars();
+            // std::map<std::string, off_t> idxEndFiles;
+            // if (BackupPara::GetBackupDebugState()) {
+            //     ptr->CheckRestoreFileInfos(idxEndFiles);
+            // }
             if (ret == ERR_OK) {
                 ptr->AsyncTaskRestoreForUpgrade();
             } else {
@@ -1013,17 +1053,22 @@ void BackupExtExtension::AsyncTaskIncrementalRestore()
         BExcepUltils::BAssert(ptr, BError::Codes::EXT_BROKEN_FRAMEWORK, "Ext extension handle have been released");
         BExcepUltils::BAssert(ptr->extension_, BError::Codes::EXT_INVAL_ARG, "Extension handle have been released");
         try {
+            if (BackupPara::GetBackupDebugState()) {
+                ptr->CheckTmpDirFileInfos();
+            }
             // 解压
             int ret = ptr->DoIncrementalRestore();
             // 恢复用户tar包以及大文件
             // 目的地址是否需要拼接path(临时目录)，FullBackupOnly为true并且非特殊场景
             bool appendTargetPath =
                 ptr->extension_->UseFullBackupOnly() && !ptr->extension_->SpecialVersionForCloneAndCloud();
-            RestoreBigFiles(appendTargetPath);
+            ptr->RestoreBigFiles(appendTargetPath);
 
             // delete 1.tar/manage.json
             DeleteBackupIncrementalTars();
-
+            if (BackupPara::GetBackupDebugState()) {
+                ptr->CheckRestoreFileInfos();
+            }
             if (ret == ERR_OK) {
                 HILOGI("after extra, do incremental restore.");
                 ptr->AsyncTaskIncrementalRestoreForUpgrade();
@@ -1060,7 +1105,13 @@ void BackupExtExtension::AsyncTaskIncreRestoreSpecialVersion()
         auto ptr = obj.promote();
         BExcepUltils::BAssert(ptr, BError::Codes::EXT_BROKEN_FRAMEWORK, "Ext extension handle have been released");
         try {
-            int ret = RestoreFilesForSpecialCloneCloud();
+            if (BackupPara::GetBackupDebugState()) {
+                ptr->CheckTmpDirFileInfos(true);
+            }
+            int ret = ptr->RestoreFilesForSpecialCloneCloud();
+            if (BackupPara::GetBackupDebugState()) {
+                ptr->CheckRestoreFileInfos();
+            }
             if (ret == ERR_OK) {
                 ptr->AsyncTaskIncrementalRestoreForUpgrade();
             } else {
@@ -2006,4 +2057,63 @@ void BackupExtExtension::RefreshTimeInfo(std::chrono::system_clock::time_point &
         fdSendNum = 0;
     }
 }
+
+std::map<std::string, off_t> BackupExtExtension::GetIdxFileInfos(bool isSpecialVersion)
+{
+    string restoreDir = isSpecialVersion ? "" :
+        string(BConstants::PATH_BUNDLE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE);
+    auto extManageInfo = GetExtManageInfo();
+    HILOGE("LHC... idx file size = %{public}ld", extManageInfo.size());
+    std::map<std::string, off_t> idxFileInfos;
+    for (size_t i = 0; i < extManageInfo.size(); ++i) {
+        std::string realPath = restoreDir + extManageInfo[i].hashName;
+        idxFileInfos[realPath] = extManageInfo[i].sta.st_size;
+    }
+    return idxFileInfos;
+}
+
+tuple<bool, vector<string>> BackupExtExtension::CheckTmpDirFileInfos(bool isSpecialVersion)
+{
+    vector<string> errFiles;
+    auto idxFileInfos = GetIdxFileInfos(isSpecialVersion);
+    struct stat attr;
+    for (auto it : idxFileInfos) {
+        if (it.first.size() >= PATH_MAX || stat(it.first.data(), &attr) == -1) {
+            HILOGE("LHC...Failed to get stat of %{public}s, errno = %{public}d",
+                it.first.c_str(), errno);
+            // HILOGE("Failed to get stat of %{public}s, errno = %{public}d",
+            //     GetAnonyPath(it.first).c_str(), errno);
+        }
+        if (it.second != attr.st_size) {
+            HILOGE("LHC...recf file:%{public}s size error", it.first.c_str());
+            //HILOGE("Recf file:%{public}s size error", GetAnonyPath(it.first.c_str()));
+            errFiles.emplace_back(it.first);
+        }
+    }
+    if (!errFiles.empty()) {
+        HILOGE("LHC...The received file and idx is not same");
+    }
+    HILOGE("LHC...The received file and idx is same");
+    return {false, errFiles};
+}
+
+tuple<bool, vector<string>> BackupExtExtension::CheckRestoreFileInfos()
+{
+    vector<string> errFiles;
+    struct stat curFileStat {};
+    for (const auto& it : endFileInfos_) {
+        HILOGE("LHC... endfileInfos file = %{public}s -> %{public}ld", it.first.c_str(), it.second);
+        if (lstat(it.first.c_str(), &curFileStat) != 0) {
+            HILOGE("LHC...Failed to lstat, err = %{public}d", errno);
+            errFiles.emplace_back(it.first);
+        } else if (curFileStat.st_size != it.second) {
+            HILOGE("LHC...File size check error, file: %{public}s", it.first.c_str());
+            errFiles.emplace_back(it.first);
+        }
+    }
+    if (errFiles.size()) {
+        return {false, errFiles};
+    }
+    return {true, errFiles};
+}
 } // namespace OHOS::FileManagement::Backup
diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp
index 523d2cd95..f8e831a52 100644
--- a/frameworks/native/backup_ext/src/tar_file.cpp
+++ b/frameworks/native/backup_ext/src/tar_file.cpp
@@ -400,6 +400,7 @@ bool TarFile::FillSplitTailBlocks()
         HILOGE("Failed to stat file %{public}s, err = %{public}d", currentTarName_.c_str(), errno);
         throw BError(BError::Codes::EXT_BACKUP_PACKET_ERROR, "FillSplitTailBlocks Failed to stat file");
     }
+    HILOGE("LHC... staTar.st_size = %{public}ld", staTar.st_size);
 
     if (staTar.st_size == 0 && tarFileCount_ > 0 && fileCount_ == 0) {
         fclose(currentTarFile_);
diff --git a/frameworks/native/backup_ext/src/untar_file.cpp b/frameworks/native/backup_ext/src/untar_file.cpp
index 502bd58ad..0f6f5309f 100644
--- a/frameworks/native/backup_ext/src/untar_file.cpp
+++ b/frameworks/native/backup_ext/src/untar_file.cpp
@@ -102,22 +102,24 @@ UntarFile &UntarFile::GetInstance()
     return instance;
 }
 
-int UntarFile::UnPacket(const string &tarFile, const string &rootPath)
+std::tuple<int, std::map<std::string, off_t>> UntarFile::UnPacket(
+    const std::string &tarFile, const std::string &rootPath)
 {
     tarFilePtr_ = fopen(tarFile.c_str(), "rb");
     if (tarFilePtr_ == nullptr) {
         HILOGE("Failed to open tar file %{public}s, err = %{public}d", tarFile.c_str(), errno);
-        return errno;
+        return {errno, {}};
     }
 
-    if (ParseTarFile(rootPath) != 0) {
+    auto [ret, fileInfos] = ParseTarFile(rootPath);
+    if (ret != 0) {
         HILOGE("Failed to parse tar file");
     }
 
     fclose(tarFilePtr_);
     tarFilePtr_ = nullptr;
 
-    return 0;
+    return {ret, fileInfos};
 }
 
 int UntarFile::IncrementalUnPacket(const string &tarFile, const string &rootPath,
@@ -140,7 +142,7 @@ int UntarFile::IncrementalUnPacket(const string &tarFile, const string &rootPath
     return 0;
 }
 
-void UntarFile::HandleTarBuffer(const string &buff, const string &name, FileStatInfo &info)
+off_t UntarFile::HandleTarBuffer(const string &buff, const string &name, FileStatInfo &info)
 {
     info.mode = static_cast<mode_t>(ParseOctalStr(&buff[0] + TMODE_BASE, TMODE_LEN));
     info.uid = static_cast<uid_t>(ParseOctalStr(&buff[0] + TUID_BASE, TUID_LEN));
@@ -158,12 +160,13 @@ void UntarFile::HandleTarBuffer(const string &buff, const string &name, FileStat
     }
     if (realName.length() > 0 && realName[0] == '/') {
         info.fullPath = realName.substr(1, realName.length() - 1);
-        return;
+        return tarFileSize_;
     }
     info.fullPath = realName;
+    return tarFileSize_;
 }
 
-int UntarFile::ParseTarFile(const string &rootPath)
+std::tuple<int, std::map<std::string, off_t>> UntarFile::ParseTarFile(const string &rootPath)
 {
     // re-parse tar header
     rootPath_ = rootPath;
@@ -181,12 +184,13 @@ int UntarFile::ParseTarFile(const string &rootPath)
     if (ret != 0) {
         HILOGE("Failed to fseeko reback SEEK_SET, err = %{public}d", errno);
     }
+    std::map<std::string, off_t> fileInfos;
 
     while (1) {
         readCnt_ = fread(buff, 1, BLOCK_SIZE, tarFilePtr_);
         if (readCnt_ < BLOCK_SIZE) {
             HILOGE("Parsing tar file completed, read data count is less then block size.");
-            return 0;
+            return {0, {}};
         }
         TarHeader *header = reinterpret_cast<TarHeader *>(buff);
         // two empty continuous block indicate end of file
@@ -195,7 +199,7 @@ int UntarFile::ParseTarFile(const string &rootPath)
             size_t tailRead = fread(tailBuff, 1, BLOCK_SIZE, tarFilePtr_);
             if (tailRead == BLOCK_SIZE && IsEmptyBlock(tailBuff)) {
                 HILOGE("Parsing tar file completed, tailBuff is empty.");
-                return 0;
+                return {0, {}};
             }
         }
         // check header
@@ -206,13 +210,15 @@ int UntarFile::ParseTarFile(const string &rootPath)
                 ret = ERR_FORMAT;
             }
             HILOGE("invalid tar block header");
-            return ret;
+            return {ret, {}};
         }
-        HandleTarBuffer(string(buff, BLOCK_SIZE), header->name, info);
+        off_t fileSize = HandleTarBuffer(string(buff, BLOCK_SIZE), header->name, info);
         ParseFileByTypeFlag(header->typeFlag, info);
+
+        fileInfos[info.fullPath] = fileSize;
     }
 
-    return ret;
+    return {ret, fileInfos};
 }
 
 int UntarFile::ParseIncrementalTarFile(const string &rootPath)
diff --git a/interfaces/kits/js/backup/session_restore_n_exporter.cpp b/interfaces/kits/js/backup/session_restore_n_exporter.cpp
index 71d362b8d..1b943259f 100644
--- a/interfaces/kits/js/backup/session_restore_n_exporter.cpp
+++ b/interfaces/kits/js/backup/session_restore_n_exporter.cpp
@@ -485,9 +485,9 @@ napi_value SessionRestoreNExporter::PublishFile(napi_env env, napi_callback_info
         if (SAUtils::IsSABundleName(fileName)) {
             HILOGI("SA %{public}s pushlish file", bundleName.c_str());
             if (fcntl(std::atoi(fileName.c_str()), F_GETFD) == -1) {
-            HILOGE("PublishFile fd is invalid.");
-            return NError(BError(BError::Codes::SDK_INVAL_ARG, "PublishFile fd is invalid.").GetCode());
-        }
+                HILOGE("PublishFile fd is invalid.");
+                return NError(BError(BError::Codes::SDK_INVAL_ARG, "PublishFile fd is invalid.").GetCode());
+            }
             return NError(entity->sessionSheet->PublishSAFile(fileInfo, UniqueFd(std::atoi(fileName.c_str()))));
         }
         return NError(entity->sessionSheet->PublishFile(fileInfo));
diff --git a/tests/unittests/backup_ext/untar_file_test.cpp b/tests/unittests/backup_ext/untar_file_test.cpp
index 9d79edb43..d595bac68 100644
--- a/tests/unittests/backup_ext/untar_file_test.cpp
+++ b/tests/unittests/backup_ext/untar_file_test.cpp
@@ -108,7 +108,7 @@ HWTEST_F(UntarFileTest, SUB_Untar_File_UnPacket_0100, testing::ext::TestSize.Lev
     try {
         string tarFile("");
         string rootPath("");
-        int ret = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
+        auto {ret, fileInfos} = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
         EXPECT_EQ(ret, ENOENT);
         ClearCache();
     } catch (...) {
@@ -151,7 +151,7 @@ HWTEST_F(UntarFileTest, SUB_Untar_File_UnPacket_0200, testing::ext::TestSize.Lev
             GTEST_LOG_(INFO) << " execute tar failure, errno :" << errno;
             throw BError(errno);
         }
-        int ret = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
+        auto {ret, fileInfos} = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
         EXPECT_EQ(ret, 0);
         ClearCache();
     } catch (...) {
@@ -186,7 +186,7 @@ HWTEST_F(UntarFileTest, SUB_Untar_File_UnPacket_0300, testing::ext::TestSize.Lev
         SaveStringToFile(aFile, "hello");
 
         string rootPath(root);
-        int ret = UntarFile::GetInstance().UnPacket(aFile, rootPath);
+        auto {ret, fileInfos} = UntarFile::GetInstance().UnPacket(aFile, rootPath);
         EXPECT_EQ(ret, 0);
         ClearCache();
     } catch (...) {
@@ -225,7 +225,7 @@ HWTEST_F(UntarFileTest, SUB_Untar_File_UnPacket_0400, testing::ext::TestSize.Lev
         }
 
         string rootPath(root);
-        int ret = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
+        auto {ret, fileInfos} = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
         EXPECT_EQ(ret, 0);
         ClearCache();
     } catch (...) {
@@ -276,7 +276,7 @@ HWTEST_F(UntarFileTest, SUB_Untar_File_UnPacket_0500, testing::ext::TestSize.Lev
         TarFile::GetInstance().Packet(smallFiles, "test", root, tarMap);
 
         string rootPath(root);
-        int ret = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
+        auto {ret, fileInfos} = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
         EXPECT_EQ(ret, 0);
         ClearCache();
     } catch (...) {
diff --git a/utils/include/b_filesystem/b_dir.h b/utils/include/b_filesystem/b_dir.h
index 753529cb6..e254bc3a9 100644
--- a/utils/include/b_filesystem/b_dir.h
+++ b/utils/include/b_filesystem/b_dir.h
@@ -56,6 +56,19 @@ public:
      * @return std::vector<std::string> 目录集合
      */
     static std::vector<std::string> GetDirs(const std::vector<std::string_view> &paths);
+
+    // /**
+    //  * @brief 读取指定目录下文件及大小清单
+    //  *
+    //  * @param paths 目录集合可带有通配符路径
+    //  * @return std::vector<std::string> 目录集合
+    //  */
+    // static std::tuple<ErrCode, std::map<std::string, off_t>, std::map<std::string, off_t>,
+    //     std::map<std::string, off_t>> GetDirFiles(const std::string &path, bool recursion);
+
+    // static bool CheckIfFilterFileInfos(const std::string &path, struct stat &sta);
+
+    // static std::string TrimFrontSymbol(const std::string &path);
 };
 } // namespace OHOS::FileManagement::Backup
 
diff --git a/utils/include/b_json/b_json_cached_entity.h b/utils/include/b_json/b_json_cached_entity.h
index aa6864ff6..7b83c7bcd 100644
--- a/utils/include/b_json/b_json_cached_entity.h
+++ b/utils/include/b_json/b_json_cached_entity.h
@@ -59,6 +59,7 @@ public:
         Json::StreamWriterBuilder builder;
         const std::string jsonFileContent = Json::writeString(builder, obj_);
         HILOGD("Try to persist a Json object, whose content reads: %{public}s", jsonFileContent.c_str());
+        HILOGI("LHC...Try to persist a Json object, whose content reads: %{public}s", jsonFileContent.c_str());
 
         BFile::Write(srcFile_, jsonFileContent);
     }
diff --git a/utils/include/b_json/b_json_entity_ext_manage.h b/utils/include/b_json/b_json_entity_ext_manage.h
index f52f47bc3..19ea9d89a 100644
--- a/utils/include/b_json/b_json_entity_ext_manage.h
+++ b/utils/include/b_json/b_json_entity_ext_manage.h
@@ -62,6 +62,13 @@ public:
      */
     std::vector<ExtManageInfo> GetExtManageInfo() const;
 
+    // /**
+    //  * @brief 获取索引文件及大小
+    //  *
+    //  * @return map<string, pair<string, struct stat>>
+    //  */
+    // std::map<std::string, off_t> GetExtManageFilesAndSize() const;
+
 public:
     /**
      * @brief 构造方法，具备T(Json::Value&, std::any)能力的构造函数
diff --git a/utils/include/b_ohos/startup/backup_para.h b/utils/include/b_ohos/startup/backup_para.h
index 1cdf80737..c5c6ef481 100644
--- a/utils/include/b_ohos/startup/backup_para.h
+++ b/utils/include/b_ohos/startup/backup_para.h
@@ -49,6 +49,13 @@ public:
      * @return 获取的配置项backup.overrideIncrementalRestore的值为true时则返回true，否则返回false
      */
     bool GetBackupOverrideIncrementalRestore();
+
+    /**
+     * @brief 获取backup.para配置项backupDebugState的值
+     *
+     * @return 获取的配置项backup.backupDebugState的值为true时则返回true，否则返回false
+     */
+    static bool GetBackupDebugState();
 };
 } // namespace OHOS::FileManagement::Backup
 
diff --git a/utils/src/b_filesystem/b_dir.cpp b/utils/src/b_filesystem/b_dir.cpp
index f8c70da1b..fffe2edcd 100644
--- a/utils/src/b_filesystem/b_dir.cpp
+++ b/utils/src/b_filesystem/b_dir.cpp
@@ -35,6 +35,8 @@
 namespace OHOS::FileManagement::Backup {
 using namespace std;
 const int32_t PATH_MAX_LEN = 4096;
+const char* IDX_FILE = "manage.json";
+const char* IDX_RP_FILE = "manage.json.rp";
 
 static bool IsEmptyDirectory(const string &path)
 {
@@ -258,5 +260,4 @@ vector<string> BDir::GetDirs(const vector<string_view> &paths)
     vector<string> dirs(inc.begin(), inc.end());
     return dirs;
 }
-
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/utils/src/b_json/b_json_entity_ext_manage.cpp b/utils/src/b_json/b_json_entity_ext_manage.cpp
index 828ebed23..7ead81207 100644
--- a/utils/src/b_json/b_json_entity_ext_manage.cpp
+++ b/utils/src/b_json/b_json_entity_ext_manage.cpp
@@ -233,4 +233,44 @@ std::vector<ExtManageInfo> BJsonEntityExtManage::GetExtManageInfo() const
 
     return infos;
 }
+
+// std::map<std::string, off_t> BJsonEntityExtManage::GetExtManageFilesAndSize() const
+// {
+//     if (!obj_) {
+//         HILOGE("Uninitialized JSon Object reference");
+//         return {};
+//     }
+//     if (!obj_.isArray()) {
+//         HILOGE("json object isn't an array");
+//         return {};
+//     }
+//     std::map<std::string, off_t> IdxFileInfos;
+//     for (const Json::Value &item : obj_) {
+//         if (!(item.isObject() && item.isMember("information"))) {
+//             continue;
+//         }
+
+//         struct stat sta = {};
+//         string path = item["information"].isMember("path") && item["information"]["path"].isString()
+//                           ? item["information"]["path"].asString()
+//                           : "";
+//         if (item["information"].isMember("stat")) {
+//             sta = JsonValue2Stat(item["information"]["stat"]);
+//         }
+//         string fileName = item.isMember("fileName") && item["fileName"].isString() ? item["fileName"].asString() : "";
+//         HILOGD("GetExtManageInfo, fileName:%{public}s ", fileName.data());
+//         if (fileName.empty()) {
+//             continue;
+//         }
+//         string restorePath = string(BConstants::PATH_BUNDLE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE);
+//         if (path.find("/") == 0) {
+//             path = path.substr(1); // 1: rm '/'
+//         }
+//         if (fileName.find(path) == string::npos) {
+//             fileName = restorePath + fileName;
+//         }
+//         IdxFileInfos.try_emplace(fileName, sta.st_size);
+//     }
+//     return IdxFileInfos;
+// }
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/utils/src/b_ohos/startup/backup_para.cpp b/utils/src/b_ohos/startup/backup_para.cpp
index c5f9c1d9d..0732d624f 100644
--- a/utils/src/b_ohos/startup/backup_para.cpp
+++ b/utils/src/b_ohos/startup/backup_para.cpp
@@ -17,6 +17,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <sstream>
 #include <string>
 #include <tuple>
 
@@ -27,7 +28,7 @@
 
 namespace OHOS::FileManagement::Backup {
 using namespace std;
-
+const char* BACKUP_DEBUG_STATE = "sys.backup.check.enable";
 /**
  * @brief 获取配置参数的值
  *
@@ -106,4 +107,17 @@ tuple<bool, int32_t> BackupPara::GetBackupDebugOverrideAccount()
     }
     return {false, 0};
 }
+
+bool BackupPara::GetBackupDebugState()
+{
+    char paraValue[30] = {0}; // 30: for system paramter
+    auto res = GetParameter(BACKUP_DEBUG_STATE, "-1", paraValue, sizeof(paraValue));
+    HILOGE("GetParameter fail, paraValue:%{public}s res:%{public}d", paraValue, res);
+    if (res <= 0) {
+        HILOGE("GetParameter fail, key:%{public}s res:%{public}d", BACKUP_DEBUG_STATE, res);
+        return false;
+    }
+    std::string result(paraValue);
+    return result == "true";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
-- 
Gitee