blob: a8f32dec824e3a1cae4dc9800807ec665970158c [file] [log] [blame]
Songchun Fan3c82a302019-11-29 14:23:45 -08001/*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#pragma once
18
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -070019#include <android/content/pm/BnDataLoaderStatusListener.h>
Songchun Fan3c82a302019-11-29 14:23:45 -080020#include <android/content/pm/DataLoaderParamsParcel.h>
Alex Buynytskyycca2c112020-05-05 12:48:41 -070021#include <android/content/pm/FileSystemControlParcel.h>
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -070022#include <android/content/pm/IDataLoaderStatusListener.h>
Songchun Fan1b76ccf2021-02-24 22:25:59 +000023#include <android/os/incremental/BnIncrementalService.h>
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -070024#include <android/os/incremental/BnIncrementalServiceConnector.h>
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070025#include <android/os/incremental/BnStorageHealthListener.h>
Songchun Fana7098592020-09-03 11:45:53 -070026#include <android/os/incremental/BnStorageLoadingProgressListener.h>
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -080027#include <android/os/incremental/PerUidReadTimeouts.h>
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070028#include <android/os/incremental/StorageHealthCheckParams.h>
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -070029#include <binder/IAppOpsCallback.h>
Songchun Fan1b76ccf2021-02-24 22:25:59 +000030#include <binder/PersistableBundle.h>
Songchun Fan3c82a302019-11-29 14:23:45 -080031#include <utils/String16.h>
32#include <utils/StrongPointer.h>
Yurii Zubrytskyida208012020-04-07 15:35:21 -070033#include <ziparchive/zip_archive.h>
Songchun Fan3c82a302019-11-29 14:23:45 -080034
35#include <atomic>
36#include <chrono>
Yurii Zubrytskyida208012020-04-07 15:35:21 -070037#include <condition_variable>
38#include <functional>
Songchun Fan3c82a302019-11-29 14:23:45 -080039#include <limits>
40#include <map>
41#include <mutex>
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -070042#include <set>
Songchun Fan9b753082020-02-26 13:08:06 -080043#include <span>
Songchun Fan3c82a302019-11-29 14:23:45 -080044#include <string>
45#include <string_view>
Yurii Zubrytskyida208012020-04-07 15:35:21 -070046#include <thread>
Songchun Fan3c82a302019-11-29 14:23:45 -080047#include <unordered_map>
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -070048#include <unordered_set>
Songchun Fan3c82a302019-11-29 14:23:45 -080049#include <utility>
50#include <vector>
51
52#include "ServiceWrappers.h"
Songchun Fan3c82a302019-11-29 14:23:45 -080053#include "incfs.h"
54#include "path.h"
55
Songchun Fan3c82a302019-11-29 14:23:45 -080056namespace android::incremental {
57
58using MountId = int;
59using StorageId = int;
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -080060using FileId = incfs::FileId;
Songchun Fan3c82a302019-11-29 14:23:45 -080061using BlockIndex = incfs::BlockIndex;
62using RawMetadata = incfs::RawMetadata;
Songchun Fan3c82a302019-11-29 14:23:45 -080063using Seconds = std::chrono::seconds;
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070064using BootClockTsUs = uint64_t;
Songchun Fan3c82a302019-11-29 14:23:45 -080065
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -070066using IDataLoaderStatusListener = ::android::content::pm::IDataLoaderStatusListener;
67using DataLoaderStatusListener = ::android::sp<IDataLoaderStatusListener>;
Alex Buynytskyy04f73912020-02-10 08:34:18 -080068
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070069using StorageHealthCheckParams = ::android::os::incremental::StorageHealthCheckParams;
70using IStorageHealthListener = ::android::os::incremental::IStorageHealthListener;
71using StorageHealthListener = ::android::sp<IStorageHealthListener>;
Songchun Fana7098592020-09-03 11:45:53 -070072using IStorageLoadingProgressListener = ::android::os::incremental::IStorageLoadingProgressListener;
73using StorageLoadingProgressListener = ::android::sp<IStorageLoadingProgressListener>;
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070074
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -080075using PerUidReadTimeouts = ::android::os::incremental::PerUidReadTimeouts;
76
Alex Buynytskyycb163f92021-03-18 21:21:27 -070077struct IfsState {
78 // If mount is fully loaded.
79 bool fullyLoaded = false;
80 // If read logs are enabled on this mount. Populated only if fullyLoaded == true.
81 bool readLogsEnabled = false;
82 // If there was an error fetching any of the above.
83 bool error = false;
84};
85// Returns true if wants to be called again.
86using IfsStateCallback = std::function<bool(StorageId, IfsState)>;
87
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -080088class IncrementalService final {
Songchun Fan3c82a302019-11-29 14:23:45 -080089public:
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -080090 explicit IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir);
Songchun Fan3c82a302019-11-29 14:23:45 -080091
92#pragma GCC diagnostic push
93#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
94 ~IncrementalService();
95#pragma GCC diagnostic pop
96
97 static constexpr StorageId kInvalidStorageId = -1;
98 static constexpr StorageId kMaxStorageId = std::numeric_limits<int>::max();
99
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -0700100 static constexpr BootClockTsUs kMaxBootClockTsUs = std::numeric_limits<BootClockTsUs>::max();
101
Songchun Fan3c82a302019-11-29 14:23:45 -0800102 enum CreateOptions {
103 TemporaryBind = 1,
104 PermanentBind = 2,
105 CreateNew = 4,
106 OpenExisting = 8,
107
108 Default = TemporaryBind | CreateNew
109 };
110
111 enum class BindKind {
112 Temporary = 0,
113 Permanent = 1,
114 };
115
Alex Buynytskyy3697d9e2020-06-06 20:15:58 -0700116 enum StorageFlags {
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800117 ReadLogsAllowed = 1 << 0,
118 ReadLogsEnabled = 1 << 1,
119 };
120
121 struct LoadingProgress {
122 ssize_t filledBlocks;
123 ssize_t totalBlocks;
124
125 bool isError() const { return totalBlocks < 0; }
126 bool started() const { return totalBlocks > 0; }
127 bool fullyLoaded() const { return !isError() && (totalBlocks == filledBlocks); }
128
Alex Buynytskyy07694ed2021-01-27 06:58:55 -0800129 int blocksRemainingOrError() const {
130 return totalBlocks <= 0 ? totalBlocks : totalBlocks - filledBlocks;
131 }
132
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800133 float getProgress() const {
134 return totalBlocks < 0
135 ? totalBlocks
136 : totalBlocks > 0 ? double(filledBlocks) / double(totalBlocks) : 1.f;
137 }
Alex Buynytskyy3697d9e2020-06-06 20:15:58 -0700138 };
139
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800140 static FileId idFromMetadata(std::span<const uint8_t> metadata);
141 static inline FileId idFromMetadata(std::span<const char> metadata) {
142 return idFromMetadata({(const uint8_t*)metadata.data(), metadata.size()});
143 }
144
Alex Buynytskyy18b07a42020-02-03 20:06:00 -0800145 void onDump(int fd);
146
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700147 void onSystemReady();
Songchun Fan3c82a302019-11-29 14:23:45 -0800148
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700149 StorageId createStorage(std::string_view mountPoint,
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700150 content::pm::DataLoaderParamsParcel dataLoaderParams,
Alex Buynytskyy07694ed2021-01-27 06:58:55 -0800151 CreateOptions options);
Songchun Fan3c82a302019-11-29 14:23:45 -0800152 StorageId createLinkedStorage(std::string_view mountPoint, StorageId linkedStorage,
153 CreateOptions options = CreateOptions::Default);
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800154 StorageId openStorage(std::string_view path);
Songchun Fan3c82a302019-11-29 14:23:45 -0800155
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700156 bool startLoading(StorageId storage, content::pm::DataLoaderParamsParcel dataLoaderParams,
157 DataLoaderStatusListener statusListener,
158 const StorageHealthCheckParams& healthCheckParams,
159 StorageHealthListener healthListener,
160 std::vector<PerUidReadTimeouts> perUidReadTimeouts);
Alex Buynytskyy07694ed2021-01-27 06:58:55 -0800161
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800162 int bind(StorageId storage, std::string_view source, std::string_view target, BindKind kind);
Songchun Fan3c82a302019-11-29 14:23:45 -0800163 int unbind(StorageId storage, std::string_view target);
164 void deleteStorage(StorageId storage);
165
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800166 void disallowReadLogs(StorageId storage);
Alex Buynytskyy5e860ba2020-03-31 15:30:21 -0700167 int setStorageParams(StorageId storage, bool enableReadLogs);
168
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800169 int makeFile(StorageId storage, std::string_view path, int mode, FileId id,
Alex Buynytskyyb39d13e2020-09-12 16:12:36 -0700170 incfs::NewFileParams params, std::span<const uint8_t> data);
Songchun Fan96100932020-02-03 19:20:58 -0800171 int makeDir(StorageId storage, std::string_view path, int mode = 0755);
172 int makeDirs(StorageId storage, std::string_view path, int mode = 0755);
Songchun Fan3c82a302019-11-29 14:23:45 -0800173
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800174 int link(StorageId sourceStorageId, std::string_view oldPath, StorageId destStorageId,
175 std::string_view newPath);
176 int unlink(StorageId storage, std::string_view path);
Songchun Fan3c82a302019-11-29 14:23:45 -0800177
Yurii Zubrytskyi256a1a42021-03-18 14:21:54 -0700178 incfs::LoadingState isFileFullyLoaded(StorageId storage, std::string_view filePath) const;
179 incfs::LoadingState isMountFullyLoaded(StorageId storage) const;
Alex Buynytskyy07694ed2021-01-27 06:58:55 -0800180
Yurii Zubrytskyi883a27a2021-03-18 19:30:56 -0700181 LoadingProgress getLoadingProgress(StorageId storage) const;
Alex Buynytskyy07694ed2021-01-27 06:58:55 -0800182
Songchun Fana7098592020-09-03 11:45:53 -0700183 bool registerLoadingProgressListener(StorageId storage,
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700184 StorageLoadingProgressListener progressListener);
Songchun Fana7098592020-09-03 11:45:53 -0700185 bool unregisterLoadingProgressListener(StorageId storage);
Songchun Fan2570ec02020-10-08 17:22:33 -0700186 bool registerStorageHealthListener(StorageId storage,
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700187 const StorageHealthCheckParams& healthCheckParams,
188 StorageHealthListener healthListener);
Songchun Fan2570ec02020-10-08 17:22:33 -0700189 void unregisterStorageHealthListener(StorageId storage);
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700190 RawMetadata getMetadata(StorageId storage, std::string_view path) const;
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800191 RawMetadata getMetadata(StorageId storage, FileId node) const;
Songchun Fan3c82a302019-11-29 14:23:45 -0800192
Songchun Fan0f8b6fe2020-02-05 17:41:25 -0800193 bool configureNativeBinaries(StorageId storage, std::string_view apkFullPath,
Songchun Fan14f6c3c2020-05-21 18:19:07 -0700194 std::string_view libDirRelativePath, std::string_view abi,
195 bool extractNativeLibs);
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700196 bool waitForNativeBinariesExtraction(StorageId storage);
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700197
Songchun Fan1b76ccf2021-02-24 22:25:59 +0000198 void getMetrics(int32_t storageId, android::os::PersistableBundle* _aidl_return);
199
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700200 class AppOpsListener : public android::BnAppOpsCallback {
201 public:
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700202 AppOpsListener(IncrementalService& incrementalService, std::string packageName)
203 : incrementalService(incrementalService), packageName(std::move(packageName)) {}
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700204 void opChanged(int32_t op, const String16& packageName) final;
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700205
206 private:
207 IncrementalService& incrementalService;
208 const std::string packageName;
209 };
210
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700211 class IncrementalServiceConnector : public os::incremental::BnIncrementalServiceConnector {
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700212 public:
213 IncrementalServiceConnector(IncrementalService& incrementalService, int32_t storage)
Alex Buynytskyy5f9e3a02020-04-07 21:13:41 -0700214 : incrementalService(incrementalService), storage(storage) {}
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700215 binder::Status setStorageParams(bool enableReadLogs, int32_t* _aidl_return) final;
216
217 private:
218 IncrementalService& incrementalService;
Alex Buynytskyy5f9e3a02020-04-07 21:13:41 -0700219 int32_t const storage;
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700220 };
221
Songchun Fan3c82a302019-11-29 14:23:45 -0800222private:
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700223 struct IncFsMount;
224
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700225 class DataLoaderStub : public content::pm::BnDataLoaderStatusListener {
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700226 public:
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700227 DataLoaderStub(IncrementalService& service, MountId id,
228 content::pm::DataLoaderParamsParcel&& params,
229 content::pm::FileSystemControlParcel&& control,
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700230 DataLoaderStatusListener&& statusListener,
231 const StorageHealthCheckParams& healthCheckParams,
232 StorageHealthListener&& healthListener, std::string&& healthPath);
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700233 ~DataLoaderStub();
Alex Buynytskyy9a54579a2020-04-17 15:34:47 -0700234 // Cleans up the internal state and invalidates DataLoaderStub. Any subsequent calls will
235 // result in an error.
236 void cleanupResources();
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700237
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700238 bool requestCreate();
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700239 bool requestStart();
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700240 bool requestDestroy();
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700241
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700242 void onDump(int fd);
243
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700244 MountId id() const { return mId.load(std::memory_order_relaxed); }
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700245 const content::pm::DataLoaderParamsParcel& params() const { return mParams; }
Alex Buynytskyyd7aa3462021-03-14 22:20:20 -0700246 bool isSystemDataLoader() const;
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700247 void setHealthListener(const StorageHealthCheckParams& healthCheckParams,
248 StorageHealthListener&& healthListener);
Songchun Fan1b76ccf2021-02-24 22:25:59 +0000249 long elapsedMsSinceOldestPendingRead();
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700250
251 private:
252 binder::Status onStatusChanged(MountId mount, int newStatus) final;
Songchun Fan33093982020-09-10 13:12:39 -0700253 binder::Status reportStreamHealth(MountId mount, int newStatus) final;
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700254
Alex Buynytskyy060c9d62021-02-18 20:55:17 -0800255 void setCurrentStatus(int newStatus);
256
Alex Buynytskyy0bdbccf2020-04-23 20:36:42 -0700257 sp<content::pm::IDataLoader> getDataLoader();
Alex Buynytskyy9a54579a2020-04-17 15:34:47 -0700258
Alex Buynytskyyea1390f2020-04-22 16:08:50 -0700259 bool bind();
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700260 bool create();
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700261 bool start();
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700262 bool destroy();
263
264 bool setTargetStatus(int status);
Alex Buynytskyy7e0a1a82020-04-27 17:06:10 -0700265 void setTargetStatusLocked(int status);
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700266
267 bool fsmStep();
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700268
Yurii Zubrytskyi883a27a2021-03-18 19:30:56 -0700269 void onHealthStatus(const StorageHealthListener& healthListener, int healthStatus);
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700270 void updateHealthStatus(bool baseline = false);
271
272 bool isValid() const { return id() != kInvalidStorageId; }
273
274 bool isHealthParamsValid() const;
275
276 const incfs::UniqueControl& initializeHealthControl();
277 void resetHealthControl();
278
279 BootClockTsUs getOldestPendingReadTs();
Songchun Fan1b76ccf2021-02-24 22:25:59 +0000280 BootClockTsUs getOldestTsFromLastPendingReads();
281 Milliseconds elapsedMsSinceKernelTs(TimePoint now, BootClockTsUs kernelTsUs);
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700282
Alex Buynytskyy7e06d712021-03-09 19:24:23 -0800283 // If the stub has to bind to the DL.
284 // Returns {} if bind operation is already in progress.
285 // Or bind delay in ms.
286 std::optional<Milliseconds> needToBind();
Alex Buynytskyyb19ee3e2021-02-06 20:31:43 -0800287
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700288 void registerForPendingReads();
289 void unregisterFromPendingReads();
Alex Buynytskyyd0855a32020-05-07 18:40:51 -0700290
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700291 IncrementalService& mService;
Alex Buynytskyyb0ea4482020-05-04 18:39:58 -0700292
293 std::mutex mMutex;
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700294 std::atomic<MountId> mId = kInvalidStorageId;
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700295 content::pm::DataLoaderParamsParcel mParams;
296 content::pm::FileSystemControlParcel mControl;
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -0700297 DataLoaderStatusListener mStatusListener;
298 StorageHealthListener mHealthListener;
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700299
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700300 std::condition_variable mStatusCondition;
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700301 int mCurrentStatus = content::pm::IDataLoaderStatusListener::DATA_LOADER_DESTROYED;
Alex Buynytskyy7e06d712021-03-09 19:24:23 -0800302 TimePoint mCurrentStatusTs = {};
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700303 int mTargetStatus = content::pm::IDataLoaderStatusListener::DATA_LOADER_DESTROYED;
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700304 TimePoint mTargetStatusTs = {};
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700305
Alex Buynytskyyb19ee3e2021-02-06 20:31:43 -0800306 TimePoint mPreviousBindTs = {};
307 Milliseconds mPreviousBindDelay = {};
308
Alex Buynytskyyd0855a32020-05-07 18:40:51 -0700309 std::string mHealthPath;
310 incfs::UniqueControl mHealthControl;
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700311 struct {
312 TimePoint userTs;
313 BootClockTsUs kernelTsUs;
314 } mHealthBase = {TimePoint::max(), kMaxBootClockTsUs};
315 StorageHealthCheckParams mHealthCheckParams;
Songchun Fan2570ec02020-10-08 17:22:33 -0700316 int mStreamStatus = content::pm::IDataLoaderStatusListener::STREAM_HEALTHY;
Songchun Fan6944f1e2020-11-06 15:24:24 -0800317 std::vector<incfs::ReadInfo> mLastPendingReads;
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700318 };
319 using DataLoaderStubPtr = sp<DataLoaderStub>;
320
Songchun Fan3c82a302019-11-29 14:23:45 -0800321 struct IncFsMount {
322 struct Bind {
323 StorageId storage;
324 std::string savedFilename;
325 std::string sourceDir;
326 BindKind kind;
327 };
328
329 struct Storage {
330 std::string name;
Songchun Fan3c82a302019-11-29 14:23:45 -0800331 };
332
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800333 using Control = incfs::UniqueControl;
Songchun Fan3c82a302019-11-29 14:23:45 -0800334
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700335 using BindMap = std::map<std::string, Bind, path::PathLess>;
Songchun Fan3c82a302019-11-29 14:23:45 -0800336 using StorageMap = std::unordered_map<StorageId, Storage>;
337
338 mutable std::mutex lock;
339 const std::string root;
340 Control control;
341 /*const*/ MountId mountId;
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800342 int32_t flags = StorageFlags::ReadLogsAllowed;
Songchun Fan3c82a302019-11-29 14:23:45 -0800343 StorageMap storages;
344 BindMap bindPoints;
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700345 DataLoaderStubPtr dataLoaderStub;
Alex Buynytskyyd7aa3462021-03-14 22:20:20 -0700346 TimePoint startLoadingTs = {};
Songchun Fan3c82a302019-11-29 14:23:45 -0800347 std::atomic<int> nextStorageDirNo{0};
Songchun Fan3c82a302019-11-29 14:23:45 -0800348 const IncrementalService& incrementalService;
349
350 IncFsMount(std::string root, MountId mountId, Control control,
351 const IncrementalService& incrementalService)
352 : root(std::move(root)),
353 control(std::move(control)),
354 mountId(mountId),
Alex Buynytskyy1d892162020-04-03 23:00:19 -0700355 incrementalService(incrementalService) {}
Songchun Fan3c82a302019-11-29 14:23:45 -0800356 IncFsMount(IncFsMount&&) = delete;
357 IncFsMount& operator=(IncFsMount&&) = delete;
358 ~IncFsMount();
359
360 StorageMap::iterator makeStorage(StorageId id);
361
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800362 void disallowReadLogs() { flags &= ~StorageFlags::ReadLogsAllowed; }
363 int32_t readLogsAllowed() const { return (flags & StorageFlags::ReadLogsAllowed); }
364
Alex Buynytskyyd7aa3462021-03-14 22:20:20 -0700365 void setReadLogsEnabled(bool value);
Alex Buynytskyy3697d9e2020-06-06 20:15:58 -0700366 int32_t readLogsEnabled() const { return (flags & StorageFlags::ReadLogsEnabled); }
367
Songchun Fan3c82a302019-11-29 14:23:45 -0800368 static void cleanupFilesystem(std::string_view root);
369 };
370
371 using IfsMountPtr = std::shared_ptr<IncFsMount>;
372 using MountMap = std::unordered_map<MountId, IfsMountPtr>;
373 using BindPathMap = std::map<std::string, IncFsMount::BindMap::iterator, path::PathLess>;
374
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700375 static bool perfLoggingEnabled();
376
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800377 void setUidReadTimeouts(StorageId storage,
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700378 std::vector<PerUidReadTimeouts>&& perUidReadTimeouts);
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800379 void clearUidReadTimeouts(StorageId storage);
Alex Buynytskyycb163f92021-03-18 21:21:27 -0700380 bool checkUidReadTimeouts(StorageId storage, IfsState state, Clock::time_point timeLimit);
Alex Buynytskyyaa8e95e2020-12-14 21:50:04 -0800381
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700382 std::unordered_set<std::string_view> adoptMountedInstances();
383 void mountExistingImages(const std::unordered_set<std::string_view>& mountedRootNames);
Yurii Zubrytskyi107ae352020-04-03 13:12:51 -0700384 bool mountExistingImage(std::string_view root);
Songchun Fan3c82a302019-11-29 14:23:45 -0800385
386 IfsMountPtr getIfs(StorageId storage) const;
387 const IfsMountPtr& getIfsLocked(StorageId storage) const;
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800388 int addBindMount(IncFsMount& ifs, StorageId storage, std::string_view storageRoot,
389 std::string&& source, std::string&& target, BindKind kind,
390 std::unique_lock<std::mutex>& mainLock);
Songchun Fan3c82a302019-11-29 14:23:45 -0800391
392 int addBindMountWithMd(IncFsMount& ifs, StorageId storage, std::string&& metadataName,
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800393 std::string&& source, std::string&& target, BindKind kind,
Songchun Fan3c82a302019-11-29 14:23:45 -0800394 std::unique_lock<std::mutex>& mainLock);
395
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700396 void addBindMountRecordLocked(IncFsMount& ifs, StorageId storage, std::string&& metadataName,
397 std::string&& source, std::string&& target, BindKind kind);
398
Alex Buynytskyyb19ee3e2021-02-06 20:31:43 -0800399 bool needStartDataLoaderLocked(IncFsMount& ifs);
400
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700401 void prepareDataLoaderLocked(IncFsMount& ifs, content::pm::DataLoaderParamsParcel&& params,
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700402 DataLoaderStatusListener&& statusListener = {},
403 const StorageHealthCheckParams& healthCheckParams = {},
404 StorageHealthListener&& healthListener = {});
Alex Buynytskyybf1c0632020-03-10 15:49:29 -0700405
Songchun Fan3c82a302019-11-29 14:23:45 -0800406 BindPathMap::const_iterator findStorageLocked(std::string_view path) const;
407 StorageId findStorageId(std::string_view path) const;
408
409 void deleteStorage(IncFsMount& ifs);
410 void deleteStorageLocked(IncFsMount& ifs, std::unique_lock<std::mutex>&& ifsLock);
411 MountMap::iterator getStorageSlotLocked();
Yurii Zubrytskyiefebb452020-04-22 13:59:06 -0700412 std::string normalizePathToStorage(const IncFsMount& incfs, StorageId storage,
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700413 std::string_view path) const;
Yurii Zubrytskyiefebb452020-04-22 13:59:06 -0700414 std::string normalizePathToStorageLocked(const IncFsMount& incfs,
415 IncFsMount::StorageMap::const_iterator storageIt,
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700416 std::string_view path) const;
Yurii Zubrytskyiefebb452020-04-22 13:59:06 -0700417 int makeDirs(const IncFsMount& ifs, StorageId storageId, std::string_view path, int mode);
Alex Buynytskyyd7aa3462021-03-14 22:20:20 -0700418
Alex Buynytskyycb163f92021-03-18 21:21:27 -0700419 int disableReadLogsLocked(IncFsMount& ifs);
420 int applyStorageParamsLocked(IncFsMount& ifs, bool enableReadLogs);
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700421
Yurii Zubrytskyi883a27a2021-03-18 19:30:56 -0700422 LoadingProgress getLoadingProgressFromPath(const IncFsMount& ifs, std::string_view path) const;
Songchun Fan374f7652020-08-20 08:40:29 -0700423
Alex Buynytskyyb39d13e2020-09-12 16:12:36 -0700424 int setFileContent(const IfsMountPtr& ifs, const incfs::FileId& fileId,
425 std::string_view debugFilePath, std::span<const uint8_t> data) const;
426
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700427 void registerAppOpsCallback(const std::string& packageName);
Alex Buynytskyy1d892162020-04-03 23:00:19 -0700428 bool unregisterAppOpsCallback(const std::string& packageName);
429 void onAppOpChanged(const std::string& packageName);
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700430
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700431 void runJobProcessing();
432 void extractZipFile(const IfsMountPtr& ifs, ZipArchiveHandle zipFile, ZipEntry& entry,
Alex Buynytskyyb39d13e2020-09-12 16:12:36 -0700433 const incfs::FileId& libFileId, std::string_view debugLibPath,
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700434 Clock::time_point scheduledTs);
435
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700436 void runCmdLooper();
437
Songchun Fana7098592020-09-03 11:45:53 -0700438 bool addTimedJob(TimedQueueWrapper& timedQueue, MountId id, Milliseconds after, Job what);
439 bool removeTimedJobs(TimedQueueWrapper& timedQueue, MountId id);
Alex Buynytskyycb163f92021-03-18 21:21:27 -0700440
441 void addIfsStateCallback(StorageId storageId, IfsStateCallback callback);
442 void removeIfsStateCallbacks(StorageId storageId);
443 void processIfsStateCallbacks();
444 void processIfsStateCallbacks(StorageId storageId, std::vector<IfsStateCallback>& callbacks);
445
Songchun Fana7098592020-09-03 11:45:53 -0700446 bool updateLoadingProgress(int32_t storageId,
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700447 StorageLoadingProgressListener&& progressListener);
Songchun Fan1b76ccf2021-02-24 22:25:59 +0000448 long getMillsSinceOldestPendingRead(StorageId storage);
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700449
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700450private:
Yurii Zubrytskyi86321402020-04-09 19:22:30 -0700451 const std::unique_ptr<VoldServiceWrapper> mVold;
452 const std::unique_ptr<DataLoaderManagerWrapper> mDataLoaderManager;
453 const std::unique_ptr<IncFsWrapper> mIncFs;
454 const std::unique_ptr<AppOpsManagerWrapper> mAppOpsManager;
455 const std::unique_ptr<JniWrapper> mJni;
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700456 const std::unique_ptr<LooperWrapper> mLooper;
Alex Buynytskyy46d3ddb2020-05-29 12:05:05 -0700457 const std::unique_ptr<TimedQueueWrapper> mTimedQueue;
Songchun Fana7098592020-09-03 11:45:53 -0700458 const std::unique_ptr<TimedQueueWrapper> mProgressUpdateJobQueue;
Songchun Fan374f7652020-08-20 08:40:29 -0700459 const std::unique_ptr<FsWrapper> mFs;
Alex Buynytskyy7e06d712021-03-09 19:24:23 -0800460 const std::unique_ptr<ClockWrapper> mClock;
Songchun Fan3c82a302019-11-29 14:23:45 -0800461 const std::string mIncrementalDir;
462
463 mutable std::mutex mLock;
464 mutable std::mutex mMountOperationLock;
465 MountMap mMounts;
466 BindPathMap mBindsByPath;
467
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700468 std::mutex mCallbacksLock;
Yurii Zubrytskyif4769e22021-03-18 20:37:45 -0700469 std::unordered_map<std::string, sp<AppOpsListener>> mCallbackRegistered;
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700470
Alex Buynytskyycb163f92021-03-18 21:21:27 -0700471 using IfsStateCallbacks = std::unordered_map<StorageId, std::vector<IfsStateCallback>>;
472 std::mutex mIfsStateCallbacksLock;
473 IfsStateCallbacks mIfsStateCallbacks;
474
Songchun Fan3c82a302019-11-29 14:23:45 -0800475 std::atomic_bool mSystemReady = false;
476 StorageId mNextId = 0;
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700477
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700478 std::atomic_bool mRunning{true};
479
Yurii Zubrytskyi721ac4d2020-04-13 11:34:32 -0700480 std::unordered_map<MountId, std::vector<Job>> mJobQueue;
481 MountId mPendingJobsMount = kInvalidStorageId;
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700482 std::condition_variable mJobCondition;
483 std::mutex mJobMutex;
484 std::thread mJobProcessor;
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700485
486 std::thread mCmdLooperThread;
Songchun Fan3c82a302019-11-29 14:23:45 -0800487};
488
489} // namespace android::incremental