• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef OHOS_FILEMGMT_BACKUP_BACKUP_EXT_EXTENSION_H
17 #define OHOS_FILEMGMT_BACKUP_BACKUP_EXT_EXTENSION_H
18 
19 #include <chrono>
20 #include <memory>
21 #include <shared_mutex>
22 #include <string>
23 #include <vector>
24 #include <tuple>
25 
26 #include <sys/stat.h>
27 
28 #include "b_json/b_json_entity_extension_config.h"
29 #include "b_json/b_json_entity_ext_manage.h"
30 #include "b_json/b_report_entity.h"
31 #include "b_radar/b_radar.h"
32 #include "b_radar/radar_app_statistic.h"
33 #include "ext_backup_js.h"
34 #include "extension_stub.h"
35 #include "service_common.h"
36 #include "iservice.h"
37 #include "tar_file.h"
38 #include "thread_pool.h"
39 #include "timer.h"
40 #include "unique_fd.h"
41 #include "untar_file.h"
42 
43 namespace OHOS::FileManagement::Backup {
44 using CompareFilesResult = tuple<map<string, struct ReportFileInfo>,
45                                  map<string, struct ReportFileInfo>,
46                                  map<string, struct ReportFileInfo>>;
47 class BackupExtExtension : public ExtensionStub {
48 public:
49     ErrCode GetFileHandleWithUniqueFd(const std::string &fileName, int32_t &errCode, int& fd) override;
50     ErrCode HandleClear() override;
51     ErrCode PublishFile(const std::string &fileName) override;
52     ErrCode HandleBackup(bool isClearData) override;
53     ErrCode HandleRestore(bool isClearData) override;
54     ErrCode GetIncrementalFileHandle(const std::string &fileName, int &fd, int &reportFd, int32_t &fdErrCode) override;
55     ErrCode PublishIncrementalFile(const std::string &fileName) override;
56     ErrCode HandleIncrementalBackup(int incrementalFd, int manifestFd) override;
57     ErrCode IncrementalOnBackup(bool isClearData) override;
58     ErrCode GetIncrementalBackupFileHandle(int &fd, int &reportFd) override;
59     ErrCode GetBackupInfo(std::string &result) override;
60     ErrCode UpdateFdSendRate(const std::string &bundleName, int32_t sendRate) override;
61     void AsyncTaskRestoreForUpgrade(void);
62     void ExtClear(void);
63     void AsyncTaskIncrementalRestoreForUpgrade(void);
64     ErrCode User0OnBackup() override;
65     ErrCode UpdateDfxInfo(int64_t uniqId, uint32_t extConnectSpend, const std::string &bundleName) override;
66     ErrCode CleanBundleTempDir() override;
67     ErrCode HandleOnRelease(int32_t scenario) override;
68     ErrCode HandleGetCompatibilityInfo(const string &extInfo, int32_t scenario, string &compatibilityInfo) override;
69 
70 public:
BackupExtExtension(const std::shared_ptr<Backup::ExtBackup> & extension,const std::string & bundleName)71     explicit BackupExtExtension(const std::shared_ptr<Backup::ExtBackup> &extension,
72         const std::string &bundleName) : extension_(extension)
73     {
74         if (extension_ != nullptr) {
75             extension_->SetBackupExtExtension(this);
76         }
77         bundleName_ = bundleName;
78         threadPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
79         onProcessTaskPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
80         reportOnProcessRetPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
81         doBackupPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
82         onReleaseTaskPool_.Start(BConstants::EXTENSION_THREAD_POOL_COUNT);
83         SetStagingPathProperties();
84         appStatistic_ = std::make_shared<RadarAppStatistic>();
85     }
~BackupExtExtension()86     ~BackupExtExtension()
87     {
88         onProcessTimeoutTimer_.Shutdown();
89         threadPool_.Stop();
90         onProcessTaskPool_.Stop();
91         reportOnProcessRetPool_.Stop();
92         doBackupPool_.Stop();
93         onReleaseTaskPool_.Stop();
94         if (callJsOnProcessThread_.joinable()) {
95             callJsOnProcessThread_.join();
96         }
97     }
98 
99 private:
100     /**
101      * @brief verify caller uid
102      *
103      */
104     void VerifyCaller();
105 
106     /**
107      * @brief backup
108      *
109      * @param bigFileInfo bigfiles to be backup
110      * @param bigFileInfoBackuped bigfiles have been backuped
111      * @param smallFiles smallfiles to be backup
112      * @param includesNum sizeof includes
113      * @param excludesNum sizeof excludes
114      */
115     int DoBackup(TarMap &bigFileInfo, TarMap &bigFileInfoBackuped, map<string, size_t> &smallFiles,
116                  uint32_t includesNum, uint32_t excludesNum);
117 
118     /**
119      * @brief backup
120      *
121      * @param bigFileInfo bigfiles to be backup
122      * @param backupedFileSize backuped file size
123      */
124     int DoBackupBigFiles(TarMap &bigFileInfo, uint32_t backupedFileSize);
125 
126     /**
127      * @brief restore
128      *
129      * @param fileName name of the file that to be untar
130      */
131     int DoRestore(const string &fileName, const off_t fileSize);
132 
133     /**
134      * @brief incremental restore
135      *
136      */
137     int DoIncrementalRestore();
138 
139     /** @brief clear backup restore data */
140     void DoClear();
141 
142     /** @brief inner of doing clear backup restore data */
143     void DoClearInner();
144 
145     /**
146      * @brief extension backup restore is done
147      *
148      * @param errCode
149      */
150     void AppDone(ErrCode errCode);
151 
152     /**
153      * @brief extension backup restore is done
154      *
155      * @param restoreRetInfo app restore reportInfo
156      */
157     void AppResultReport(const std::string restoreRetInfo, BackupRestoreScenario scenario,
158         ErrCode errCode = 0);
159 
160     /**
161      * @brief extension process Info
162      *
163      * @param restoreRetInfo app processInfo
164      * @param scenario backup or restore
165      */
166     void ReportAppProcessInfo(const std::string processInfo, BackupRestoreScenario scenario);
167 
168     /**
169      * @brief Executing Backup Tasks Asynchronously
170      *
171      * @param extAction action
172      *
173      * @param config user configure
174      */
175     void AsyncTaskBackup(const std::string config);
176 
177     /**
178      * @brief Executing Restoration Tasks Asynchronously
179      *
180      */
181     void AsyncTaskRestore(std::set<std::string> fileSet, const std::vector<ExtManageInfo> extManageInfo);
182 
183     /**
184      * @brief Executing Incremental Restoration Tasks Asynchronously
185      *
186      */
187     void AsyncTaskIncrementalRestore();
188 
189     /**
190      * @brief Executing Incremental Restoration Tasks Asynchronously for special clone & cloud
191      *
192      */
193     void AsyncTaskIncreRestoreSpecialVersion();
194 
195     void AsyncTaskOnBackup();
196 
197     bool IfAllowToBackupRestore();
198 
199     void AsyncTaskUser0Backup();
200 
201     void DoUser0Backup(const BJsonEntityExtensionConfig &usrConfig);
202 
203     int User0DoBackup(const BJsonEntityExtensionConfig &usrConfig);
204 
205     int DoIncrementalBackup(const std::vector<struct ReportFileInfo> &allFiles,
206                             const std::vector<struct ReportFileInfo> &smallFiles,
207                             const std::vector<struct ReportFileInfo> &bigFiles);
208 
209     void FillFileInfos(UniqueFd incrementalFd,
210                        UniqueFd manifestFd,
211                        vector<struct ReportFileInfo> &allFiles,
212                        vector<struct ReportFileInfo> &smallFiles,
213                        vector<struct ReportFileInfo> &bigFiles);
214     void FillFileInfosWithoutCmp(vector<struct ReportFileInfo> &allFiles,
215                                  vector<struct ReportFileInfo> &smallFiles,
216                                  vector<struct ReportFileInfo> &bigFiles,
217                                  UniqueFd incrementalFd);
218     void FillFileInfosWithCmp(vector<struct ReportFileInfo> &allFiles,
219                               vector<struct ReportFileInfo> &smallFiles,
220                               vector<struct ReportFileInfo> &bigFiles,
221                               const unordered_map<string, struct ReportFileInfo> &cloudFiles,
222                               UniqueFd incrementalFd);
223     void CompareFiles(vector<struct ReportFileInfo> &allFiles,
224                       vector<struct ReportFileInfo> &smallFiles,
225                       vector<struct ReportFileInfo> &bigFiles,
226                       const unordered_map<string, struct ReportFileInfo> &cloudFiles,
227                       unordered_map<string, struct ReportFileInfo> &localFilesInfo);
228 
229     void AsyncTaskDoIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd);
230     void AsyncTaskOnIncrementalBackup();
231     int DoIncrementalBackupTask(UniqueFd incrementalFd, UniqueFd manifestFd);
232     ErrCode IncrementalBigFileReady(TarMap &pkgInfo, const vector<struct ReportFileInfo> &bigInfos,
233         sptr<IService> proxy);
234     ErrCode BigFileReady(TarMap &bigFileInfo, sptr<IService> proxy, int backupedFileSize);
235     void WaitToSendFd(std::chrono::system_clock::time_point &startTime, int &fdSendNum);
236     void RefreshTimeInfo(std::chrono::system_clock::time_point &startTime, int &fdSendNum);
237     void IncrementalPacket(const vector<struct ReportFileInfo> &infos, TarMap &tar, sptr<IService> proxy);
238     void DoPacket(const map<string, size_t> &srcFiles, TarMap &tar, sptr<IService> proxy);
239     void CheckTmpDirFileInfos(bool isSpecialVersion = false);
240     std::map<std::string, off_t> GetIdxFileInfos(bool isSpecialVersion = false);
241     tuple<bool, vector<string>> CheckRestoreFileInfos();
242     void CheckAppIncrementalFileReadyResult(int32_t ret, std::string packageName, std::string file);
243     /**
244      * @brief extension incremental backup restore is done
245      *
246      * @param errCode
247      */
248     void AppIncrementalDone(ErrCode errCode);
249 
250     /**
251      * @brief start extension timer by ipc
252      *
253      * @param result
254      */
255     void StartExtTimer(bool &isExtStart);
256 
257     /**
258      * @brief start fwk timer by ipc
259      *
260      * @param errCode
261      */
262     void StartFwkTimer(bool &isFwkStart);
263 
264     /**
265      * @brief stop ext timer by ipc
266      */
267     bool StopExtTimer();
268 
269     /**
270      * @brief refresh datasize
271      *
272      * @param totalSize backup totalSize
273      */
274     bool RefreshDataSize(int64_t totalSize);
275 
276     /**
277      * @brief scanning files and calculate datasize
278      *
279      * @param usrConfig usrConfig
280      * @param totalSize totalSize
281      * @param bigFileInfo bigFileInfo
282      * @param smallFiles smallFiles info
283      */
284     tuple<ErrCode, uint32_t, uint32_t> CalculateDataSize(const BJsonEntityExtensionConfig &usrConfig,
285         int64_t &totalSize, TarMap &bigFileInfo, map<string, size_t> &smallFiles);
286 
287     /**
288      * @brief get increCallbackEx for execute onRestore with string param
289      *
290      * @param obj
291      */
292     std::function<void(ErrCode, const std::string)> IncreOnRestoreExCallback(wptr<BackupExtExtension> obj);
293 
294     /**
295      * @brief get increCallback for execute onRestore with string param
296      *
297      * @param obj
298      */
299     std::function<void(ErrCode, const std::string)> IncreOnRestoreCallback(wptr<BackupExtExtension> obj);
300 
301     /**
302      * @brief get callback for execute onRestore with string param
303      *
304      * @param obj
305      */
306     std::function<void(ErrCode, std::string)> OnRestoreCallback(wptr<BackupExtExtension> obj);
307 
308     /**
309      * @brief get callbackEx for execute onRestore with string param
310      *
311      * @param obj
312      */
313     std::function<void(ErrCode, std::string)> OnRestoreExCallback(wptr<BackupExtExtension> obj);
314 
315     /**
316      * @brief get callbackEx for execute appDone
317      */
318     std::function<void(ErrCode, std::string)> AppDoneCallbackEx(wptr<BackupExtExtension> obj);
319 
320     std::function<void(ErrCode, const std::string)> IncOnBackupExCallback(wptr<BackupExtExtension> obj);
321     std::function<void(ErrCode, const std::string)> IncOnBackupCallback(wptr<BackupExtExtension> obj);
322 
323     std::function<void(ErrCode, const std::string)> OnBackupExCallback(wptr<BackupExtExtension> obj);
324     std::function<void(ErrCode, const std::string)> OnBackupCallback(wptr<BackupExtExtension> obj);
325 
326     void HandleSpecialVersionRestore();
327     void DeleteBackupIncrementalIdxFile();
328     void DeleteBackupIdxFile();
329     void DeleteBackupIncrementalTars(const string &tarName);
330     void SetClearDataFlag(bool isClearData);
331     std::string GetBundlePath();
332     std::vector<ExtManageInfo> GetExtManageInfo(bool isSpecialVersion = false);
333     ErrCode RestoreFilesForSpecialCloneCloud();
334     void RestoreBigFilesForSpecialCloneCloud(const ExtManageInfo &item);
335     ErrCode RestoreTarForSpecialCloneCloud(const ExtManageInfo &item);
336     void RestoreBigFiles(bool appendTargetPath);
337     void FillEndFileInfos(const std::string &path, const unordered_map<string, struct ReportFileInfo> &result);
338     void RestoreBigFileAfter(const string &filePath, const struct stat &sta);
339     void DealIncreUnPacketResult(const off_t tarFileSize, const std::string &tarFileName,
340         const std::tuple<int, EndFileInfo, ErrFileInfo> &result);
341 
342     ErrCode StartOnProcessTaskThread(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
343     void FinishOnProcessTask();
344     void ExecCallOnProcessTask(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
345     void AsyncCallJsOnProcessTask(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
346     void SyncCallJsOnProcessTask(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
347     void StartOnProcessTimeOutTimer(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
348     void CloseOnProcessTimeOutTimer();
349     void UpdateOnStartTime();
350     int32_t GetOnStartTimeCost();
351     bool SetStagingPathProperties();
352 
353     std::function<void(std::string, int)> ReportErrFileByProc(wptr<BackupExtExtension> obj,
354         BackupRestoreScenario scenario);
355     std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncreFileHandleForNormalVersion(const std::string &fileName);
356     void RestoreOneBigFile(const std::string &path, const ExtManageInfo &item, const bool appendTargetPath);
357     int DealIncreRestoreBigAndTarFile();
358     ErrCode IncrementalTarFileReady(const TarMap &bigFileInfo, const vector<struct ReportFileInfo> &srcFiles,
359         sptr<IService> proxy);
360     ErrCode IncrementalAllFileReady(const TarMap &pkgInfo, const vector<struct ReportFileInfo> &srcFiles,
361         sptr<IService> proxy);
362     void ClearNoPermissionFiles(TarMap &pkgInfo, vector<std::string> &noPermissionFiles);
363     std::function<void(ErrCode, std::string)> ReportOnProcessResultCallback(wptr<BackupExtExtension> obj,
364         BackupRestoreScenario scenario);
365     UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode);
366     std::tuple<ErrCode, UniqueFd, UniqueFd> GetIncrementalFileHandle(const std::string &fileName);
367     ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd);
368     std::tuple<UniqueFd, UniqueFd> GetIncrementalBackupFileHandle();
369     bool IfCloudSpecialRestore(std::string tarName);
370     ErrCode CloudSpecialRestore(std::string tarName, std::string untarPath, off_t tarFileSize);
371     void GetTarIncludes(const string &tarName, unordered_map<string, struct ReportFileInfo> &infos);
372     void DeleteIndexAndRpFile();
373     ErrCode RestoreTarListForSpecialCloneCloud(const std::vector<const ExtManageInfo> &tarList);
374     bool CheckIsSplitTarList(const std::vector<const ExtManageInfo> &tarList);
375     ErrCode RestoreUnSplitTarListForSpecialCloneCloud(const std::vector<const ExtManageInfo> &tarList);
376     ErrCode RestoreSplitTarListForSpecialCloneCloud(const std::vector<const ExtManageInfo> &tarList);
377 
378     tuple<ErrCode, UniqueFd, UniqueFd> GetIncreFileHandleForSpecialVersion(const string &fileName);
379     void RmBigFileReportForSpecialCloneCloud(const std::string &srcFile);
380     string GetReportFileName(const string &fileName);
381     void OnBackupFinish();
382     void OnBackupExFinish();
383     void OnRestoreFinish();
384     void OnRestoreExFinish();
385     void DoBackupStart();
386     void DoBackupEnd();
387     void UpdateTarStat(uint64_t tarFileSize);
388     void CalculateDataSizeTask(const string &config);
389     void DoBackUpTask(const string &config);
390     TarMap convertFileToBigFiles(std::map<std::string, struct stat> files);
391     void PreDealExcludes(std::vector<std::string> &excludes);
392     template <typename T>
393     map<string, T> MatchFiles(map<string, T> files, vector<string> endExcludes);
394 
395     void HandleExtDisconnect(bool isAppResultReport, ErrCode errCode);
396     bool HandleGetExtOnRelease();
397     void HandleExtOnRelease(bool isAppResultReport, ErrCode errCode);
398     std::function<void(ErrCode, const std::string)> OnReleaseCallback(wptr<BackupExtExtension> obj);
399     std::function<void(ErrCode, const std::string)> GetComInfoCallback(wptr<BackupExtExtension> obj);
400 private:
401     pair<TarMap, map<string, size_t>> GetFileInfos(const vector<string> &includes, const vector<string> &excludes);
402     TarMap GetIncrmentBigInfos(const vector<struct ReportFileInfo> &files);
403     void UpdateFileStat(std::string filePath, uint64_t fileSize);
404     void ReportAppStatistic(const std::string &func, ErrCode errCode);
405     ErrCode IndexFileReady(const TarMap &pkgInfo, sptr<IService> proxy);
406 
407     std::shared_mutex lock_;
408     std::shared_ptr<ExtBackup> extension_;
409     std::string backupInfo_;
410     OHOS::ThreadPool threadPool_;
411     std::mutex updateSendRateLock_;
412     std::condition_variable startSendFdRateCon_;
413     std::condition_variable waitSendFdCon_;
414     std::mutex startSendMutex_;
415     std::mutex waitTimeLock_;
416     std::string bundleName_;
417     int32_t sendRate_ = BConstants::DEFAULT_FD_SEND_RATE;
418     bool isClearData_ {true};
419     bool isDebug_ {true};
420     std::map<std::string, off_t> endFileInfos_;
421     std::map<std::string, std::vector<ErrCode>> errFileInfos_;
422     bool isRpValid_ {false};
423 
424     std::thread callJsOnProcessThread_;
425     Utils::Timer onProcessTimeoutTimer_ {"onProcessTimeoutTimer_"};
426     uint32_t onProcessTimeoutTimerId_ { 0 };
427     std::atomic<int> onProcessTimeoutCnt_ { 0 };
428     std::atomic<bool> stopCallJsOnProcess_ {false};
429     std::condition_variable execOnProcessCon_;
430     std::mutex onProcessLock_;
431     std::atomic<bool> onProcessTimeout_ {false};
432     std::chrono::time_point<std::chrono::system_clock> g_onStart;
433     std::mutex onStartTimeLock_;
434     AppRadar::DoRestoreInfo radarRestoreInfo_ { 0 };
435     OHOS::ThreadPool onProcessTaskPool_;
436     std::atomic<bool> isFirstCallOnProcess_ {false};
437     std::atomic<bool> isExecAppDone_ {false};
438     OHOS::ThreadPool reportOnProcessRetPool_;
439     OHOS::ThreadPool doBackupPool_;
440 
441     std::mutex reportHashLock_;
442     std::map<std::string, std::string> reportHashSrcPathMap_;
443 
444     std::shared_ptr<RadarAppStatistic> appStatistic_ = nullptr;
445     BackupRestoreScenario curScenario_ { BackupRestoreScenario::FULL_BACKUP };
446 
447     OHOS::ThreadPool onReleaseTaskPool_;
448     std::atomic<bool> stopWaitOnRelease_ {false};
449     std::mutex onReleaseLock_;
450     std::condition_variable execOnReleaseCon_;
451     std::atomic<bool> needAppResultReport_ {false};
452     std::string appResultReportInfo_;
453     ErrCode appResultReportErrCode_ { 0 };
454     std::mutex execOnReleaseLock_ {};
455     std::atomic<bool> isOnReleased_ {false};
456 
457     std::mutex getCompatibilityInfoLock_ {};
458     std::condition_variable getCompatibilityInfoCon_ {};
459     std::atomic<bool> stopGetComInfo_ {false};
460     std::string compatibilityInfo_ {};
461 };
462 } // namespace OHOS::FileManagement::Backup
463 
464 #endif // OHOS_FILEMGMT_BACKUP_BACKUP_EXT_EXTENSION_H