blob: 57e4669d53dee3eaa7b4b251507f0bb8a5b68eb4 [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>
23#include <android/os/incremental/BnIncrementalServiceConnector.h>
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070024#include <android/os/incremental/BnStorageHealthListener.h>
25#include <android/os/incremental/StorageHealthCheckParams.h>
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -070026#include <binder/IAppOpsCallback.h>
Songchun Fan3c82a302019-11-29 14:23:45 -080027#include <utils/String16.h>
28#include <utils/StrongPointer.h>
Yurii Zubrytskyida208012020-04-07 15:35:21 -070029#include <ziparchive/zip_archive.h>
Songchun Fan3c82a302019-11-29 14:23:45 -080030
31#include <atomic>
32#include <chrono>
Yurii Zubrytskyida208012020-04-07 15:35:21 -070033#include <condition_variable>
34#include <functional>
Songchun Fan3c82a302019-11-29 14:23:45 -080035#include <limits>
36#include <map>
37#include <mutex>
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -070038#include <set>
Songchun Fan9b753082020-02-26 13:08:06 -080039#include <span>
Songchun Fan3c82a302019-11-29 14:23:45 -080040#include <string>
41#include <string_view>
Yurii Zubrytskyida208012020-04-07 15:35:21 -070042#include <thread>
Songchun Fan3c82a302019-11-29 14:23:45 -080043#include <unordered_map>
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -070044#include <unordered_set>
Songchun Fan3c82a302019-11-29 14:23:45 -080045#include <utility>
46#include <vector>
47
48#include "ServiceWrappers.h"
Songchun Fan3c82a302019-11-29 14:23:45 -080049#include "incfs.h"
50#include "path.h"
51
Songchun Fan3c82a302019-11-29 14:23:45 -080052namespace android::incremental {
53
54using MountId = int;
55using StorageId = int;
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -080056using FileId = incfs::FileId;
Songchun Fan3c82a302019-11-29 14:23:45 -080057using BlockIndex = incfs::BlockIndex;
58using RawMetadata = incfs::RawMetadata;
59using Clock = std::chrono::steady_clock;
60using TimePoint = std::chrono::time_point<Clock>;
61using Seconds = std::chrono::seconds;
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070062using BootClockTsUs = uint64_t;
Songchun Fan3c82a302019-11-29 14:23:45 -080063
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -070064using IDataLoaderStatusListener = ::android::content::pm::IDataLoaderStatusListener;
65using DataLoaderStatusListener = ::android::sp<IDataLoaderStatusListener>;
Alex Buynytskyy04f73912020-02-10 08:34:18 -080066
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070067using StorageHealthCheckParams = ::android::os::incremental::StorageHealthCheckParams;
68using IStorageHealthListener = ::android::os::incremental::IStorageHealthListener;
69using StorageHealthListener = ::android::sp<IStorageHealthListener>;
70
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -080071class IncrementalService final {
Songchun Fan3c82a302019-11-29 14:23:45 -080072public:
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -080073 explicit IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir);
Songchun Fan3c82a302019-11-29 14:23:45 -080074
75#pragma GCC diagnostic push
76#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
77 ~IncrementalService();
78#pragma GCC diagnostic pop
79
80 static constexpr StorageId kInvalidStorageId = -1;
81 static constexpr StorageId kMaxStorageId = std::numeric_limits<int>::max();
82
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -070083 static constexpr BootClockTsUs kMaxBootClockTsUs = std::numeric_limits<BootClockTsUs>::max();
84
Songchun Fan3c82a302019-11-29 14:23:45 -080085 enum CreateOptions {
86 TemporaryBind = 1,
87 PermanentBind = 2,
88 CreateNew = 4,
89 OpenExisting = 8,
90
91 Default = TemporaryBind | CreateNew
92 };
93
94 enum class BindKind {
95 Temporary = 0,
96 Permanent = 1,
97 };
98
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -080099 static FileId idFromMetadata(std::span<const uint8_t> metadata);
100 static inline FileId idFromMetadata(std::span<const char> metadata) {
101 return idFromMetadata({(const uint8_t*)metadata.data(), metadata.size()});
102 }
103
Alex Buynytskyy18b07a42020-02-03 20:06:00 -0800104 void onDump(int fd);
105
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700106 void onSystemReady();
Songchun Fan3c82a302019-11-29 14:23:45 -0800107
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700108 StorageId createStorage(std::string_view mountPoint,
109 content::pm::DataLoaderParamsParcel&& dataLoaderParams,
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -0700110 CreateOptions options, const DataLoaderStatusListener& statusListener,
111 StorageHealthCheckParams&& healthCheckParams,
112 const StorageHealthListener& healthListener);
Songchun Fan3c82a302019-11-29 14:23:45 -0800113 StorageId createLinkedStorage(std::string_view mountPoint, StorageId linkedStorage,
114 CreateOptions options = CreateOptions::Default);
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800115 StorageId openStorage(std::string_view path);
Songchun Fan3c82a302019-11-29 14:23:45 -0800116
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800117 int bind(StorageId storage, std::string_view source, std::string_view target, BindKind kind);
Songchun Fan3c82a302019-11-29 14:23:45 -0800118 int unbind(StorageId storage, std::string_view target);
119 void deleteStorage(StorageId storage);
120
Alex Buynytskyy5e860ba2020-03-31 15:30:21 -0700121 int setStorageParams(StorageId storage, bool enableReadLogs);
122
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800123 int makeFile(StorageId storage, std::string_view path, int mode, FileId id,
124 incfs::NewFileParams params);
Songchun Fan96100932020-02-03 19:20:58 -0800125 int makeDir(StorageId storage, std::string_view path, int mode = 0755);
126 int makeDirs(StorageId storage, std::string_view path, int mode = 0755);
Songchun Fan3c82a302019-11-29 14:23:45 -0800127
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800128 int link(StorageId sourceStorageId, std::string_view oldPath, StorageId destStorageId,
129 std::string_view newPath);
130 int unlink(StorageId storage, std::string_view path);
Songchun Fan3c82a302019-11-29 14:23:45 -0800131
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800132 bool isRangeLoaded(StorageId storage, FileId file, std::pair<BlockIndex, BlockIndex> range) {
Songchun Fan3c82a302019-11-29 14:23:45 -0800133 return false;
134 }
135
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700136 RawMetadata getMetadata(StorageId storage, std::string_view path) const;
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800137 RawMetadata getMetadata(StorageId storage, FileId node) const;
Songchun Fan3c82a302019-11-29 14:23:45 -0800138
Songchun Fan3c82a302019-11-29 14:23:45 -0800139 bool startLoading(StorageId storage) const;
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700140
Songchun Fan0f8b6fe2020-02-05 17:41:25 -0800141 bool configureNativeBinaries(StorageId storage, std::string_view apkFullPath,
Songchun Fan14f6c3c2020-05-21 18:19:07 -0700142 std::string_view libDirRelativePath, std::string_view abi,
143 bool extractNativeLibs);
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700144 bool waitForNativeBinariesExtraction(StorageId storage);
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700145
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700146 class AppOpsListener : public android::BnAppOpsCallback {
147 public:
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700148 AppOpsListener(IncrementalService& incrementalService, std::string packageName)
149 : incrementalService(incrementalService), packageName(std::move(packageName)) {}
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700150 void opChanged(int32_t op, const String16& packageName) final;
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700151
152 private:
153 IncrementalService& incrementalService;
154 const std::string packageName;
155 };
156
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700157 class IncrementalServiceConnector : public os::incremental::BnIncrementalServiceConnector {
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700158 public:
159 IncrementalServiceConnector(IncrementalService& incrementalService, int32_t storage)
Alex Buynytskyy5f9e3a02020-04-07 21:13:41 -0700160 : incrementalService(incrementalService), storage(storage) {}
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700161 binder::Status setStorageParams(bool enableReadLogs, int32_t* _aidl_return) final;
162
163 private:
164 IncrementalService& incrementalService;
Alex Buynytskyy5f9e3a02020-04-07 21:13:41 -0700165 int32_t const storage;
Alex Buynytskyyf4156792020-04-07 14:26:55 -0700166 };
167
Songchun Fan3c82a302019-11-29 14:23:45 -0800168private:
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700169 struct IncFsMount;
170
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700171 class DataLoaderStub : public content::pm::BnDataLoaderStatusListener {
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700172 public:
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700173 DataLoaderStub(IncrementalService& service, MountId id,
174 content::pm::DataLoaderParamsParcel&& params,
175 content::pm::FileSystemControlParcel&& control,
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -0700176 const DataLoaderStatusListener* statusListener,
177 StorageHealthCheckParams&& healthCheckParams,
178 const StorageHealthListener* healthListener, std::string&& healthPath);
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700179 ~DataLoaderStub();
Alex Buynytskyy9a54579a2020-04-17 15:34:47 -0700180 // Cleans up the internal state and invalidates DataLoaderStub. Any subsequent calls will
181 // result in an error.
182 void cleanupResources();
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700183
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700184 bool requestCreate();
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700185 bool requestStart();
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700186 bool requestDestroy();
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700187
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700188 void onDump(int fd);
189
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700190 MountId id() const { return mId.load(std::memory_order_relaxed); }
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700191 const content::pm::DataLoaderParamsParcel& params() const { return mParams; }
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700192
193 private:
194 binder::Status onStatusChanged(MountId mount, int newStatus) final;
195
Alex Buynytskyy0bdbccf2020-04-23 20:36:42 -0700196 sp<content::pm::IDataLoader> getDataLoader();
Alex Buynytskyy9a54579a2020-04-17 15:34:47 -0700197
Alex Buynytskyyea1390f2020-04-22 16:08:50 -0700198 bool bind();
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700199 bool create();
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700200 bool start();
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700201 bool destroy();
202
203 bool setTargetStatus(int status);
Alex Buynytskyy7e0a1a82020-04-27 17:06:10 -0700204 void setTargetStatusLocked(int status);
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700205
206 bool fsmStep();
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700207 bool fsmStep(int currentStatus, int targetStatus);
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700208
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700209 void onHealthStatus(StorageHealthListener healthListener, int healthStatus);
210 void updateHealthStatus(bool baseline = false);
211
212 bool isValid() const { return id() != kInvalidStorageId; }
213
214 bool isHealthParamsValid() const;
215
216 const incfs::UniqueControl& initializeHealthControl();
217 void resetHealthControl();
218
219 BootClockTsUs getOldestPendingReadTs();
220
221 void registerForPendingReads();
222 void unregisterFromPendingReads();
Alex Buynytskyyd0855a32020-05-07 18:40:51 -0700223
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700224 IncrementalService& mService;
Alex Buynytskyyb0ea4482020-05-04 18:39:58 -0700225
226 std::mutex mMutex;
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700227 std::atomic<MountId> mId = kInvalidStorageId;
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700228 content::pm::DataLoaderParamsParcel mParams;
229 content::pm::FileSystemControlParcel mControl;
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -0700230 DataLoaderStatusListener mStatusListener;
231 StorageHealthListener mHealthListener;
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700232
Alex Buynytskyy0b202662020-04-13 09:53:04 -0700233 std::condition_variable mStatusCondition;
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700234 int mCurrentStatus = content::pm::IDataLoaderStatusListener::DATA_LOADER_DESTROYED;
235 int mTargetStatus = content::pm::IDataLoaderStatusListener::DATA_LOADER_DESTROYED;
Alex Buynytskyyab65cb12020-04-17 10:01:47 -0700236 TimePoint mTargetStatusTs = {};
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700237
Alex Buynytskyyd0855a32020-05-07 18:40:51 -0700238 std::string mHealthPath;
239 incfs::UniqueControl mHealthControl;
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700240 struct {
241 TimePoint userTs;
242 BootClockTsUs kernelTsUs;
243 } mHealthBase = {TimePoint::max(), kMaxBootClockTsUs};
244 StorageHealthCheckParams mHealthCheckParams;
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700245 };
246 using DataLoaderStubPtr = sp<DataLoaderStub>;
247
Songchun Fan3c82a302019-11-29 14:23:45 -0800248 struct IncFsMount {
249 struct Bind {
250 StorageId storage;
251 std::string savedFilename;
252 std::string sourceDir;
253 BindKind kind;
254 };
255
256 struct Storage {
257 std::string name;
Songchun Fan3c82a302019-11-29 14:23:45 -0800258 };
259
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800260 using Control = incfs::UniqueControl;
Songchun Fan3c82a302019-11-29 14:23:45 -0800261
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700262 using BindMap = std::map<std::string, Bind, path::PathLess>;
Songchun Fan3c82a302019-11-29 14:23:45 -0800263 using StorageMap = std::unordered_map<StorageId, Storage>;
264
265 mutable std::mutex lock;
266 const std::string root;
267 Control control;
268 /*const*/ MountId mountId;
269 StorageMap storages;
270 BindMap bindPoints;
Alex Buynytskyy0ea4ff42020-04-09 17:25:42 -0700271 DataLoaderStubPtr dataLoaderStub;
Songchun Fan3c82a302019-11-29 14:23:45 -0800272 std::atomic<int> nextStorageDirNo{0};
Songchun Fan3c82a302019-11-29 14:23:45 -0800273 const IncrementalService& incrementalService;
274
275 IncFsMount(std::string root, MountId mountId, Control control,
276 const IncrementalService& incrementalService)
277 : root(std::move(root)),
278 control(std::move(control)),
279 mountId(mountId),
Alex Buynytskyy1d892162020-04-03 23:00:19 -0700280 incrementalService(incrementalService) {}
Songchun Fan3c82a302019-11-29 14:23:45 -0800281 IncFsMount(IncFsMount&&) = delete;
282 IncFsMount& operator=(IncFsMount&&) = delete;
283 ~IncFsMount();
284
285 StorageMap::iterator makeStorage(StorageId id);
286
287 static void cleanupFilesystem(std::string_view root);
288 };
289
290 using IfsMountPtr = std::shared_ptr<IncFsMount>;
291 using MountMap = std::unordered_map<MountId, IfsMountPtr>;
292 using BindPathMap = std::map<std::string, IncFsMount::BindMap::iterator, path::PathLess>;
293
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700294 static bool perfLoggingEnabled();
295
296 std::unordered_set<std::string_view> adoptMountedInstances();
297 void mountExistingImages(const std::unordered_set<std::string_view>& mountedRootNames);
Yurii Zubrytskyi107ae352020-04-03 13:12:51 -0700298 bool mountExistingImage(std::string_view root);
Songchun Fan3c82a302019-11-29 14:23:45 -0800299
300 IfsMountPtr getIfs(StorageId storage) const;
301 const IfsMountPtr& getIfsLocked(StorageId storage) const;
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800302 int addBindMount(IncFsMount& ifs, StorageId storage, std::string_view storageRoot,
303 std::string&& source, std::string&& target, BindKind kind,
304 std::unique_lock<std::mutex>& mainLock);
Songchun Fan3c82a302019-11-29 14:23:45 -0800305
306 int addBindMountWithMd(IncFsMount& ifs, StorageId storage, std::string&& metadataName,
Yurii Zubrytskyi4a25dfb2020-01-10 11:53:24 -0800307 std::string&& source, std::string&& target, BindKind kind,
Songchun Fan3c82a302019-11-29 14:23:45 -0800308 std::unique_lock<std::mutex>& mainLock);
309
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700310 void addBindMountRecordLocked(IncFsMount& ifs, StorageId storage, std::string&& metadataName,
311 std::string&& source, std::string&& target, BindKind kind);
312
313 DataLoaderStubPtr prepareDataLoader(IncFsMount& ifs,
314 content::pm::DataLoaderParamsParcel&& params,
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -0700315 const DataLoaderStatusListener* statusListener = nullptr,
316 StorageHealthCheckParams&& healthCheckParams = {},
317 const StorageHealthListener* healthListener = nullptr);
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700318 void prepareDataLoaderLocked(IncFsMount& ifs, content::pm::DataLoaderParamsParcel&& params,
Alex Buynytskyy8ef61ae2020-05-08 16:18:52 -0700319 const DataLoaderStatusListener* statusListener = nullptr,
320 StorageHealthCheckParams&& healthCheckParams = {},
321 const StorageHealthListener* healthListener = nullptr);
Alex Buynytskyybf1c0632020-03-10 15:49:29 -0700322
Songchun Fan3c82a302019-11-29 14:23:45 -0800323 BindPathMap::const_iterator findStorageLocked(std::string_view path) const;
324 StorageId findStorageId(std::string_view path) const;
325
326 void deleteStorage(IncFsMount& ifs);
327 void deleteStorageLocked(IncFsMount& ifs, std::unique_lock<std::mutex>&& ifsLock);
328 MountMap::iterator getStorageSlotLocked();
Yurii Zubrytskyiefebb452020-04-22 13:59:06 -0700329 std::string normalizePathToStorage(const IncFsMount& incfs, StorageId storage,
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700330 std::string_view path) const;
Yurii Zubrytskyiefebb452020-04-22 13:59:06 -0700331 std::string normalizePathToStorageLocked(const IncFsMount& incfs,
332 IncFsMount::StorageMap::const_iterator storageIt,
Yurii Zubrytskyi629051fd2020-04-17 23:13:47 -0700333 std::string_view path) const;
Yurii Zubrytskyiefebb452020-04-22 13:59:06 -0700334 int makeDirs(const IncFsMount& ifs, StorageId storageId, std::string_view path, int mode);
Alex Buynytskyy1d892162020-04-03 23:00:19 -0700335 binder::Status applyStorageParams(IncFsMount& ifs, bool enableReadLogs);
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700336
337 void registerAppOpsCallback(const std::string& packageName);
Alex Buynytskyy1d892162020-04-03 23:00:19 -0700338 bool unregisterAppOpsCallback(const std::string& packageName);
339 void onAppOpChanged(const std::string& packageName);
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700340
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700341 using Job = std::function<void()>;
342
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700343 void runJobProcessing();
344 void extractZipFile(const IfsMountPtr& ifs, ZipArchiveHandle zipFile, ZipEntry& entry,
345 const incfs::FileId& libFileId, std::string_view targetLibPath,
346 Clock::time_point scheduledTs);
347
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700348 void runCmdLooper();
349
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700350 void addTimedJob(MountId id, TimePoint when, Job what);
351 void removeTimedJobs(MountId id);
352 void runTimers();
353
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700354private:
Yurii Zubrytskyi86321402020-04-09 19:22:30 -0700355 const std::unique_ptr<VoldServiceWrapper> mVold;
356 const std::unique_ptr<DataLoaderManagerWrapper> mDataLoaderManager;
357 const std::unique_ptr<IncFsWrapper> mIncFs;
358 const std::unique_ptr<AppOpsManagerWrapper> mAppOpsManager;
359 const std::unique_ptr<JniWrapper> mJni;
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700360 const std::unique_ptr<LooperWrapper> mLooper;
Songchun Fan3c82a302019-11-29 14:23:45 -0800361 const std::string mIncrementalDir;
362
363 mutable std::mutex mLock;
364 mutable std::mutex mMountOperationLock;
365 MountMap mMounts;
366 BindPathMap mBindsByPath;
367
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700368 std::mutex mCallbacksLock;
Alex Buynytskyy1d892162020-04-03 23:00:19 -0700369 std::map<std::string, sp<AppOpsListener>> mCallbackRegistered;
Alex Buynytskyy96e350b2020-04-02 20:03:47 -0700370
Songchun Fan3c82a302019-11-29 14:23:45 -0800371 std::atomic_bool mSystemReady = false;
372 StorageId mNextId = 0;
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700373
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700374 std::atomic_bool mRunning{true};
375
Yurii Zubrytskyi721ac4d2020-04-13 11:34:32 -0700376 std::unordered_map<MountId, std::vector<Job>> mJobQueue;
377 MountId mPendingJobsMount = kInvalidStorageId;
Yurii Zubrytskyida208012020-04-07 15:35:21 -0700378 std::condition_variable mJobCondition;
379 std::mutex mJobMutex;
380 std::thread mJobProcessor;
Alex Buynytskyycca2c112020-05-05 12:48:41 -0700381
382 std::thread mCmdLooperThread;
Alex Buynytskyy4760d8f2020-05-08 16:18:52 -0700383
384 struct TimedJob {
385 MountId id;
386 TimePoint when;
387 Job what;
388 friend bool operator<(const TimedJob& lhs, const TimedJob& rhs) {
389 return lhs.when < rhs.when;
390 }
391 };
392 std::set<TimedJob> mTimedJobs;
393 std::condition_variable mTimerCondition;
394 std::mutex mTimerMutex;
395 std::thread mTimerThread;
Songchun Fan3c82a302019-11-29 14:23:45 -0800396};
397
398} // namespace android::incremental