blob: 27055051257c5adc6e9872dbede907e1ab70d74a [file] [log] [blame]
Mike Lockwood94afecf2012-10-24 10:45:23 -07001/*
2** Copyright 2008, The Android Open Source Project
3**
Dave Allisond9370732014-01-30 14:19:23 -08004** 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
Mike Lockwood94afecf2012-10-24 10:45:23 -07007**
Dave Allisond9370732014-01-30 14:19:23 -08008** http://www.apache.org/licenses/LICENSE-2.0
Mike Lockwood94afecf2012-10-24 10:45:23 -07009**
Dave Allisond9370732014-01-30 14:19:23 -080010** 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
Mike Lockwood94afecf2012-10-24 10:45:23 -070014** limitations under the License.
15*/
16
Jeff Sharkeyf3e30b92016-12-09 17:06:57 -070017#include "InstalldNativeService.h"
Andreas Gampe02d0de52015-11-11 20:43:16 -080018
Jeff Sharkey466459b2017-01-17 15:25:01 -070019#define ATRACE_TAG ATRACE_TAG_PACKAGE_MANAGER
20
Andreas Gampe02d0de52015-11-11 20:43:16 -080021#include <errno.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070022#include <fts.h>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080023#include <inttypes.h>
Keun young Park144a9892021-10-13 16:43:58 -070024#include <stdio.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080025#include <stdlib.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070026#include <string.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080027#include <sys/capability.h>
28#include <sys/file.h>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080029#include <sys/ioctl.h>
30#include <sys/mman.h>
Ricky Waiff9d3ea2019-11-18 18:18:24 +000031#include <sys/mount.h>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080032#include <sys/resource.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080033#include <sys/stat.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070034#include <sys/statvfs.h>
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070035#include <sys/types.h>
Calin Juravle6a1648e2016-02-01 12:12:16 +000036#include <sys/wait.h>
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070037#include <sys/xattr.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080038#include <unistd.h>
Samiul Islamb911bc62022-01-14 16:24:48 +000039#include <algorithm>
40#include <filesystem>
41#include <fstream>
42#include <functional>
43#include <regex>
Jeff Sharkey41ea4242015-04-09 11:34:03 -070044
Nikita Ioffeb68f0d12019-02-04 11:06:37 +000045#include <android-base/file.h>
Andreas Gampeafa58d12016-06-03 16:09:32 -070046#include <android-base/logging.h>
Oli Lanc7789572020-03-16 18:18:41 +000047#include <android-base/parseint.h>
Jeff Sharkeyf29a3bc2018-01-08 10:40:19 -070048#include <android-base/properties.h>
Narayan Kamathe63ca7d2019-01-14 15:21:52 +000049#include <android-base/scopeguard.h>
Elliott Hughese4ec9eb2015-12-04 15:39:32 -080050#include <android-base/stringprintf.h>
David Sehr6727c2d2016-05-17 16:06:22 -070051#include <android-base/strings.h>
Roland Levillain64b59cc2016-04-05 16:41:12 +010052#include <android-base/unique_fd.h>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080053#include <cutils/ashmem.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080054#include <cutils/fs.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070055#include <cutils/properties.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070056#include <cutils/sched_policy.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070057#include <log/log.h> // TODO: Move everything to base/logging.
Jeff Sharkeye3637242015-04-08 20:56:42 -070058#include <logwrap/logwrap.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080059#include <private/android_filesystem_config.h>
Martijn Coenen771cc342020-02-19 23:26:56 +010060#include <private/android_projectid_config.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070061#include <selinux/android.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080062#include <system/thread_defs.h>
Jeff Sharkey466459b2017-01-17 15:25:01 -070063#include <utils/Trace.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070064
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070065#include "dexopt.h"
Jeff Sharkeyf3e30b92016-12-09 17:06:57 -070066#include "globals.h"
67#include "installd_deps.h"
68#include "otapreopt_utils.h"
69#include "utils.h"
Eric Holk0ebbe0f2019-01-09 18:17:27 -080070#include "view_compiler.h"
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070071
Jeff Sharkey88ddd942017-01-17 18:05:54 -070072#include "CacheTracker.h"
Felka Chang2a0a2462019-11-20 14:20:40 +080073#include "CrateManager.h"
Jeff Sharkeydf2d7542017-01-07 09:19:35 -070074#include "MatchExtensionGen.h"
Risan5f308262018-10-26 12:06:58 -060075#include "QuotaUtils.h"
Jeff Sharkeydf2d7542017-01-07 09:19:35 -070076
Andreas Gampe02d0de52015-11-11 20:43:16 -080077#ifndef LOG_TAG
78#define LOG_TAG "installd"
79#endif
Jeff Sharkey41ea4242015-04-09 11:34:03 -070080
Alex Buynytskyy4fef8862021-11-21 16:09:33 -080081// #define GRANULAR_LOCKS
82
Oli Lanc7789572020-03-16 18:18:41 +000083using android::base::ParseUint;
Jeff Sharkey41ea4242015-04-09 11:34:03 -070084using android::base::StringPrintf;
Jeff Sharkey66b1a122017-01-16 20:57:45 -070085using std::endl;
Mike Lockwood94afecf2012-10-24 10:45:23 -070086
Andreas Gampe02d0de52015-11-11 20:43:16 -080087namespace android {
88namespace installd {
Mike Lockwood94afecf2012-10-24 10:45:23 -070089
Nikita Ioffe8e4d3462019-01-21 17:56:03 +000090// An uuid used in unit tests.
91static constexpr const char* kTestUuid = "TEST";
92
Nikita Ioffeb68f0d12019-02-04 11:06:37 +000093static constexpr const mode_t kRollbackFolderMode = 0700;
94
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070095static constexpr const char* kCpPath = "/system/bin/cp";
96static constexpr const char* kXattrDefault = "user.default";
Jeff Sharkeye3637242015-04-08 20:56:42 -070097
Ricky Waiff9d3ea2019-11-18 18:18:24 +000098static constexpr const char* kDataMirrorCePath = "/data_mirror/data_ce";
99static constexpr const char* kDataMirrorDePath = "/data_mirror/data_de";
100
Janis Danisevskis40bd3ef2016-06-07 10:31:27 -0700101static constexpr const int MIN_RESTRICTED_HOME_SDK_VERSION = 24; // > M
Janis Danisevskiseecb2d22016-01-12 14:45:55 +0000102
Andreas Gampe0354bd02016-06-27 14:25:30 -0700103static constexpr const char* PKG_LIB_POSTFIX = "/lib";
104static constexpr const char* CACHE_DIR_POSTFIX = "/cache";
105static constexpr const char* CODE_CACHE_DIR_POSTFIX = "/code_cache";
106
Zim0ce832d2019-12-03 17:03:58 +0000107static constexpr const char* kFuseProp = "persist.sys.fuse";
Victor Hsieh99de5162017-10-06 14:44:14 -0700108
Ricky Waiff9d3ea2019-11-18 18:18:24 +0000109/**
110 * Property to control if app data isolation is enabled.
111 */
112static constexpr const char* kAppDataIsolationEnabledProperty = "persist.zygote.app_data_isolation";
Zim1edb92a2020-01-09 08:48:00 +0000113static constexpr const char* kMntSdcardfs = "/mnt/runtime/default/";
114static constexpr const char* kMntFuse = "/mnt/pass_through/0/";
Ricky Waiff9d3ea2019-11-18 18:18:24 +0000115
116static std::atomic<bool> sAppDataIsolationEnabled(false);
117
Jeff Sharkey0274c972016-12-06 09:32:04 -0700118namespace {
119
120constexpr const char* kDump = "android.permission.DUMP";
121
Jeff Sharkey423e7462016-12-09 18:18:43 -0700122static binder::Status ok() {
123 return binder::Status::ok();
124}
125
126static binder::Status exception(uint32_t code, const std::string& msg) {
Jeff Sharkey8e9bf352018-02-27 11:40:45 -0700127 LOG(ERROR) << msg << " (" << code << ")";
Jeff Sharkey423e7462016-12-09 18:18:43 -0700128 return binder::Status::fromExceptionCode(code, String8(msg.c_str()));
129}
130
131static binder::Status error() {
132 return binder::Status::fromServiceSpecificError(errno);
133}
134
135static binder::Status error(const std::string& msg) {
136 PLOG(ERROR) << msg;
137 return binder::Status::fromServiceSpecificError(errno, String8(msg.c_str()));
138}
139
140static binder::Status error(uint32_t code, const std::string& msg) {
141 LOG(ERROR) << msg << " (" << code << ")";
142 return binder::Status::fromServiceSpecificError(code, String8(msg.c_str()));
143}
144
Jeff Sharkey0274c972016-12-06 09:32:04 -0700145binder::Status checkPermission(const char* permission) {
146 pid_t pid;
147 uid_t uid;
148
149 if (checkCallingPermission(String16(permission), reinterpret_cast<int32_t*>(&pid),
150 reinterpret_cast<int32_t*>(&uid))) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700151 return ok();
Jeff Sharkey0274c972016-12-06 09:32:04 -0700152 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700153 return exception(binder::Status::EX_SECURITY,
154 StringPrintf("UID %d / PID %d lacks permission %s", uid, pid, permission));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700155 }
156}
157
158binder::Status checkUid(uid_t expectedUid) {
159 uid_t uid = IPCThreadState::self()->getCallingUid();
160 if (uid == expectedUid || uid == AID_ROOT) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700161 return ok();
Jeff Sharkey0274c972016-12-06 09:32:04 -0700162 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700163 return exception(binder::Status::EX_SECURITY,
164 StringPrintf("UID %d is not expected UID %d", uid, expectedUid));
165 }
166}
167
Jooyung Han149be4a2020-01-23 12:45:10 +0900168binder::Status checkArgumentUuid(const std::optional<std::string>& uuid) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700169 if (!uuid || is_valid_filename(*uuid)) {
170 return ok();
171 } else {
172 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
173 StringPrintf("UUID %s is malformed", uuid->c_str()));
174 }
175}
176
Jooyung Han149be4a2020-01-23 12:45:10 +0900177binder::Status checkArgumentUuidTestOrNull(const std::optional<std::string>& uuid) {
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000178 if (!uuid || strcmp(uuid->c_str(), kTestUuid) == 0) {
179 return ok();
180 } else {
181 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
182 StringPrintf("UUID must be null or \"%s\", got: %s", kTestUuid, uuid->c_str()));
183 }
184}
185
Jeff Sharkey423e7462016-12-09 18:18:43 -0700186binder::Status checkArgumentPackageName(const std::string& packageName) {
Greg Kaiser6d758fc2019-03-26 08:55:32 -0700187 if (is_valid_package_name(packageName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700188 return ok();
189 } else {
190 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
191 StringPrintf("Package name %s is malformed", packageName.c_str()));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700192 }
193}
194
Jeff Sharkey53594302018-02-24 18:59:39 -0700195binder::Status checkArgumentPath(const std::string& path) {
196 if (path.empty()) {
197 return exception(binder::Status::EX_ILLEGAL_ARGUMENT, "Missing path");
198 }
199 if (path[0] != '/') {
200 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
201 StringPrintf("Path %s is relative", path.c_str()));
202 }
203 if ((path + '/').find("/../") != std::string::npos) {
204 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
205 StringPrintf("Path %s is shady", path.c_str()));
206 }
207 for (const char& c : path) {
208 if (c == '\0' || c == '\n') {
209 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
210 StringPrintf("Path %s is malformed", path.c_str()));
211 }
212 }
213 return ok();
214}
215
Jooyung Han149be4a2020-01-23 12:45:10 +0900216binder::Status checkArgumentPath(const std::optional<std::string>& path) {
Jeff Sharkey53594302018-02-24 18:59:39 -0700217 if (path) {
218 return checkArgumentPath(*path);
219 } else {
220 return ok();
221 }
222}
223
Jeff Sharkey0274c972016-12-06 09:32:04 -0700224#define ENFORCE_UID(uid) { \
225 binder::Status status = checkUid((uid)); \
226 if (!status.isOk()) { \
227 return status; \
228 } \
229}
230
Jeff Sharkey423e7462016-12-09 18:18:43 -0700231#define CHECK_ARGUMENT_UUID(uuid) { \
232 binder::Status status = checkArgumentUuid((uuid)); \
233 if (!status.isOk()) { \
234 return status; \
235 } \
236}
237
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000238#define CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(uuid) { \
239 auto status = checkArgumentUuidTestOrNull(uuid); \
240 if (!status.isOk()) { \
241 return status; \
242 } \
243} \
244
Jeff Sharkey423e7462016-12-09 18:18:43 -0700245#define CHECK_ARGUMENT_PACKAGE_NAME(packageName) { \
246 binder::Status status = \
247 checkArgumentPackageName((packageName)); \
248 if (!status.isOk()) { \
249 return status; \
250 } \
251}
252
Jeff Sharkey53594302018-02-24 18:59:39 -0700253#define CHECK_ARGUMENT_PATH(path) { \
254 binder::Status status = checkArgumentPath((path)); \
255 if (!status.isOk()) { \
256 return status; \
257 } \
258}
259
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800260#ifdef GRANULAR_LOCKS
261
262/**
263 * This class obtains in constructor and keeps the local strong pointer to the RefLock.
264 * On destruction, it checks if there are any other strong pointers, and remove the map entry if
265 * this was the last one.
266 */
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800267template <class Key, class Mutex>
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800268struct LocalLockHolder {
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800269 using WeakPointer = std::weak_ptr<Mutex>;
270 using StrongPointer = std::shared_ptr<Mutex>;
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800271 using Map = std::unordered_map<Key, WeakPointer>;
272 using MapLock = std::recursive_mutex;
273
274 LocalLockHolder(Key key, Map& map, MapLock& mapLock)
275 : mKey(std::move(key)), mMap(map), mMapLock(mapLock) {
276 std::lock_guard lock(mMapLock);
277 auto& weakPtr = mMap[mKey];
278
279 // Check if the RefLock is still alive.
280 mRefLock = weakPtr.lock();
281 if (!mRefLock) {
282 // Create a new lock.
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800283 mRefLock = std::make_shared<Mutex>();
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800284 weakPtr = mRefLock;
285 }
286 }
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800287 LocalLockHolder(LocalLockHolder&& other) noexcept
288 : mKey(std::move(other.mKey)),
289 mMap(other.mMap),
290 mMapLock(other.mMapLock),
291 mRefLock(std::move(other.mRefLock)) {
292 other.mRefLock.reset();
293 }
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800294 ~LocalLockHolder() {
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800295 if (!mRefLock) {
296 return;
297 }
298
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800299 std::lock_guard lock(mMapLock);
300 // Clear the strong pointer.
301 mRefLock.reset();
302 auto found = mMap.find(mKey);
303 if (found == mMap.end()) {
304 return;
305 }
306 const auto& weakPtr = found->second;
307 // If this was the last pointer then it's ok to remove the map entry.
308 if (weakPtr.expired()) {
309 mMap.erase(found);
310 }
311 }
312
313 void lock() { mRefLock->lock(); }
314 void unlock() { mRefLock->unlock(); }
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800315 void lock_shared() { mRefLock->lock_shared(); }
316 void unlock_shared() { mRefLock->unlock_shared(); }
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800317
318private:
319 Key mKey;
320 Map& mMap;
321 MapLock& mMapLock;
322 StrongPointer mRefLock;
323};
324
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800325using UserLock = LocalLockHolder<userid_t, std::shared_mutex>;
326using UserWriteLockGuard = std::unique_lock<UserLock>;
327using UserReadLockGuard = std::shared_lock<UserLock>;
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800328
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800329using PackageLock = LocalLockHolder<std::string, std::recursive_mutex>;
330using PackageLockGuard = std::lock_guard<PackageLock>;
331
332#define LOCK_USER() \
333 UserLock localUserLock(userId, mUserIdLock, mLock); \
334 UserWriteLockGuard userLock(localUserLock)
335
336#define LOCK_USER_READ() \
337 UserLock localUserLock(userId, mUserIdLock, mLock); \
338 UserReadLockGuard userLock(localUserLock)
339
340#define LOCK_PACKAGE() \
341 PackageLock localPackageLock(packageName, mPackageNameLock, mLock); \
342 PackageLockGuard packageLock(localPackageLock)
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800343
344#define LOCK_PACKAGE_USER() \
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800345 LOCK_USER_READ(); \
346 LOCK_PACKAGE()
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800347
348#else
349
350#define LOCK_USER() std::lock_guard lock(mLock)
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800351#define LOCK_PACKAGE() std::lock_guard lock(mLock)
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800352#define LOCK_PACKAGE_USER() \
353 (void)userId; \
354 std::lock_guard lock(mLock)
355
356#endif // GRANULAR_LOCKS
357
Jeff Sharkey0274c972016-12-06 09:32:04 -0700358} // namespace
359
360status_t InstalldNativeService::start() {
361 IPCThreadState::self()->disableBackgroundScheduling(true);
362 status_t ret = BinderService<InstalldNativeService>::publish();
363 if (ret != android::OK) {
364 return ret;
365 }
366 sp<ProcessState> ps(ProcessState::self());
367 ps->startThreadPool();
368 ps->giveThreadPoolName();
Ricky Waiff9d3ea2019-11-18 18:18:24 +0000369 sAppDataIsolationEnabled = android::base::GetBoolProperty(
Ricky Wai30f947d2019-12-19 17:24:48 +0000370 kAppDataIsolationEnabledProperty, true);
Jeff Sharkey0274c972016-12-06 09:32:04 -0700371 return android::OK;
372}
373
374status_t InstalldNativeService::dump(int fd, const Vector<String16> & /* args */) {
375 const binder::Status dump_permission = checkPermission(kDump);
376 if (!dump_permission.isOk()) {
Keun young Park144a9892021-10-13 16:43:58 -0700377 dprintf(fd, "%s\n", dump_permission.toString8().c_str());
Jeff Sharkey0274c972016-12-06 09:32:04 -0700378 return PERMISSION_DENIED;
379 }
380
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700381 {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -0600382 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
Keun young Park144a9892021-10-13 16:43:58 -0700383 dprintf(fd, "Storage mounts:\n");
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -0600384 for (const auto& n : mStorageMounts) {
Keun young Park144a9892021-10-13 16:43:58 -0700385 dprintf(fd, " %s = %s\n", n.first.c_str(), n.second.c_str());
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -0600386 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700387 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700388
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700389 {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -0600390 std::lock_guard<std::recursive_mutex> lock(mQuotasLock);
Keun young Park144a9892021-10-13 16:43:58 -0700391 dprintf(fd, "Per-UID cache quotas:\n");
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700392 for (const auto& n : mCacheQuotas) {
Keun young Park144a9892021-10-13 16:43:58 -0700393 dprintf(fd, " %d = %" PRId64 "\n", n.first, n.second);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700394 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700395 }
396
Keun young Park144a9892021-10-13 16:43:58 -0700397 dprintf(fd, "is_dexopt_blocked:%d\n", android::installd::is_dexopt_blocked());
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700398
Jeff Sharkey0274c972016-12-06 09:32:04 -0700399 return NO_ERROR;
400}
401
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600402/**
403 * Perform restorecon of the given path, but only perform recursive restorecon
404 * if the label of that top-level file actually changed. This can save us
405 * significant time by avoiding no-op traversals of large filesystem trees.
406 */
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700407static int restorecon_app_data_lazy(const std::string& path, const std::string& seInfo, uid_t uid,
408 bool existing) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600409 int res = 0;
410 char* before = nullptr;
411 char* after = nullptr;
Jigar Thakkarf42c8a72021-10-28 17:24:33 +0000412 if (!existing) {
413 if (selinux_android_restorecon_pkgdir(path.c_str(), seInfo.c_str(), uid,
414 SELINUX_ANDROID_RESTORECON_RECURSE) < 0) {
415 PLOG(ERROR) << "Failed recursive restorecon for " << path;
416 goto fail;
417 }
418 return res;
419 }
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600420
421 // Note that SELINUX_ANDROID_RESTORECON_DATADATA flag is set by
422 // libselinux. Not needed here.
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600423 if (lgetfilecon(path.c_str(), &before) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600424 PLOG(ERROR) << "Failed before getfilecon for " << path;
425 goto fail;
426 }
Jeff Sharkey0274c972016-12-06 09:32:04 -0700427 if (selinux_android_restorecon_pkgdir(path.c_str(), seInfo.c_str(), uid, 0) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600428 PLOG(ERROR) << "Failed top-level restorecon for " << path;
429 goto fail;
430 }
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600431 if (lgetfilecon(path.c_str(), &after) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600432 PLOG(ERROR) << "Failed after getfilecon for " << path;
433 goto fail;
434 }
435
436 // If the initial top-level restorecon above changed the label, then go
437 // back and restorecon everything recursively
Jeff Vander Stoep4689cdc2021-06-28 18:59:47 +0200438 if (strcmp(before, after)) {
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700439 if (existing) {
440 LOG(DEBUG) << "Detected label change from " << before << " to " << after << " at "
441 << path << "; running recursive restorecon";
442 }
Jeff Sharkey0274c972016-12-06 09:32:04 -0700443 if (selinux_android_restorecon_pkgdir(path.c_str(), seInfo.c_str(), uid,
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600444 SELINUX_ANDROID_RESTORECON_RECURSE) < 0) {
445 PLOG(ERROR) << "Failed recursive restorecon for " << path;
446 goto fail;
447 }
448 }
449
450 goto done;
451fail:
452 res = -1;
453done:
454 free(before);
455 free(after);
456 return res;
457}
458
459static int prepare_app_dir(const std::string& path, mode_t target_mode, uid_t uid) {
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600460 if (fs_prepare_dir_strict(path.c_str(), target_mode, uid, uid) != 0) {
461 PLOG(ERROR) << "Failed to prepare " << path;
462 return -1;
463 }
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600464 return 0;
465}
466
Calin Juravled2affb82017-11-28 17:41:43 -0800467static bool prepare_app_profile_dir(const std::string& packageName, int32_t appId, int32_t userId) {
468 if (!property_get_bool("dalvik.vm.usejitprofiles", false)) {
469 return true;
470 }
471
472 int32_t uid = multiuser_get_uid(userId, appId);
473 int shared_app_gid = multiuser_get_shared_gid(userId, appId);
474 if (shared_app_gid == -1) {
475 // TODO(calin): this should no longer be possible but do not continue if we don't get
476 // a valid shared gid.
477 PLOG(WARNING) << "Invalid shared_app_gid for " << packageName;
478 return true;
479 }
480
481 const std::string profile_dir =
482 create_primary_current_profile_package_dir_path(userId, packageName);
483 // read-write-execute only for the app user.
484 if (fs_prepare_dir_strict(profile_dir.c_str(), 0700, uid, uid) != 0) {
485 PLOG(ERROR) << "Failed to prepare " << profile_dir;
486 return false;
487 }
Alan Stokes928d2c12020-12-09 10:11:24 +0000488 if (selinux_android_restorecon(profile_dir.c_str(), 0)) {
489 PLOG(ERROR) << "Failed to restorecon " << profile_dir;
490 return false;
491 }
Calin Juravlecfcd6aa2018-01-18 20:23:17 -0800492
Calin Juravled2affb82017-11-28 17:41:43 -0800493 const std::string ref_profile_path =
494 create_primary_reference_profile_package_dir_path(packageName);
Calin Juravle6f06eb62017-11-28 18:44:53 -0800495
496 // Prepare the reference profile directory. Note that we use the non strict version of
497 // fs_prepare_dir. This will fix the permission and the ownership to the correct values.
498 // This is particularly important given that in O there were some fixes for how the
499 // shared_app_gid is computed.
500 //
501 // Note that by the time we get here we know that we are using a correct uid (otherwise
502 // prepare_app_dir and the above fs_prepare_file_strict which check the uid). So we
503 // are sure that the gid being used belongs to the owning app and not someone else.
504 //
505 // dex2oat/profman runs under the shared app gid and it needs to read/write reference profiles.
506 if (fs_prepare_dir(ref_profile_path.c_str(), 0770, AID_SYSTEM, shared_app_gid) != 0) {
Calin Juravled2affb82017-11-28 17:41:43 -0800507 PLOG(ERROR) << "Failed to prepare " << ref_profile_path;
508 return false;
509 }
Calin Juravle6f06eb62017-11-28 18:44:53 -0800510
Calin Juravled2affb82017-11-28 17:41:43 -0800511 return true;
512}
513
John Wu84e8f242021-10-21 11:50:41 -0700514static bool chown_app_dir(const std::string& path, uid_t uid, uid_t previousUid, gid_t cacheGid) {
515 FTS* fts;
516 char *argv[] = { (char*) path.c_str(), nullptr };
517 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
518 return false;
519 }
520 for (FTSENT* p; (p = fts_read(fts)) != nullptr;) {
521 if (p->fts_info == FTS_D && p->fts_level == 1
522 && (strcmp(p->fts_name, "cache") == 0
523 || strcmp(p->fts_name, "code_cache") == 0)) {
524 // Mark cache dirs
525 p->fts_number = 1;
526 } else {
527 // Inherit parent's number
528 p->fts_number = p->fts_parent->fts_number;
529 }
530
531 switch (p->fts_info) {
532 case FTS_D:
533 case FTS_F:
534 case FTS_SL:
535 case FTS_SLNONE:
536 if (p->fts_statp->st_uid == previousUid) {
537 if (lchown(p->fts_path, uid, p->fts_number ? cacheGid : uid) != 0) {
538 PLOG(WARNING) << "Failed to lchown " << p->fts_path;
539 }
540 } else {
541 LOG(WARNING) << "Ignoring " << p->fts_path << " with unexpected UID "
542 << p->fts_statp->st_uid << " instead of " << previousUid;
543 }
544 break;
545 }
546 }
547 fts_close(fts);
548 return true;
549}
550
551static void chown_app_profile_dir(const std::string &packageName, int32_t appId, int32_t userId) {
552 uid_t uid = multiuser_get_uid(userId, appId);
553 gid_t sharedGid = multiuser_get_shared_gid(userId, appId);
554
555 const std::string profile_dir =
556 create_primary_current_profile_package_dir_path(userId, packageName);
557 char *argv[] = { (char*) profile_dir.c_str(), nullptr };
558 if (FTS* fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr)) {
559 for (FTSENT* p; (p = fts_read(fts)) != nullptr;) {
560 switch (p->fts_info) {
561 case FTS_D:
562 case FTS_F:
563 case FTS_SL:
564 case FTS_SLNONE:
565 if (lchown(p->fts_path, uid, uid) != 0) {
566 PLOG(WARNING) << "Failed to lchown " << p->fts_path;
567 }
568 break;
569 }
570 }
571 fts_close(fts);
572 }
573
574 const std::string ref_profile_path =
575 create_primary_reference_profile_package_dir_path(packageName);
576 argv[0] = (char *) ref_profile_path.c_str();
577 if (FTS* fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr)) {
578 for (FTSENT* p; (p = fts_read(fts)) != nullptr;) {
579 if (p->fts_info == FTS_D && p->fts_level == 0) {
580 if (chown(p->fts_path, AID_SYSTEM, sharedGid) != 0) {
581 PLOG(WARNING) << "Failed to chown " << p->fts_path;
582 }
583 continue;
584 }
585 switch (p->fts_info) {
586 case FTS_D:
587 case FTS_F:
588 case FTS_SL:
589 case FTS_SLNONE:
590 if (lchown(p->fts_path, sharedGid, sharedGid) != 0) {
591 PLOG(WARNING) << "Failed to lchown " << p->fts_path;
592 }
593 break;
594 }
595 }
596 fts_close(fts);
597 }
598}
599
600static binder::Status createAppDataDirs(const std::string& path,
601 int32_t uid, int32_t* previousUid, int32_t cacheGid,
602 const std::string& seInfo, mode_t targetMode) {
603 struct stat st{};
Jigar Thakkarf42c8a72021-10-28 17:24:33 +0000604 bool parent_dir_exists = (stat(path.c_str(), &st) == 0);
605
606 auto cache_path = StringPrintf("%s/%s", path.c_str(), "cache");
607 auto code_cache_path = StringPrintf("%s/%s", path.c_str(), "code_cache");
608 bool cache_exists = (access(cache_path.c_str(), F_OK) == 0);
609 bool code_cache_exists = (access(code_cache_path.c_str(), F_OK) == 0);
610
611 if (parent_dir_exists) {
John Wu84e8f242021-10-21 11:50:41 -0700612 if (*previousUid < 0) {
613 // If previousAppId is -1 in CreateAppDataArgs, we will assume the current owner
614 // of the directory as previousUid. This is required because it is not always possible
615 // to chown app data during app upgrade (e.g. secondary users' CE storage not unlocked)
616 *previousUid = st.st_uid;
617 }
618 if (*previousUid != uid) {
619 if (!chown_app_dir(path, uid, *previousUid, cacheGid)) {
620 return error("Failed to chown " + path);
621 }
622 }
623 }
624
Jigar Thakkarf42c8a72021-10-28 17:24:33 +0000625 // Prepare only the parent app directory
John Wu84e8f242021-10-21 11:50:41 -0700626 if (prepare_app_dir(path, targetMode, uid) ||
627 prepare_app_cache_dir(path, "cache", 02771, uid, cacheGid) ||
628 prepare_app_cache_dir(path, "code_cache", 02771, uid, cacheGid)) {
629 return error("Failed to prepare " + path);
630 }
631
632 // Consider restorecon over contents if label changed
Jigar Thakkarf42c8a72021-10-28 17:24:33 +0000633 if (restorecon_app_data_lazy(path, seInfo, uid, parent_dir_exists)) {
John Wu84e8f242021-10-21 11:50:41 -0700634 return error("Failed to restorecon " + path);
635 }
636
Jigar Thakkarf42c8a72021-10-28 17:24:33 +0000637 // If the parent dir exists, the restorecon would already have been done
638 // as a part of the recursive restorecon above
639 if (parent_dir_exists && !cache_exists
640 && restorecon_app_data_lazy(cache_path, seInfo, uid, false)) {
641 return error("Failed to restorecon " + cache_path);
642 }
643
644 // If the parent dir exists, the restorecon would already have been done
645 // as a part of the recursive restorecon above
646 if (parent_dir_exists && !code_cache_exists
647 && restorecon_app_data_lazy(code_cache_path, seInfo, uid, false)) {
648 return error("Failed to restorecon " + code_cache_path);
649 }
John Wu84e8f242021-10-21 11:50:41 -0700650 return ok();
651}
652
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800653binder::Status InstalldNativeService::createAppDataLocked(
654 const std::optional<std::string>& uuid, const std::string& packageName, int32_t userId,
655 int32_t flags, int32_t appId, int32_t previousAppId, const std::string& seInfo,
656 int32_t targetSdkVersion, int64_t* _aidl_return) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700657 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700658 CHECK_ARGUMENT_UUID(uuid);
659 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey0274c972016-12-06 09:32:04 -0700660
661 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
662 const char* pkgname = packageName.c_str();
663
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700664 // Assume invalid inode unless filled in below
665 if (_aidl_return != nullptr) *_aidl_return = -1;
666
Jeff Sharkey24ef15b2017-01-12 19:27:03 -0700667 int32_t uid = multiuser_get_uid(userId, appId);
John Wu84e8f242021-10-21 11:50:41 -0700668
669 // If previousAppId < 0, we will use the existing app data owner as previousAppUid
670 // If previousAppId == 0, we use uid as previousUid (no data migration will happen)
671 // if previousAppId > 0, an app is upgrading and changing its app ID
672 int32_t previousUid = previousAppId > 0
673 ? (int32_t) multiuser_get_uid(userId, previousAppId)
674 : (previousAppId == 0 ? uid : -1);
675
Jeff Sharkey24ef15b2017-01-12 19:27:03 -0700676 int32_t cacheGid = multiuser_get_cache_gid(userId, appId);
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -0700677 mode_t targetMode = targetSdkVersion >= MIN_RESTRICTED_HOME_SDK_VERSION ? 0700 : 0751;
678
Jeff Sharkey24ef15b2017-01-12 19:27:03 -0700679 // If UID doesn't have a specific cache GID, use UID value
680 if (cacheGid == -1) {
681 cacheGid = uid;
682 }
683
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700684 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700685 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname);
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700686
John Wu84e8f242021-10-21 11:50:41 -0700687 auto status = createAppDataDirs(path, uid, &previousUid, cacheGid, seInfo, targetMode);
688 if (!status.isOk()) {
689 return status;
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600690 }
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600691
692 // Remember inode numbers of cache directories so that we can clear
693 // contents while CE storage is locked
694 if (write_path_inode(path, "cache", kXattrInodeCache) ||
695 write_path_inode(path, "code_cache", kXattrInodeCodeCache)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700696 return error("Failed to write_path_inode for " + path);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700697 }
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700698
699 // And return the CE inode of the top-level data directory so we can
700 // clear contents while CE storage is locked
Ricky Waiff9d3ea2019-11-18 18:18:24 +0000701 if (_aidl_return != nullptr) {
702 ino_t result;
703 if (get_path_inode(path, &result) != 0) {
704 return error("Failed to get_path_inode for " + path);
705 }
706 *_aidl_return = static_cast<uint64_t>(result);
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700707 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700708 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700709 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700710 auto path = create_data_user_de_package_path(uuid_, userId, pkgname);
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700711
John Wu84e8f242021-10-21 11:50:41 -0700712 auto status = createAppDataDirs(path, uid, &previousUid, cacheGid, seInfo, targetMode);
713 if (!status.isOk()) {
714 return status;
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600715 }
John Wu3b383372022-02-09 02:21:39 -0800716 if (previousUid != uid) {
717 chown_app_profile_dir(packageName, appId, userId);
718 }
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600719
Calin Juravled2affb82017-11-28 17:41:43 -0800720 if (!prepare_app_profile_dir(packageName, appId, userId)) {
721 return error("Failed to prepare profiles for " + packageName);
Calin Juravle6a1648e2016-02-01 12:12:16 +0000722 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700723 }
Samiul Islamb911bc62022-01-14 16:24:48 +0000724
Samiul Islama0340b32022-02-21 15:23:36 +0000725 if (flags & FLAG_STORAGE_SDK) {
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000726 auto status = createSdkSandboxDataDirectory(uuid, packageName, userId, appId, previousAppId,
727 seInfo, flags);
Samiul Islamb911bc62022-01-14 16:24:48 +0000728 if (!status.isOk()) {
729 return status;
730 }
731 }
732
733 return ok();
734}
735
736/**
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000737 * Responsible for creating /data/misc_{ce|de}/user/0/sdksandbox/<app-name> directory and other
Samiul Islamb911bc62022-01-14 16:24:48 +0000738 * app level sub directories, such as ./shared
739 */
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000740binder::Status InstalldNativeService::createSdkSandboxDataDirectory(
Samiul Islamb911bc62022-01-14 16:24:48 +0000741 const std::optional<std::string>& uuid, const std::string& packageName, int32_t userId,
742 int32_t appId, int32_t previousAppId, const std::string& seInfo, int32_t flags) {
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000743 int32_t sdkSandboxUid = multiuser_get_sdk_sandbox_uid(userId, appId);
744 if (sdkSandboxUid == -1) {
745 // There no valid sdk sandbox process for this app. Skip creation of data directory
Samiul Islamb911bc62022-01-14 16:24:48 +0000746 return ok();
747 }
748
749 // TODO(b/211763739): what if uuid is not nullptr or TEST?
750 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
751
752 constexpr int storageFlags[2] = {FLAG_STORAGE_CE, FLAG_STORAGE_DE};
753 for (int i = 0; i < 2; i++) {
754 int currentFlag = storageFlags[i];
755 if ((flags & currentFlag) == 0) {
756 continue;
757 }
758 bool isCeData = (currentFlag == FLAG_STORAGE_CE);
759
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000760 // /data/misc_{ce,de}/<user-id>/sdksandbox directory gets created by vold
Samiul Islamb911bc62022-01-14 16:24:48 +0000761 // during user creation
762
763 // Prepare the app directory
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000764 auto appPath = create_data_misc_sdk_sandbox_package_path(uuid_, isCeData, userId,
765 packageName.c_str());
Samiul Islamb911bc62022-01-14 16:24:48 +0000766 if (prepare_app_dir(appPath, 0751, AID_SYSTEM)) {
767 return error("Failed to prepare " + appPath);
768 }
769
770 // Now prepare the shared directory which will be accessible by all codes
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000771 auto sharedPath = create_data_misc_sdk_sandbox_shared_path(uuid_, isCeData, userId,
772 packageName.c_str());
Samiul Islamb911bc62022-01-14 16:24:48 +0000773
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000774 int32_t previousSdkSandboxUid = multiuser_get_sdk_sandbox_uid(userId, previousAppId);
Samiul Islamb911bc62022-01-14 16:24:48 +0000775 int32_t cacheGid = multiuser_get_cache_gid(userId, appId);
776 if (cacheGid == -1) {
777 return exception(binder::Status::EX_ILLEGAL_STATE,
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000778 StringPrintf("cacheGid cannot be -1 for sdksandbox data"));
Samiul Islamb911bc62022-01-14 16:24:48 +0000779 }
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000780 auto status = createAppDataDirs(sharedPath, sdkSandboxUid, &previousSdkSandboxUid, cacheGid,
781 seInfo, 0700);
Samiul Islamb911bc62022-01-14 16:24:48 +0000782 if (!status.isOk()) {
783 return status;
784 }
785
786 // TODO(b/211763739): We also need to handle art profile creations
787
Nikita Ioffe9c3e8f52022-02-21 19:02:05 +0000788 // TODO(b/211763739): And return the CE inode of the sdksandbox root directory and
Samiul Islamb911bc62022-01-14 16:24:48 +0000789 // app directory under it so we can clear contents while CE storage is locked
790 }
791
Jeff Sharkey423e7462016-12-09 18:18:43 -0700792 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -0700793}
794
Jeff Sharkey8d3848b2020-08-13 14:16:46 -0600795binder::Status InstalldNativeService::createAppData(
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800796 const std::optional<std::string>& uuid, const std::string& packageName, int32_t userId,
797 int32_t flags, int32_t appId, int32_t previousAppId, const std::string& seInfo,
798 int32_t targetSdkVersion, int64_t* _aidl_return) {
799 ENFORCE_UID(AID_SYSTEM);
800 CHECK_ARGUMENT_UUID(uuid);
801 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
802 LOCK_PACKAGE_USER();
803 return createAppDataLocked(uuid, packageName, userId, flags, appId, previousAppId, seInfo,
804 targetSdkVersion, _aidl_return);
805}
806
807binder::Status InstalldNativeService::createAppData(
Jeff Sharkey8d3848b2020-08-13 14:16:46 -0600808 const android::os::CreateAppDataArgs& args,
809 android::os::CreateAppDataResult* _aidl_return) {
810 ENFORCE_UID(AID_SYSTEM);
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800811 // Locking is performed depeer in the callstack.
Jeff Sharkey8d3848b2020-08-13 14:16:46 -0600812
813 int64_t ceDataInode = -1;
814 auto status = createAppData(args.uuid, args.packageName, args.userId, args.flags, args.appId,
John Wu84e8f242021-10-21 11:50:41 -0700815 args.previousAppId, args.seInfo, args.targetSdkVersion, &ceDataInode);
Jeff Sharkey8d3848b2020-08-13 14:16:46 -0600816 _aidl_return->ceDataInode = ceDataInode;
817 _aidl_return->exceptionCode = status.exceptionCode();
818 _aidl_return->exceptionMessage = status.exceptionMessage();
819 return ok();
820}
821
822binder::Status InstalldNativeService::createAppDataBatched(
823 const std::vector<android::os::CreateAppDataArgs>& args,
824 std::vector<android::os::CreateAppDataResult>* _aidl_return) {
825 ENFORCE_UID(AID_SYSTEM);
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -0800826 // Locking is performed depeer in the callstack.
Jeff Sharkey8d3848b2020-08-13 14:16:46 -0600827
828 std::vector<android::os::CreateAppDataResult> results;
John Wu84e8f242021-10-21 11:50:41 -0700829 for (const auto &arg : args) {
Jeff Sharkey8d3848b2020-08-13 14:16:46 -0600830 android::os::CreateAppDataResult result;
831 createAppData(arg, &result);
832 results.push_back(result);
833 }
834 *_aidl_return = results;
835 return ok();
836}
837
Jooyung Han149be4a2020-01-23 12:45:10 +0900838binder::Status InstalldNativeService::migrateAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700839 const std::string& packageName, int32_t userId, int32_t flags) {
840 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700841 CHECK_ARGUMENT_UUID(uuid);
842 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800843 LOCK_PACKAGE_USER();
Jeff Sharkey423e7462016-12-09 18:18:43 -0700844
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700845 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
846 const char* pkgname = packageName.c_str();
847
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700848 // This method only exists to upgrade system apps that have requested
849 // forceDeviceEncrypted, so their default storage always lives in a
850 // consistent location. This only works on non-FBE devices, since we
851 // never want to risk exposing data on a device with real CE/DE storage.
852
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700853 auto ce_path = create_data_user_ce_package_path(uuid_, userId, pkgname);
854 auto de_path = create_data_user_de_package_path(uuid_, userId, pkgname);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700855
856 // If neither directory is marked as default, assume CE is default
857 if (getxattr(ce_path.c_str(), kXattrDefault, nullptr, 0) == -1
858 && getxattr(de_path.c_str(), kXattrDefault, nullptr, 0) == -1) {
859 if (setxattr(ce_path.c_str(), kXattrDefault, nullptr, 0, 0) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700860 return error("Failed to mark default storage " + ce_path);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700861 }
862 }
863
864 // Migrate default data location if needed
865 auto target = (flags & FLAG_STORAGE_DE) ? de_path : ce_path;
866 auto source = (flags & FLAG_STORAGE_DE) ? ce_path : de_path;
867
868 if (getxattr(target.c_str(), kXattrDefault, nullptr, 0) == -1) {
869 LOG(WARNING) << "Requested default storage " << target
870 << " is not active; migrating from " << source;
871 if (delete_dir_contents_and_dir(target) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700872 return error("Failed to delete " + target);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700873 }
874 if (rename(source.c_str(), target.c_str()) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700875 return error("Failed to rename " + source + " to " + target);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700876 }
877 }
878
Jeff Sharkey423e7462016-12-09 18:18:43 -0700879 return ok();
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700880}
881
Calin Juravle6a1648e2016-02-01 12:12:16 +0000882
Calin Juravle562de812018-01-20 23:34:18 -0800883binder::Status InstalldNativeService::clearAppProfiles(const std::string& packageName,
884 const std::string& profileName) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700885 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700886 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800887 LOCK_PACKAGE();
Jeff Sharkey423e7462016-12-09 18:18:43 -0700888
Jeff Sharkey423e7462016-12-09 18:18:43 -0700889 binder::Status res = ok();
Calin Juravle562de812018-01-20 23:34:18 -0800890 if (!clear_primary_reference_profile(packageName, profileName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700891 res = error("Failed to clear reference profile for " + packageName);
892 }
Calin Juravle562de812018-01-20 23:34:18 -0800893 if (!clear_primary_current_profiles(packageName, profileName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700894 res = error("Failed to clear current profiles for " + packageName);
895 }
896 return res;
Calin Juravle6a1648e2016-02-01 12:12:16 +0000897}
898
Jooyung Han149be4a2020-01-23 12:45:10 +0900899binder::Status InstalldNativeService::clearAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700900 const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {
901 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700902 CHECK_ARGUMENT_UUID(uuid);
903 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -0800904 LOCK_PACKAGE_USER();
Jeff Sharkey423e7462016-12-09 18:18:43 -0700905
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700906 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
907 const char* pkgname = packageName.c_str();
908
Jeff Sharkey423e7462016-12-09 18:18:43 -0700909 binder::Status res = ok();
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700910 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700911 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInode);
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600912 if (flags & FLAG_CLEAR_CACHE_ONLY) {
913 path = read_path_inode(path, "cache", kXattrInodeCache);
914 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
915 path = read_path_inode(path, "code_cache", kXattrInodeCodeCache);
916 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700917 if (access(path.c_str(), F_OK) == 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700918 if (delete_dir_contents(path) != 0) {
919 res = error("Failed to delete contents of " + path);
Ryuki Nakamurac7342f82017-09-30 11:57:00 +0900920 } else if ((flags & (FLAG_CLEAR_CACHE_ONLY | FLAG_CLEAR_CODE_CACHE_ONLY)) == 0) {
921 remove_path_xattr(path, kXattrInodeCache);
922 remove_path_xattr(path, kXattrInodeCodeCache);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700923 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700924 }
925 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700926 if (flags & FLAG_STORAGE_DE) {
John Wu84e8f242021-10-21 11:50:41 -0700927 std::string suffix;
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600928 if (flags & FLAG_CLEAR_CACHE_ONLY) {
929 suffix = CACHE_DIR_POSTFIX;
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600930 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
931 suffix = CODE_CACHE_DIR_POSTFIX;
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600932 }
933
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700934 auto path = create_data_user_de_package_path(uuid_, userId, pkgname) + suffix;
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700935 if (access(path.c_str(), F_OK) == 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700936 if (delete_dir_contents(path) != 0) {
937 res = error("Failed to delete contents of " + path);
938 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700939 }
940 }
Jeff Sharkey6e175692019-05-14 14:55:33 -0600941 if (flags & FLAG_STORAGE_EXTERNAL) {
942 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
943 for (const auto& n : mStorageMounts) {
944 auto extPath = n.second;
Zim0ce832d2019-12-03 17:03:58 +0000945
946 if (android::base::GetBoolProperty(kFuseProp, false)) {
947 std::regex re("^\\/mnt\\/pass_through\\/[0-9]+\\/emulated");
948 if (std::regex_match(extPath, re)) {
949 extPath += "/" + std::to_string(userId);
950 }
951 } else {
952 if (n.first.compare(0, 14, "/mnt/media_rw/") != 0) {
953 extPath += StringPrintf("/%d", userId);
954 } else if (userId != 0) {
955 // TODO: support devices mounted under secondary users
956 continue;
957 }
Jeff Sharkey6e175692019-05-14 14:55:33 -0600958 }
Zim0ce832d2019-12-03 17:03:58 +0000959
Jeff Sharkey6e175692019-05-14 14:55:33 -0600960 if (flags & FLAG_CLEAR_CACHE_ONLY) {
961 // Clear only cached data from shared storage
962 auto path = StringPrintf("%s/Android/data/%s/cache", extPath.c_str(), pkgname);
963 if (delete_dir_contents(path, true) != 0) {
964 res = error("Failed to delete contents of " + path);
965 }
966 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
967 // No code cache on shared storage
968 } else {
969 // Clear everything on shared storage
970 auto path = StringPrintf("%s/Android/data/%s", extPath.c_str(), pkgname);
971 if (delete_dir_contents(path, true) != 0) {
972 res = error("Failed to delete contents of " + path);
973 }
974 path = StringPrintf("%s/Android/media/%s", extPath.c_str(), pkgname);
975 if (delete_dir_contents(path, true) != 0) {
976 res = error("Failed to delete contents of " + path);
977 }
Martijn Coenen24a93072020-01-08 10:10:43 +0100978 // Note that we explicitly don't delete OBBs - those are only removed on
979 // app uninstall.
Jeff Sharkey6e175692019-05-14 14:55:33 -0600980 }
981 }
982 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700983 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700984}
985
Calin Juravle76268c52017-03-09 13:19:42 -0800986static int destroy_app_reference_profile(const std::string& pkgname) {
Calin Juravle7535e8e2016-03-29 16:05:40 +0100987 return delete_dir_contents_and_dir(
Calin Juravle114f0812017-03-08 19:05:07 -0800988 create_primary_reference_profile_package_dir_path(pkgname),
Calin Juravle7535e8e2016-03-29 16:05:40 +0100989 /*ignore_if_missing*/ true);
990}
991
Calin Juravle76268c52017-03-09 13:19:42 -0800992static int destroy_app_current_profiles(const std::string& pkgname, userid_t userid) {
Calin Juravleb06f98a2016-03-28 15:11:01 +0100993 return delete_dir_contents_and_dir(
Calin Juravle114f0812017-03-08 19:05:07 -0800994 create_primary_current_profile_package_dir_path(userid, pkgname),
Calin Juravleb06f98a2016-03-28 15:11:01 +0100995 /*ignore_if_missing*/ true);
Calin Juravleedae6692016-03-23 13:55:31 +0000996}
997
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700998binder::Status InstalldNativeService::destroyAppProfiles(const std::string& packageName) {
999 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001000 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001001 LOCK_PACKAGE();
Jeff Sharkey423e7462016-12-09 18:18:43 -07001002
Jeff Sharkey423e7462016-12-09 18:18:43 -07001003 binder::Status res = ok();
Calin Juravleedae6692016-03-23 13:55:31 +00001004 std::vector<userid_t> users = get_known_users(/*volume_uuid*/ nullptr);
1005 for (auto user : users) {
Calin Juravle76268c52017-03-09 13:19:42 -08001006 if (destroy_app_current_profiles(packageName, user) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001007 res = error("Failed to destroy current profiles for " + packageName);
1008 }
Calin Juravleedae6692016-03-23 13:55:31 +00001009 }
Calin Juravle76268c52017-03-09 13:19:42 -08001010 if (destroy_app_reference_profile(packageName) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001011 res = error("Failed to destroy reference profile for " + packageName);
1012 }
1013 return res;
Calin Juravlecaa6b802016-03-22 14:15:52 +00001014}
1015
Jooyung Han149be4a2020-01-23 12:45:10 +09001016binder::Status InstalldNativeService::destroyAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001017 const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {
1018 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001019 CHECK_ARGUMENT_UUID(uuid);
1020 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001021 LOCK_PACKAGE_USER();
Jeff Sharkey423e7462016-12-09 18:18:43 -07001022
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001023 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
1024 const char* pkgname = packageName.c_str();
1025
Jeff Sharkey423e7462016-12-09 18:18:43 -07001026 binder::Status res = ok();
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07001027 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001028 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInode);
Alex Buynytskyy038a19b2022-02-09 19:51:52 -08001029 if (rename_delete_dir_contents_and_dir(path) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001030 res = error("Failed to delete " + path);
1031 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001032 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07001033 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001034 auto path = create_data_user_de_package_path(uuid_, userId, pkgname);
Alex Buynytskyy038a19b2022-02-09 19:51:52 -08001035 if (rename_delete_dir_contents_and_dir(path) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001036 res = error("Failed to delete " + path);
1037 }
Alan Stokesd983cc72020-02-14 14:36:58 +00001038 if ((flags & FLAG_CLEAR_APP_DATA_KEEP_ART_PROFILES) == 0) {
1039 destroy_app_current_profiles(packageName, userId);
1040 // TODO(calin): If the package is still installed by other users it's probably
1041 // beneficial to keep the reference profile around.
1042 // Verify if it's ok to do that.
1043 destroy_app_reference_profile(packageName);
1044 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001045 }
Jeff Sharkey6e175692019-05-14 14:55:33 -06001046 if (flags & FLAG_STORAGE_EXTERNAL) {
1047 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
1048 for (const auto& n : mStorageMounts) {
1049 auto extPath = n.second;
Zim0ce832d2019-12-03 17:03:58 +00001050
1051 if (android::base::GetBoolProperty(kFuseProp, false)) {
1052 std::regex re("^\\/mnt\\/pass_through\\/[0-9]+\\/emulated");
1053 if (std::regex_match(extPath, re)) {
1054 extPath += "/" + std::to_string(userId);
1055 }
1056 } else {
1057 if (n.first.compare(0, 14, "/mnt/media_rw/") != 0) {
1058 extPath += StringPrintf("/%d", userId);
1059 } else if (userId != 0) {
1060 // TODO: support devices mounted under secondary users
1061 continue;
1062 }
Jeff Sharkey6e175692019-05-14 14:55:33 -06001063 }
Zim0ce832d2019-12-03 17:03:58 +00001064
Jeff Sharkey6e175692019-05-14 14:55:33 -06001065 auto path = StringPrintf("%s/Android/data/%s", extPath.c_str(), pkgname);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001066 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey6e175692019-05-14 14:55:33 -06001067 res = error("Failed to delete contents of " + path);
1068 }
1069 path = StringPrintf("%s/Android/media/%s", extPath.c_str(), pkgname);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001070 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey6e175692019-05-14 14:55:33 -06001071 res = error("Failed to delete contents of " + path);
1072 }
1073 path = StringPrintf("%s/Android/obb/%s", extPath.c_str(), pkgname);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001074 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey6e175692019-05-14 14:55:33 -06001075 res = error("Failed to delete contents of " + path);
1076 }
1077 }
1078 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07001079 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001080}
1081
Jeff Sharkeye12d5962017-04-03 16:41:02 -06001082static gid_t get_cache_gid(uid_t uid) {
1083 int32_t gid = multiuser_get_cache_gid(multiuser_get_user_id(uid), multiuser_get_app_id(uid));
1084 return (gid != -1) ? gid : uid;
1085}
1086
Jooyung Han149be4a2020-01-23 12:45:10 +09001087binder::Status InstalldNativeService::fixupAppData(const std::optional<std::string>& uuid,
Jeff Sharkeye12d5962017-04-03 16:41:02 -06001088 int32_t flags) {
1089 ENFORCE_UID(AID_SYSTEM);
1090 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeye12d5962017-04-03 16:41:02 -06001091
1092 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001093 for (auto userId : get_known_users(uuid_)) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001094 LOCK_USER();
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -08001095 ATRACE_BEGIN("fixup user");
Jeff Sharkeye12d5962017-04-03 16:41:02 -06001096 FTS* fts;
1097 FTSENT* p;
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001098 auto ce_path = create_data_user_ce_path(uuid_, userId);
1099 auto de_path = create_data_user_de_path(uuid_, userId);
Jeff Sharkeyd9ff77f2017-04-14 18:54:49 -06001100 char *argv[] = { (char*) ce_path.c_str(), (char*) de_path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -07001101 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkeye12d5962017-04-03 16:41:02 -06001102 return error("Failed to fts_open");
1103 }
1104 while ((p = fts_read(fts)) != nullptr) {
1105 if (p->fts_info == FTS_D && p->fts_level == 1) {
1106 // Track down inodes of cache directories
1107 uint64_t raw = 0;
1108 ino_t inode_cache = 0;
1109 ino_t inode_code_cache = 0;
1110 if (getxattr(p->fts_path, kXattrInodeCache, &raw, sizeof(raw)) == sizeof(raw)) {
1111 inode_cache = raw;
1112 }
1113 if (getxattr(p->fts_path, kXattrInodeCodeCache, &raw, sizeof(raw)) == sizeof(raw)) {
1114 inode_code_cache = raw;
1115 }
1116
1117 // Figure out expected GID of each child
1118 FTSENT* child = fts_children(fts, 0);
1119 while (child != nullptr) {
1120 if ((child->fts_statp->st_ino == inode_cache)
1121 || (child->fts_statp->st_ino == inode_code_cache)
1122 || !strcmp(child->fts_name, "cache")
1123 || !strcmp(child->fts_name, "code_cache")) {
1124 child->fts_number = get_cache_gid(p->fts_statp->st_uid);
1125 } else {
1126 child->fts_number = p->fts_statp->st_uid;
1127 }
1128 child = child->fts_link;
1129 }
1130 } else if (p->fts_level >= 2) {
1131 if (p->fts_level > 2) {
1132 // Inherit GID from parent once we're deeper into tree
1133 p->fts_number = p->fts_parent->fts_number;
1134 }
1135
1136 uid_t uid = p->fts_parent->fts_statp->st_uid;
1137 gid_t cache_gid = get_cache_gid(uid);
1138 gid_t expected = p->fts_number;
1139 gid_t actual = p->fts_statp->st_gid;
1140 if (actual == expected) {
1141#if FIXUP_DEBUG
1142 LOG(DEBUG) << "Ignoring " << p->fts_path << " with expected GID " << expected;
1143#endif
1144 if (!(flags & FLAG_FORCE)) {
1145 fts_set(fts, p, FTS_SKIP);
1146 }
1147 } else if ((actual == uid) || (actual == cache_gid)) {
1148 // Only consider fixing up when current GID belongs to app
1149 if (p->fts_info != FTS_D) {
1150 LOG(INFO) << "Fixing " << p->fts_path << " with unexpected GID " << actual
1151 << " instead of " << expected;
1152 }
1153 switch (p->fts_info) {
1154 case FTS_DP:
1155 // If we're moving towards cache GID, we need to set S_ISGID
1156 if (expected == cache_gid) {
1157 if (chmod(p->fts_path, 02771) != 0) {
1158 PLOG(WARNING) << "Failed to chmod " << p->fts_path;
1159 }
1160 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -07001161 [[fallthrough]]; // also set GID
Jeff Sharkeye12d5962017-04-03 16:41:02 -06001162 case FTS_F:
1163 if (chown(p->fts_path, -1, expected) != 0) {
1164 PLOG(WARNING) << "Failed to chown " << p->fts_path;
1165 }
1166 break;
1167 case FTS_SL:
1168 case FTS_SLNONE:
1169 if (lchown(p->fts_path, -1, expected) != 0) {
1170 PLOG(WARNING) << "Failed to chown " << p->fts_path;
1171 }
1172 break;
1173 }
1174 } else {
1175 // Ignore all other GID transitions, since they're kinda shady
1176 LOG(WARNING) << "Ignoring " << p->fts_path << " with unexpected GID " << actual
1177 << " instead of " << expected;
Jeff Sharkey6b63b912017-09-21 15:41:37 -06001178 if (!(flags & FLAG_FORCE)) {
1179 fts_set(fts, p, FTS_SKIP);
1180 }
Jeff Sharkeye12d5962017-04-03 16:41:02 -06001181 }
1182 }
1183 }
1184 fts_close(fts);
1185 ATRACE_END();
1186 }
1187 return ok();
1188}
1189
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001190static int32_t copy_directory_recursive(const char* from, const char* to) {
Dario Freni918beeb2021-12-22 01:00:01 +00001191 char* argv[] =
1192 {(char*)kCpPath,
1193 (char*)"-F", /* delete any existing destination file first (--remove-destination) */
1194 (char*)"--preserve=mode,ownership,timestamps,xattr", /* preserve properties */
1195 (char*)"-R", /* recurse into subdirectories (DEST must be a directory) */
1196 (char*)"-P", /* Do not follow symlinks [default] */
1197 (char*)"-d", /* don't dereference symlinks */
1198 (char*)from,
1199 (char*)to};
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001200
1201 LOG(DEBUG) << "Copying " << from << " to " << to;
Tom Cherrye79cde52019-09-25 16:51:56 -07001202 return logwrap_fork_execvp(ARRAY_SIZE(argv), argv, nullptr, false, LOG_ALOG, false, nullptr);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001203}
1204
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001205binder::Status InstalldNativeService::snapshotAppData(const std::optional<std::string>& volumeUuid,
1206 const std::string& packageName,
1207 int32_t userId, int32_t snapshotId,
1208 int32_t storageFlags, int64_t* _aidl_return) {
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001209 ENFORCE_UID(AID_SYSTEM);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001210 CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(volumeUuid);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001211 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001212 LOCK_PACKAGE_USER();
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001213
1214 const char* volume_uuid = volumeUuid ? volumeUuid->c_str() : nullptr;
1215 const char* package_name = packageName.c_str();
1216
1217 binder::Status res = ok();
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001218 // Default result to 0, it will be populated with inode of ce data snapshot
1219 // if FLAG_STORAGE_CE has been passed.
1220 if (_aidl_return != nullptr) *_aidl_return = 0;
1221
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001222 bool clear_ce_on_exit = false;
1223 bool clear_de_on_exit = false;
1224
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001225 auto deleter = [&clear_ce_on_exit, &clear_de_on_exit, &volume_uuid, &userId, &package_name,
1226 &snapshotId] {
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001227 if (clear_de_on_exit) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001228 auto to = create_data_misc_de_rollback_package_path(volume_uuid, userId, snapshotId,
1229 package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001230 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
1231 LOG(WARNING) << "Failed to delete app data snapshot: " << to;
1232 }
1233 }
1234
1235 if (clear_ce_on_exit) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001236 auto to = create_data_misc_ce_rollback_package_path(volume_uuid, userId, snapshotId,
1237 package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001238 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
1239 LOG(WARNING) << "Failed to delete app data snapshot: " << to;
1240 }
1241 }
1242 };
1243
1244 auto scope_guard = android::base::make_scope_guard(deleter);
1245
JW Wang1d643c72020-10-06 13:42:41 +08001246 if (storageFlags & FLAG_STORAGE_DE) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001247 auto from = create_data_user_de_package_path(volume_uuid, userId, package_name);
1248 auto to = create_data_misc_de_rollback_path(volume_uuid, userId, snapshotId);
1249 auto rollback_package_path =
1250 create_data_misc_de_rollback_package_path(volume_uuid, userId, snapshotId,
1251 package_name);
JW Wang1d643c72020-10-06 13:42:41 +08001252
1253 int rc = create_dir_if_needed(to.c_str(), kRollbackFolderMode);
1254 if (rc != 0) {
1255 return error(rc, "Failed to create folder " + to);
1256 }
1257
1258 rc = delete_dir_contents(rollback_package_path, true /* ignore_if_missing */);
1259 if (rc != 0) {
1260 return error(rc, "Failed clearing existing snapshot " + rollback_package_path);
1261 }
1262
1263 // Check if we have data to copy.
1264 if (access(from.c_str(), F_OK) == 0) {
1265 rc = copy_directory_recursive(from.c_str(), to.c_str());
1266 }
1267 if (rc != 0) {
1268 res = error(rc, "Failed copying " + from + " to " + to);
1269 clear_de_on_exit = true;
1270 return res;
1271 }
1272 }
1273
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001274 // The app may not have any data at all, in which case it's OK to skip here.
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001275 auto from_ce = create_data_user_ce_package_path(volume_uuid, userId, package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001276 if (access(from_ce.c_str(), F_OK) != 0) {
1277 LOG(INFO) << "Missing source " << from_ce;
1278 return ok();
1279 }
1280
Nikita Ioffe900b3c22019-01-23 14:32:48 +00001281 // ce_data_inode is not needed when FLAG_CLEAR_CACHE_ONLY is set.
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001282 binder::Status clear_cache_result =
1283 clearAppData(volumeUuid, packageName, userId, storageFlags | FLAG_CLEAR_CACHE_ONLY, 0);
Nikita Ioffe900b3c22019-01-23 14:32:48 +00001284 if (!clear_cache_result.isOk()) {
1285 // It should be fine to continue snapshot if we for some reason failed
1286 // to clear cache.
1287 LOG(WARNING) << "Failed to clear cache of app " << packageName;
1288 }
1289
1290 // ce_data_inode is not needed when FLAG_CLEAR_CODE_CACHE_ONLY is set.
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001291 binder::Status clear_code_cache_result =
1292 clearAppData(volumeUuid, packageName, userId, storageFlags | FLAG_CLEAR_CODE_CACHE_ONLY,
1293 0);
Nikita Ioffe900b3c22019-01-23 14:32:48 +00001294 if (!clear_code_cache_result.isOk()) {
1295 // It should be fine to continue snapshot if we for some reason failed
1296 // to clear code_cache.
1297 LOG(WARNING) << "Failed to clear code_cache of app " << packageName;
1298 }
1299
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001300 if (storageFlags & FLAG_STORAGE_CE) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001301 auto from = create_data_user_ce_package_path(volume_uuid, userId, package_name);
1302 auto to = create_data_misc_ce_rollback_path(volume_uuid, userId, snapshotId);
1303 auto rollback_package_path =
1304 create_data_misc_ce_rollback_package_path(volume_uuid, userId, snapshotId,
1305 package_name);
Nikita Ioffe835ae772019-01-23 16:32:13 +00001306
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001307 int rc = create_dir_if_needed(to.c_str(), kRollbackFolderMode);
1308 if (rc != 0) {
1309 return error(rc, "Failed to create folder " + to);
Nikita Ioffe835ae772019-01-23 16:32:13 +00001310 }
1311
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001312 rc = delete_dir_contents(rollback_package_path, true /* ignore_if_missing */);
1313 if (rc != 0) {
1314 return error(rc, "Failed clearing existing snapshot " + rollback_package_path);
1315 }
1316
1317 rc = copy_directory_recursive(from.c_str(), to.c_str());
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001318 if (rc != 0) {
1319 res = error(rc, "Failed copying " + from + " to " + to);
1320 clear_ce_on_exit = true;
1321 return res;
1322 }
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001323 if (_aidl_return != nullptr) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001324 auto ce_snapshot_path =
1325 create_data_misc_ce_rollback_package_path(volume_uuid, userId, snapshotId,
1326 package_name);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001327 rc = get_path_inode(ce_snapshot_path, reinterpret_cast<ino_t*>(_aidl_return));
1328 if (rc != 0) {
1329 res = error(rc, "Failed to get_path_inode for " + ce_snapshot_path);
1330 clear_ce_on_exit = true;
1331 return res;
1332 }
1333 }
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001334 }
1335
1336 return res;
1337}
1338
1339binder::Status InstalldNativeService::restoreAppDataSnapshot(
Jooyung Han149be4a2020-01-23 12:45:10 +09001340 const std::optional<std::string>& volumeUuid, const std::string& packageName,
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001341 const int32_t appId, const std::string& seInfo, const int32_t userId,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001342 const int32_t snapshotId, int32_t storageFlags) {
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001343 ENFORCE_UID(AID_SYSTEM);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001344 CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(volumeUuid);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001345 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001346 LOCK_PACKAGE_USER();
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001347
1348 const char* volume_uuid = volumeUuid ? volumeUuid->c_str() : nullptr;
1349 const char* package_name = packageName.c_str();
1350
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001351 auto from_ce = create_data_misc_ce_rollback_package_path(volume_uuid, userId, snapshotId,
1352 package_name);
1353 auto from_de = create_data_misc_de_rollback_package_path(volume_uuid, userId, snapshotId,
1354 package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001355
1356 const bool needs_ce_rollback = (storageFlags & FLAG_STORAGE_CE) &&
1357 (access(from_ce.c_str(), F_OK) == 0);
1358 const bool needs_de_rollback = (storageFlags & FLAG_STORAGE_DE) &&
1359 (access(from_de.c_str(), F_OK) == 0);
1360
1361 if (!needs_ce_rollback && !needs_de_rollback) {
1362 return ok();
1363 }
1364
1365 // We know we're going to rollback one of the CE or DE data, so we clear
1366 // application data first. Note that it's possible that we're asked to
1367 // restore both CE & DE data but that one of the restores fail. Leaving the
1368 // app with no data in those cases is arguably better than leaving the app
1369 // with mismatched / stale data.
1370 LOG(INFO) << "Clearing app data for " << packageName << " to restore snapshot.";
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001371 // It's fine to pass 0 as ceDataInode here, because restoreAppDataSnapshot
1372 // can only be called when user unlocks the phone, meaning that CE user data
1373 // is decrypted.
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001374 binder::Status res =
1375 clearAppData(volumeUuid, packageName, userId, storageFlags, 0 /* ceDataInode */);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001376 if (!res.isOk()) {
1377 return res;
1378 }
1379
1380 if (needs_ce_rollback) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001381 auto to_ce = create_data_user_ce_path(volume_uuid, userId);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001382 int rc = copy_directory_recursive(from_ce.c_str(), to_ce.c_str());
1383 if (rc != 0) {
1384 res = error(rc, "Failed copying " + from_ce + " to " + to_ce);
1385 return res;
1386 }
JW Wangfda19ec2020-05-18 16:54:08 +08001387 delete_dir_contents_and_dir(from_ce, true /* ignore_if_missing */);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001388 }
1389
1390 if (needs_de_rollback) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001391 auto to_de = create_data_user_de_path(volume_uuid, userId);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001392 int rc = copy_directory_recursive(from_de.c_str(), to_de.c_str());
1393 if (rc != 0) {
Nikita Ioffefd2ccd42019-01-25 11:44:36 +00001394 if (needs_ce_rollback) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001395 auto ce_data = create_data_user_ce_package_path(volume_uuid, userId, package_name);
Nikita Ioffefd2ccd42019-01-25 11:44:36 +00001396 LOG(WARNING) << "de_data rollback failed. Erasing rolled back ce_data " << ce_data;
1397 if (delete_dir_contents(ce_data.c_str(), 1, nullptr) != 0) {
1398 LOG(WARNING) << "Failed to delete rolled back ce_data " << ce_data;
1399 }
1400 }
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001401 res = error(rc, "Failed copying " + from_de + " to " + to_de);
1402 return res;
1403 }
JW Wangfda19ec2020-05-18 16:54:08 +08001404 delete_dir_contents_and_dir(from_de, true /* ignore_if_missing */);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001405 }
1406
1407 // Finally, restore the SELinux label on the app data.
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001408 return restoreconAppData(volumeUuid, packageName, userId, storageFlags, appId, seInfo);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001409}
1410
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001411binder::Status InstalldNativeService::destroyAppDataSnapshot(
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001412 const std::optional<std::string>& volumeUuid, const std::string& packageName,
1413 const int32_t userId, const int64_t ceSnapshotInode, const int32_t snapshotId,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001414 int32_t storageFlags) {
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001415 ENFORCE_UID(AID_SYSTEM);
1416 CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(volumeUuid);
1417 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001418 LOCK_PACKAGE_USER();
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001419
1420 const char* volume_uuid = volumeUuid ? volumeUuid->c_str() : nullptr;
1421 const char* package_name = packageName.c_str();
1422
1423 if (storageFlags & FLAG_STORAGE_DE) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001424 auto de_snapshot_path = create_data_misc_de_rollback_package_path(volume_uuid, userId,
1425 snapshotId, package_name);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001426
1427 int res = delete_dir_contents_and_dir(de_snapshot_path, true /* ignore_if_missing */);
1428 if (res != 0) {
1429 return error(res, "Failed clearing snapshot " + de_snapshot_path);
1430 }
1431 }
1432
1433 if (storageFlags & FLAG_STORAGE_CE) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001434 auto ce_snapshot_path =
1435 create_data_misc_ce_rollback_package_path(volume_uuid, userId, snapshotId,
1436 package_name, ceSnapshotInode);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001437 int res = delete_dir_contents_and_dir(ce_snapshot_path, true /* ignore_if_missing */);
1438 if (res != 0) {
1439 return error(res, "Failed clearing snapshot " + ce_snapshot_path);
1440 }
1441 }
1442 return ok();
1443}
1444
Oli Lanc7789572020-03-16 18:18:41 +00001445binder::Status InstalldNativeService::destroyCeSnapshotsNotSpecified(
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001446 const std::optional<std::string>& volumeUuid, const int32_t userId,
Oli Lanc7789572020-03-16 18:18:41 +00001447 const std::vector<int32_t>& retainSnapshotIds) {
1448 ENFORCE_UID(AID_SYSTEM);
1449 CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(volumeUuid);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001450 LOCK_USER();
Oli Lanc7789572020-03-16 18:18:41 +00001451
1452 const char* volume_uuid = volumeUuid ? volumeUuid->c_str() : nullptr;
1453
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001454 auto base_path = create_data_misc_ce_rollback_base_path(volume_uuid, userId);
Oli Lanc7789572020-03-16 18:18:41 +00001455
1456 std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(base_path.c_str()), closedir);
1457 if (!dir) {
1458 return error(-1, "Failed to open rollback base dir " + base_path);
1459 }
1460
1461 struct dirent* ent;
1462 while ((ent = readdir(dir.get()))) {
1463 if (ent->d_type != DT_DIR) {
1464 continue;
1465 }
1466
1467 uint snapshot_id;
1468 bool parse_ok = ParseUint(ent->d_name, &snapshot_id);
1469 if (parse_ok &&
1470 std::find(retainSnapshotIds.begin(), retainSnapshotIds.end(),
1471 snapshot_id) == retainSnapshotIds.end()) {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001472 auto rollback_path =
1473 create_data_misc_ce_rollback_path(volume_uuid, userId, snapshot_id);
Oli Lanc7789572020-03-16 18:18:41 +00001474 int res = delete_dir_contents_and_dir(rollback_path, true /* ignore_if_missing */);
1475 if (res != 0) {
1476 return error(res, "Failed clearing snapshot " + rollback_path);
1477 }
1478 }
1479 }
1480 return ok();
1481}
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001482
Jooyung Han149be4a2020-01-23 12:45:10 +09001483binder::Status InstalldNativeService::moveCompleteApp(const std::optional<std::string>& fromUuid,
1484 const std::optional<std::string>& toUuid, const std::string& packageName,
Songchun Fandc2083f2020-02-18 17:45:46 -08001485 int32_t appId, const std::string& seInfo,
Songchun Fanaed33372020-02-05 12:02:22 -08001486 int32_t targetSdkVersion, const std::string& fromCodePath) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001487 ENFORCE_UID(AID_SYSTEM);
1488 CHECK_ARGUMENT_UUID(fromUuid);
1489 CHECK_ARGUMENT_UUID(toUuid);
1490 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001491 LOCK_PACKAGE();
Jeff Sharkey0274c972016-12-06 09:32:04 -07001492
1493 const char* from_uuid = fromUuid ? fromUuid->c_str() : nullptr;
1494 const char* to_uuid = toUuid ? toUuid->c_str() : nullptr;
1495 const char* package_name = packageName.c_str();
Jeff Sharkey0274c972016-12-06 09:32:04 -07001496
Jeff Sharkey423e7462016-12-09 18:18:43 -07001497 binder::Status res = ok();
Jeff Sharkeye3637242015-04-08 20:56:42 -07001498 std::vector<userid_t> users = get_known_users(from_uuid);
1499
Songchun Fandc2083f2020-02-18 17:45:46 -08001500 auto to_app_package_path_parent = create_data_app_path(to_uuid);
1501 auto to_app_package_path = StringPrintf("%s/%s", to_app_package_path_parent.c_str(),
1502 android::base::Basename(fromCodePath).c_str());
1503
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001504 // Copy app
1505 {
Songchun Fandc2083f2020-02-18 17:45:46 -08001506 int rc = copy_directory_recursive(fromCodePath.c_str(), to_app_package_path_parent.c_str());
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001507 if (rc != 0) {
Songchun Fandc2083f2020-02-18 17:45:46 -08001508 res = error(rc, "Failed copying " + fromCodePath + " to " + to_app_package_path);
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001509 goto fail;
1510 }
1511
Songchun Fandc2083f2020-02-18 17:45:46 -08001512 if (selinux_android_restorecon(to_app_package_path.c_str(), SELINUX_ANDROID_RESTORECON_RECURSE) != 0) {
1513 res = error("Failed to restorecon " + to_app_package_path);
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001514 goto fail;
1515 }
1516 }
1517
1518 // Copy private data for all known users
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001519 for (auto userId : users) {
1520 LOCK_USER();
Jeff Sharkeye3637242015-04-08 20:56:42 -07001521
1522 // Data source may not exist for all users; that's okay
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001523 auto from_ce = create_data_user_ce_package_path(from_uuid, userId, package_name);
Jeff Sharkey51c94492016-05-10 17:46:39 -06001524 if (access(from_ce.c_str(), F_OK) != 0) {
1525 LOG(INFO) << "Missing source " << from_ce;
Jeff Sharkeye3637242015-04-08 20:56:42 -07001526 continue;
1527 }
1528
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -08001529 if (!createAppDataLocked(toUuid, packageName, userId, FLAG_STORAGE_CE | FLAG_STORAGE_DE,
1530 appId, /* previousAppId */ -1, seInfo, targetSdkVersion, nullptr)
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001531 .isOk()) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001532 res = error("Failed to create package target");
Jeff Sharkeye3637242015-04-08 20:56:42 -07001533 goto fail;
1534 }
Jeff Sharkey51c94492016-05-10 17:46:39 -06001535 {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001536 auto from = create_data_user_de_package_path(from_uuid, userId, package_name);
1537 auto to = create_data_user_de_path(to_uuid, userId);
Jeff Sharkeye3637242015-04-08 20:56:42 -07001538
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001539 int rc = copy_directory_recursive(from.c_str(), to.c_str());
Jeff Sharkey51c94492016-05-10 17:46:39 -06001540 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001541 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkey51c94492016-05-10 17:46:39 -06001542 goto fail;
1543 }
1544 }
1545 {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001546 auto from = create_data_user_ce_package_path(from_uuid, userId, package_name);
1547 auto to = create_data_user_ce_path(to_uuid, userId);
Jeff Sharkey51c94492016-05-10 17:46:39 -06001548
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001549 int rc = copy_directory_recursive(from.c_str(), to.c_str());
Jeff Sharkey51c94492016-05-10 17:46:39 -06001550 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001551 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkey51c94492016-05-10 17:46:39 -06001552 goto fail;
1553 }
Jeff Sharkeye3637242015-04-08 20:56:42 -07001554 }
1555
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -08001556 if (!restoreconAppDataLocked(toUuid, packageName, userId, FLAG_STORAGE_CE | FLAG_STORAGE_DE,
1557 appId, seInfo)
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001558 .isOk()) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001559 res = error("Failed to restorecon");
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07001560 goto fail;
1561 }
Jeff Sharkeye3637242015-04-08 20:56:42 -07001562 }
1563
Jeff Sharkey31f08982015-07-07 13:31:37 -07001564 // We let the framework scan the new location and persist that before
1565 // deleting the data in the old location; this ordering ensures that
1566 // we can recover from things like battery pulls.
Jeff Sharkey423e7462016-12-09 18:18:43 -07001567 return ok();
Jeff Sharkeye3637242015-04-08 20:56:42 -07001568
1569fail:
1570 // Nuke everything we might have already copied
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001571 {
Songchun Fandc2083f2020-02-18 17:45:46 -08001572 if (delete_dir_contents(to_app_package_path.c_str(), 1, nullptr) != 0) {
1573 LOG(WARNING) << "Failed to rollback " << to_app_package_path;
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001574 }
1575 }
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001576 for (auto userId : users) {
1577 LOCK_USER();
Jeff Sharkey51c94492016-05-10 17:46:39 -06001578 {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001579 auto to = create_data_user_de_package_path(to_uuid, userId, package_name);
Yi Konge7bf3772018-07-17 16:16:24 -07001580 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
Jeff Sharkey51c94492016-05-10 17:46:39 -06001581 LOG(WARNING) << "Failed to rollback " << to;
1582 }
1583 }
1584 {
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001585 auto to = create_data_user_ce_package_path(to_uuid, userId, package_name);
Yi Konge7bf3772018-07-17 16:16:24 -07001586 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
Jeff Sharkey51c94492016-05-10 17:46:39 -06001587 LOG(WARNING) << "Failed to rollback " << to;
1588 }
Jeff Sharkeye3637242015-04-08 20:56:42 -07001589 }
1590 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07001591 return res;
Jeff Sharkeye3637242015-04-08 20:56:42 -07001592}
1593
Jooyung Han149be4a2020-01-23 12:45:10 +09001594binder::Status InstalldNativeService::createUserData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001595 int32_t userId, int32_t userSerial ATTRIBUTE_UNUSED, int32_t flags) {
1596 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001597 CHECK_ARGUMENT_UUID(uuid);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001598 LOCK_USER();
Jeff Sharkey423e7462016-12-09 18:18:43 -07001599
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001600 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey379a12b2016-04-14 20:45:06 -06001601 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001602 if (uuid_ == nullptr) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001603 if (ensure_config_user_dirs(userId) != 0) {
Jeff Sharkey7be5ead2016-12-12 13:18:46 -07001604 return error(StringPrintf("Failed to ensure dirs for %d", userId));
Jeff Sharkey423e7462016-12-09 18:18:43 -07001605 }
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001606 }
1607 }
Jeff Sharkeye59c85c2017-04-02 21:53:14 -06001608
Jeff Sharkey7be5ead2016-12-12 13:18:46 -07001609 return ok();
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001610}
1611
Jooyung Han149be4a2020-01-23 12:45:10 +09001612binder::Status InstalldNativeService::destroyUserData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001613 int32_t userId, int32_t flags) {
1614 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001615 CHECK_ARGUMENT_UUID(uuid);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001616 LOCK_USER();
Jeff Sharkey423e7462016-12-09 18:18:43 -07001617
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001618 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey423e7462016-12-09 18:18:43 -07001619 binder::Status res = ok();
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001620 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001621 auto path = create_data_user_de_path(uuid_, userId);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001622 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001623 res = error("Failed to delete " + path);
1624 }
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001625 if (uuid_ == nullptr) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001626 path = create_data_misc_legacy_path(userId);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001627 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001628 res = error("Failed to delete " + path);
1629 }
Calin Juravle114f0812017-03-08 19:05:07 -08001630 path = create_primary_cur_profile_dir_path(userId);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001631 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001632 res = error("Failed to delete " + path);
1633 }
Jeff Sharkey41ea4242015-04-09 11:34:03 -07001634 }
Robin Lee095c7632014-04-25 15:05:19 +01001635 }
Jeff Sharkey379a12b2016-04-14 20:45:06 -06001636 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001637 auto path = create_data_user_ce_path(uuid_, userId);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001638 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001639 res = error("Failed to delete " + path);
1640 }
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001641 path = findDataMediaPath(uuid, userId);
Alex Buynytskyy5cb25262022-02-15 08:59:36 -08001642 if (delete_dir_contents_and_dir(path, true) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001643 res = error("Failed to delete " + path);
1644 }
Jeff Sharkey379a12b2016-04-14 20:45:06 -06001645 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07001646 return res;
Robin Lee095c7632014-04-25 15:05:19 +01001647}
1648
Jooyung Han149be4a2020-01-23 12:45:10 +09001649binder::Status InstalldNativeService::freeCache(const std::optional<std::string>& uuid,
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001650 int64_t targetFreeBytes, int64_t cacheReservedBytes, int32_t flags) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001651 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001652 CHECK_ARGUMENT_UUID(uuid);
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -08001653#ifndef GRANULAR_LOCKS
1654 std::lock_guard lock(mLock);
1655#endif // !GRANULAR_LOCKS
Jeff Sharkey423e7462016-12-09 18:18:43 -07001656
Jooyung Han149be4a2020-01-23 12:45:10 +09001657 auto uuidString = uuid.value_or("");
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001658 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001659 auto data_path = create_data_path(uuid_);
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001660 auto noop = (flags & FLAG_FREE_CACHE_NOOP);
Jeff Sharkey41ea4242015-04-09 11:34:03 -07001661
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001662 int64_t free = data_disk_free(data_path);
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001663 if (free < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001664 return error("Failed to determine free space for " + data_path);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001665 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001666
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001667 int64_t cleared = 0;
1668 int64_t needed = targetFreeBytes - free;
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001669 LOG(DEBUG) << "Device " << data_path << " has " << free << " free; requested "
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001670 << targetFreeBytes << "; needed " << needed;
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001671
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001672 if (free >= targetFreeBytes) {
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001673 return ok();
1674 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001675
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001676 if (flags & FLAG_FREE_CACHE_V2) {
1677 // This new cache strategy fairly removes files from UIDs by deleting
1678 // files from the UIDs which are most over their allocated quota
1679
1680 // 1. Create trackers for every known UID
1681 ATRACE_BEGIN("create");
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -08001682 const auto users = get_known_users(uuid_);
1683#ifdef GRANULAR_LOCKS
1684 std::vector<UserLock> userLocks;
1685 userLocks.reserve(users.size());
1686 std::vector<UserWriteLockGuard> lockGuards;
1687 lockGuards.reserve(users.size());
1688#endif // GRANULAR_LOCKS
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001689 std::unordered_map<uid_t, std::shared_ptr<CacheTracker>> trackers;
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -08001690 for (auto userId : users) {
1691#ifdef GRANULAR_LOCKS
1692 userLocks.emplace_back(userId, mUserIdLock, mLock);
1693 lockGuards.emplace_back(userLocks.back());
1694#endif // GRANULAR_LOCKS
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001695 FTS *fts;
1696 FTSENT *p;
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08001697 auto ce_path = create_data_user_ce_path(uuid_, userId);
1698 auto de_path = create_data_user_de_path(uuid_, userId);
1699 auto media_path = findDataMediaPath(uuid, userId) + "/Android/data/";
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001700 char *argv[] = { (char*) ce_path.c_str(), (char*) de_path.c_str(),
1701 (char*) media_path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -07001702 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001703 return error("Failed to fts_open");
1704 }
Yi Konge7bf3772018-07-17 16:16:24 -07001705 while ((p = fts_read(fts)) != nullptr) {
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001706 if (p->fts_info == FTS_D && p->fts_level == 1) {
1707 uid_t uid = p->fts_statp->st_uid;
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001708 if (multiuser_get_app_id(uid) == AID_MEDIA_RW) {
1709 uid = (multiuser_get_app_id(p->fts_statp->st_gid) - AID_EXT_GID_START)
1710 + AID_APP_START;
1711 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001712 auto search = trackers.find(uid);
1713 if (search != trackers.end()) {
1714 search->second->addDataPath(p->fts_path);
1715 } else {
1716 auto tracker = std::shared_ptr<CacheTracker>(new CacheTracker(
Risan5f308262018-10-26 12:06:58 -06001717 multiuser_get_user_id(uid), multiuser_get_app_id(uid), uuidString));
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001718 tracker->addDataPath(p->fts_path);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001719 {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001720 std::lock_guard<std::recursive_mutex> lock(mQuotasLock);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001721 tracker->cacheQuota = mCacheQuotas[uid];
1722 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001723 if (tracker->cacheQuota == 0) {
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001724#if MEASURE_DEBUG
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001725 LOG(WARNING) << "UID " << uid << " has no cache quota; assuming 64MB";
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001726#endif
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001727 tracker->cacheQuota = 67108864;
1728 }
1729 trackers[uid] = tracker;
1730 }
1731 fts_set(fts, p, FTS_SKIP);
1732 }
1733 }
1734 fts_close(fts);
1735 }
1736 ATRACE_END();
1737
1738 // 2. Populate tracker stats and insert into priority queue
1739 ATRACE_BEGIN("populate");
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001740 int64_t cacheTotal = 0;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001741 auto cmp = [](std::shared_ptr<CacheTracker> left, std::shared_ptr<CacheTracker> right) {
1742 return (left->getCacheRatio() < right->getCacheRatio());
1743 };
1744 std::priority_queue<std::shared_ptr<CacheTracker>,
1745 std::vector<std::shared_ptr<CacheTracker>>, decltype(cmp)> queue(cmp);
1746 for (const auto& it : trackers) {
1747 it.second->loadStats();
1748 queue.push(it.second);
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001749 cacheTotal += it.second->cacheUsed;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001750 }
1751 ATRACE_END();
1752
1753 // 3. Bounce across the queue, freeing items from whichever tracker is
1754 // the most over their assigned quota
1755 ATRACE_BEGIN("bounce");
1756 std::shared_ptr<CacheTracker> active;
1757 while (active || !queue.empty()) {
Jeff Sharkey871a8f22017-02-21 18:30:28 -07001758 // Only look at apps under quota when explicitly requested
1759 if (active && (active->getCacheRatio() < 10000)
1760 && !(flags & FLAG_FREE_CACHE_V2_DEFY_QUOTA)) {
1761 LOG(DEBUG) << "Active ratio " << active->getCacheRatio()
1762 << " isn't over quota, and defy not requested";
1763 break;
1764 }
1765
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001766 // Only keep clearing when we haven't pushed into reserved area
1767 if (cacheReservedBytes > 0 && cleared >= (cacheTotal - cacheReservedBytes)) {
1768 LOG(DEBUG) << "Refusing to clear cached data in reserved space";
1769 break;
1770 }
1771
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001772 // Find the best tracker to work with; this might involve swapping
1773 // if the active tracker is no longer the most over quota
1774 bool nextBetter = active && !queue.empty()
1775 && active->getCacheRatio() < queue.top()->getCacheRatio();
1776 if (!active || nextBetter) {
1777 if (active) {
1778 // Current tracker still has items, so we'll consider it
1779 // again later once it bubbles up to surface
1780 queue.push(active);
1781 }
1782 active = queue.top(); queue.pop();
1783 active->ensureItems();
1784 continue;
1785 }
1786
1787 // If no items remain, go find another tracker
1788 if (active->items.empty()) {
1789 active = nullptr;
1790 continue;
1791 } else {
1792 auto item = active->items.back();
1793 active->items.pop_back();
1794
1795 LOG(DEBUG) << "Purging " << item->toString() << " from " << active->toString();
1796 if (!noop) {
1797 item->purge();
1798 }
1799 active->cacheUsed -= item->size;
1800 needed -= item->size;
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001801 cleared += item->size;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001802 }
1803
1804 // Verify that we're actually done before bailing, since sneaky
1805 // apps might be using hardlinks
1806 if (needed <= 0) {
1807 free = data_disk_free(data_path);
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001808 needed = targetFreeBytes - free;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001809 if (needed <= 0) {
1810 break;
1811 } else {
1812 LOG(WARNING) << "Expected to be done but still need " << needed;
1813 }
1814 }
1815 }
1816 ATRACE_END();
1817
1818 } else {
Jeff Sharkey1cb4aaf2017-03-27 16:41:06 -06001819 return error("Legacy cache logic no longer supported");
Mike Lockwood94afecf2012-10-24 10:45:23 -07001820 }
1821
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001822 free = data_disk_free(data_path);
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001823 if (free >= targetFreeBytes) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001824 return ok();
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001825 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001826 return error(StringPrintf("Failed to free up %" PRId64 " on %s; final free space %" PRId64,
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001827 targetFreeBytes, data_path.c_str(), free));
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001828 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001829}
1830
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001831binder::Status InstalldNativeService::rmdex(const std::string& codePath,
1832 const std::string& instructionSet) {
1833 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07001834 CHECK_ARGUMENT_PATH(codePath);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001835
Mike Lockwood94afecf2012-10-24 10:45:23 -07001836 char dex_path[PKG_PATH_MAX];
1837
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001838 const char* path = codePath.c_str();
1839 const char* instruction_set = instructionSet.c_str();
1840
Jeff Sharkey770180a2014-09-08 17:14:26 -07001841 if (validate_apk_path(path) && validate_system_app_path(path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001842 return error("Invalid path " + codePath);
Jeff Sharkey770180a2014-09-08 17:14:26 -07001843 }
1844
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001845 if (!create_cache_path(dex_path, path, instruction_set)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001846 return error("Failed to create cache path for " + codePath);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001847 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001848
1849 ALOGV("unlink %s\n", dex_path);
1850 if (unlink(dex_path) < 0) {
Calin Juravle249f2d32017-05-03 17:22:27 -07001851 // It's ok if we don't have a dalvik cache path. Report error only when the path exists
1852 // but could not be unlinked.
1853 if (errno != ENOENT) {
1854 return error(StringPrintf("Failed to unlink %s", dex_path));
1855 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001856 }
Calin Juravle249f2d32017-05-03 17:22:27 -07001857 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001858}
1859
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001860struct stats {
1861 int64_t codeSize;
1862 int64_t dataSize;
1863 int64_t cacheSize;
1864};
1865
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001866#if MEASURE_DEBUG
1867static std::string toString(std::vector<int64_t> values) {
1868 std::stringstream res;
1869 res << "[";
1870 for (size_t i = 0; i < values.size(); i++) {
1871 res << values[i];
1872 if (i < values.size() - 1) {
1873 res << ",";
1874 }
1875 }
1876 res << "]";
1877 return res.str();
1878}
1879#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001880
Risan5f308262018-10-26 12:06:58 -06001881static void collectQuotaStats(const std::string& uuid, int32_t userId,
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001882 int32_t appId, struct stats* stats, struct stats* extStats) {
Risan5f308262018-10-26 12:06:58 -06001883 int64_t space;
Martijn Coenen771cc342020-02-19 23:26:56 +01001884 uid_t uid = multiuser_get_uid(userId, appId);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001885 if (stats != nullptr) {
Risan5f308262018-10-26 12:06:58 -06001886 if ((space = GetOccupiedSpaceForUid(uuid, uid)) != -1) {
1887 stats->dataSize += space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001888 }
1889
1890 int cacheGid = multiuser_get_cache_gid(userId, appId);
1891 if (cacheGid != -1) {
Risan5f308262018-10-26 12:06:58 -06001892 if ((space = GetOccupiedSpaceForGid(uuid, cacheGid)) != -1) {
1893 stats->cacheSize += space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001894 }
1895 }
1896
1897 int sharedGid = multiuser_get_shared_gid(0, appId);
1898 if (sharedGid != -1) {
Risan5f308262018-10-26 12:06:58 -06001899 if ((space = GetOccupiedSpaceForGid(uuid, sharedGid)) != -1) {
1900 stats->codeSize += space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001901 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001902 }
1903 }
1904
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001905 if (extStats != nullptr) {
Martijn Coenen771cc342020-02-19 23:26:56 +01001906 static const bool supportsSdCardFs = supports_sdcardfs();
1907 space = get_occupied_app_space_external(uuid, userId, appId);
1908
1909 if (space != -1) {
1910 extStats->dataSize += space;
1911 if (!supportsSdCardFs && stats != nullptr) {
1912 // On devices without sdcardfs, if internal and external are on
1913 // the same volume, a uid such as u0_a123 is used for
1914 // application dirs on both internal and external storage;
1915 // therefore, substract that amount from internal to make sure
1916 // we don't count it double.
1917 stats->dataSize -= space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001918 }
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001919 }
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001920
Martijn Coenen771cc342020-02-19 23:26:56 +01001921 space = get_occupied_app_cache_space_external(uuid, userId, appId);
1922 if (space != -1) {
1923 extStats->dataSize += space; // cache counts for "data"
1924 extStats->cacheSize += space;
1925 if (!supportsSdCardFs && stats != nullptr) {
1926 // On devices without sdcardfs, if internal and external are on
1927 // the same volume, a uid such as u0_a123 is used for both
1928 // internal and external storage; therefore, substract that
1929 // amount from internal to make sure we don't count it double.
1930 stats->dataSize -= space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001931 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001932 }
Martijn Coenen771cc342020-02-19 23:26:56 +01001933
1934 if (!supportsSdCardFs && stats != nullptr) {
1935 // On devices without sdcardfs, the UID of OBBs on external storage
1936 // matches the regular app UID (eg u0_a123); therefore, to avoid
1937 // OBBs being include in stats->dataSize, compute the OBB size for
1938 // this app, and substract it from the size reported on internal
1939 // storage
1940 long obbProjectId = uid - AID_APP_START + PROJECT_ID_EXT_OBB_START;
1941 int64_t appObbSize = GetOccupiedSpaceForProjectId(uuid, obbProjectId);
1942 stats->dataSize -= appObbSize;
1943 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001944 }
1945}
1946
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001947static void collectManualStats(const std::string& path, struct stats* stats) {
Mike Lockwood94afecf2012-10-24 10:45:23 -07001948 DIR *d;
1949 int dfd;
1950 struct dirent *de;
1951 struct stat s;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001952
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001953 d = opendir(path.c_str());
1954 if (d == nullptr) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001955 if (errno != ENOENT) {
1956 PLOG(WARNING) << "Failed to open " << path;
1957 }
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001958 return;
1959 }
1960 dfd = dirfd(d);
1961 while ((de = readdir(d))) {
1962 const char *name = de->d_name;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001963
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001964 int64_t size = 0;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001965 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001966 size = s.st_blocks * 512;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001967 }
1968
1969 if (de->d_type == DT_DIR) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001970 if (!strcmp(name, ".")) {
1971 // Don't recurse, but still count node size
1972 } else if (!strcmp(name, "..")) {
1973 // Don't recurse or count node size
1974 continue;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001975 } else {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001976 // Measure all children nodes
1977 size = 0;
1978 calculate_tree_size(StringPrintf("%s/%s", path.c_str(), name), &size);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001979 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001980
1981 if (!strcmp(name, "cache") || !strcmp(name, "code_cache")) {
1982 stats->cacheSize += size;
1983 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001984 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001985
1986 // Legacy symlink isn't owned by app
1987 if (de->d_type == DT_LNK && !strcmp(name, "lib")) {
1988 continue;
1989 }
1990
1991 // Everything found inside is considered data
1992 stats->dataSize += size;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001993 }
1994 closedir(d);
1995}
1996
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001997static void collectManualStatsForUser(const std::string& path, struct stats* stats,
1998 bool exclude_apps = false) {
1999 DIR *d;
2000 int dfd;
2001 struct dirent *de;
2002 struct stat s;
2003
2004 d = opendir(path.c_str());
2005 if (d == nullptr) {
2006 if (errno != ENOENT) {
2007 PLOG(WARNING) << "Failed to open " << path;
2008 }
2009 return;
2010 }
2011 dfd = dirfd(d);
2012 while ((de = readdir(d))) {
2013 if (de->d_type == DT_DIR) {
2014 const char *name = de->d_name;
2015 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) != 0) {
2016 continue;
2017 }
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002018 int32_t user_uid = multiuser_get_app_id(s.st_uid);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002019 if (!strcmp(name, ".") || !strcmp(name, "..")) {
2020 continue;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002021 } else if (exclude_apps && (user_uid >= AID_APP_START && user_uid <= AID_APP_END)) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002022 continue;
2023 } else {
2024 collectManualStats(StringPrintf("%s/%s", path.c_str(), name), stats);
2025 }
2026 }
2027 }
2028 closedir(d);
2029}
2030
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002031static void collectManualExternalStatsForUser(const std::string& path, struct stats* stats) {
2032 FTS *fts;
2033 FTSENT *p;
2034 char *argv[] = { (char*) path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -07002035 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002036 PLOG(ERROR) << "Failed to fts_open " << path;
2037 return;
2038 }
Yi Konge7bf3772018-07-17 16:16:24 -07002039 while ((p = fts_read(fts)) != nullptr) {
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07002040 p->fts_number = p->fts_parent->fts_number;
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002041 switch (p->fts_info) {
2042 case FTS_D:
2043 if (p->fts_level == 4
2044 && !strcmp(p->fts_name, "cache")
2045 && !strcmp(p->fts_parent->fts_parent->fts_name, "data")
2046 && !strcmp(p->fts_parent->fts_parent->fts_parent->fts_name, "Android")) {
2047 p->fts_number = 1;
2048 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -07002049 [[fallthrough]]; // to count the directory
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002050 case FTS_DEFAULT:
2051 case FTS_F:
2052 case FTS_SL:
2053 case FTS_SLNONE:
2054 int64_t size = (p->fts_statp->st_blocks * 512);
2055 if (p->fts_number == 1) {
2056 stats->cacheSize += size;
2057 }
2058 stats->dataSize += size;
2059 break;
2060 }
2061 }
2062 fts_close(fts);
2063}
Shikha Malhotraaae96442021-11-25 10:52:50 +00002064static bool ownsExternalStorage(int32_t appId) {
2065 // Fetch external storage owner appid and check if it is the same as the
2066 // current appId whose size is calculated
2067 struct stat s;
2068 auto _picDir = StringPrintf("%s/Pictures", create_data_media_path(nullptr, 0).c_str());
2069 // check if the stat are present
2070 if (stat(_picDir.c_str(), &s) == 0) {
2071 // fetch the appId from the uid of the media app
2072 return ((int32_t)multiuser_get_app_id(s.st_uid) == appId);
2073 }
2074 return false;
2075}
Jooyung Han149be4a2020-01-23 12:45:10 +09002076binder::Status InstalldNativeService::getAppSize(const std::optional<std::string>& uuid,
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002077 const std::vector<std::string>& packageNames, int32_t userId, int32_t flags,
2078 int32_t appId, const std::vector<int64_t>& ceDataInodes,
2079 const std::vector<std::string>& codePaths, std::vector<int64_t>* _aidl_return) {
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002080 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002081 CHECK_ARGUMENT_UUID(uuid);
Alex Buynytskyya6823ef2022-02-28 14:18:19 -08002082 if (packageNames.size() != ceDataInodes.size()) {
2083 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
2084 "packageNames/ceDataInodes size mismatch.");
2085 }
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07002086 for (const auto& packageName : packageNames) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002087 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
2088 }
Jeff Sharkey53594302018-02-24 18:59:39 -07002089 for (const auto& codePath : codePaths) {
2090 CHECK_ARGUMENT_PATH(codePath);
2091 }
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07002092 // NOTE: Locking is relaxed on this method, since it's limited to
2093 // read-only measurements without mutation.
Jeff Sharkey423e7462016-12-09 18:18:43 -07002094
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002095 // When modifying this logic, always verify using tests:
2096 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetAppSize
2097
2098#if MEASURE_DEBUG
2099 LOG(INFO) << "Measuring user " << userId << " app " << appId;
2100#endif
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002101
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002102 // Here's a summary of the common storage locations across the platform,
2103 // and how they're each tagged:
2104 //
2105 // /data/app/com.example UID system
2106 // /data/app/com.example/oat UID system
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002107 // /data/user/0/com.example UID u0_a10 GID u0_a10
2108 // /data/user/0/com.example/cache UID u0_a10 GID u0_a10_cache
2109 // /data/media/0/foo.txt UID u0_media_rw
2110 // /data/media/0/bar.jpg UID u0_media_rw GID u0_media_image
2111 // /data/media/0/Android/data/com.example UID u0_media_rw GID u0_a10_ext
2112 // /data/media/0/Android/data/com.example/cache UID u0_media_rw GID u0_a10_ext_cache
2113 // /data/media/obb/com.example UID system
Jeff Sharkey2f720f72016-04-10 20:51:40 -06002114
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002115 struct stats stats;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002116 struct stats extStats;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002117 memset(&stats, 0, sizeof(stats));
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002118 memset(&extStats, 0, sizeof(extStats));
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002119
Jooyung Han149be4a2020-01-23 12:45:10 +09002120 auto uuidString = uuid.value_or("");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002121 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002122
Risan5f308262018-10-26 12:06:58 -06002123 if (!IsQuotaSupported(uuidString)) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002124 flags &= ~FLAG_USE_QUOTA;
2125 }
2126
Jeff Sharkey466459b2017-01-17 15:25:01 -07002127 ATRACE_BEGIN("obb");
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07002128 for (const auto& packageName : packageNames) {
Jeff Sharkey6d775c52019-03-22 13:46:20 -06002129 auto obbCodePath = create_data_media_package_path(uuid_, userId,
2130 "obb", packageName.c_str());
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002131 calculate_tree_size(obbCodePath, &extStats.codeSize);
2132 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07002133 ATRACE_END();
Shikha Malhotraaae96442021-11-25 10:52:50 +00002134 // Calculating the app size of the external storage owning app in a manual way, since
2135 // calculating it through quota apis also includes external media storage in the app storage
2136 // numbers
2137 if (flags & FLAG_USE_QUOTA && appId >= AID_APP_START && !ownsExternalStorage(appId)) {
Jeff Sharkey466459b2017-01-17 15:25:01 -07002138 ATRACE_BEGIN("code");
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07002139 for (const auto& codePath : codePaths) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002140 calculate_tree_size(codePath, &stats.codeSize, -1,
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002141 multiuser_get_shared_gid(0, appId));
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002142 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07002143 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002144
Jeff Sharkey466459b2017-01-17 15:25:01 -07002145 ATRACE_BEGIN("quota");
Risan5f308262018-10-26 12:06:58 -06002146 collectQuotaStats(uuidString, userId, appId, &stats, &extStats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07002147 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002148 } else {
Jeff Sharkey466459b2017-01-17 15:25:01 -07002149 ATRACE_BEGIN("code");
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07002150 for (const auto& codePath : codePaths) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002151 calculate_tree_size(codePath, &stats.codeSize);
2152 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07002153 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002154
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002155 for (size_t i = 0; i < packageNames.size(); i++) {
2156 const char* pkgname = packageNames[i].c_str();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002157
Jeff Sharkey466459b2017-01-17 15:25:01 -07002158 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002159 auto cePath = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInodes[i]);
2160 collectManualStats(cePath, &stats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002161 auto dePath = create_data_user_de_package_path(uuid_, userId, pkgname);
2162 collectManualStats(dePath, &stats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07002163 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002164
Jeff Sharkey06a61842017-04-15 12:03:31 -06002165 if (!uuid) {
2166 ATRACE_BEGIN("profiles");
2167 calculate_tree_size(
2168 create_primary_current_profile_package_dir_path(userId, pkgname),
2169 &stats.dataSize);
2170 calculate_tree_size(
2171 create_primary_reference_profile_package_dir_path(pkgname),
2172 &stats.codeSize);
2173 ATRACE_END();
2174 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002175
Jeff Sharkey466459b2017-01-17 15:25:01 -07002176 ATRACE_BEGIN("external");
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07002177 auto extPath = create_data_media_package_path(uuid_, userId, "data", pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002178 collectManualStats(extPath, &extStats);
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07002179 auto mediaPath = create_data_media_package_path(uuid_, userId, "media", pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002180 calculate_tree_size(mediaPath, &extStats.dataSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07002181 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002182 }
2183
Jeff Sharkey06a61842017-04-15 12:03:31 -06002184 if (!uuid) {
2185 ATRACE_BEGIN("dalvik");
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002186 int32_t sharedGid = multiuser_get_shared_gid(0, appId);
Jeff Sharkey06a61842017-04-15 12:03:31 -06002187 if (sharedGid != -1) {
2188 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
2189 sharedGid, -1);
2190 }
2191 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002192 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07002193 }
Jeff Sharkey2f720f72016-04-10 20:51:40 -06002194
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002195 std::vector<int64_t> ret;
2196 ret.push_back(stats.codeSize);
2197 ret.push_back(stats.dataSize);
2198 ret.push_back(stats.cacheSize);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002199 ret.push_back(extStats.codeSize);
2200 ret.push_back(extStats.dataSize);
2201 ret.push_back(extStats.cacheSize);
2202#if MEASURE_DEBUG
2203 LOG(DEBUG) << "Final result " << toString(ret);
2204#endif
2205 *_aidl_return = ret;
2206 return ok();
2207}
2208
Martijn Coenen771cc342020-02-19 23:26:56 +01002209struct external_sizes {
2210 int64_t audioSize;
2211 int64_t videoSize;
2212 int64_t imageSize;
2213 int64_t totalSize; // excludes OBBs (Android/obb), but includes app data + cache
2214 int64_t obbSize;
2215};
2216
2217#define PER_USER_RANGE 100000
2218
2219static long getProjectIdForUser(int userId, long projectId) {
2220 return userId * PER_USER_RANGE + projectId;
2221}
2222
2223static external_sizes getExternalSizesForUserWithQuota(const std::string& uuid, int32_t userId, const std::vector<int32_t>& appIds) {
2224 struct external_sizes sizes = {};
2225 int64_t space;
2226
2227 if (supports_sdcardfs()) {
2228 uid_t uid = multiuser_get_uid(userId, AID_MEDIA_RW);
2229 if ((space = GetOccupiedSpaceForUid(uuid, uid)) != -1) {
2230 sizes.totalSize = space;
2231 }
2232
2233 gid_t audioGid = multiuser_get_uid(userId, AID_MEDIA_AUDIO);
2234 if ((space = GetOccupiedSpaceForGid(uuid, audioGid)) != -1) {
2235 sizes.audioSize = space;
2236 }
2237
2238 gid_t videoGid = multiuser_get_uid(userId, AID_MEDIA_VIDEO);
2239 if ((space = GetOccupiedSpaceForGid(uuid, videoGid)) != -1) {
2240 sizes.videoSize = space;
2241 }
2242
2243 gid_t imageGid = multiuser_get_uid(userId, AID_MEDIA_IMAGE);
2244 if ((space = GetOccupiedSpaceForGid(uuid, imageGid)) != -1) {
2245 sizes.imageSize = space;
2246 }
2247
2248 if ((space = GetOccupiedSpaceForGid(uuid, AID_MEDIA_OBB)) != -1) {
2249 sizes.obbSize = space;
2250 }
2251 } else {
2252 int64_t totalSize = 0;
2253 long defaultProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_DEFAULT);
2254 if ((space = GetOccupiedSpaceForProjectId(uuid, defaultProjectId)) != -1) {
2255 // This is all files that are not audio/video/images, excluding
2256 // OBBs and app-private data
2257 totalSize += space;
2258 }
2259
2260 long audioProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_MEDIA_AUDIO);
2261 if ((space = GetOccupiedSpaceForProjectId(uuid, audioProjectId)) != -1) {
2262 sizes.audioSize = space;
2263 totalSize += space;
2264 }
2265
2266 long videoProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_MEDIA_VIDEO);
2267 if ((space = GetOccupiedSpaceForProjectId(uuid, videoProjectId)) != -1) {
2268 sizes.videoSize = space;
2269 totalSize += space;
2270 }
2271
2272 long imageProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_MEDIA_IMAGE);
2273 if ((space = GetOccupiedSpaceForProjectId(uuid, imageProjectId)) != -1) {
2274 sizes.imageSize = space;
2275 totalSize += space;
2276 }
2277
2278 int64_t totalAppDataSize = 0;
2279 int64_t totalAppCacheSize = 0;
2280 int64_t totalAppObbSize = 0;
2281 for (auto appId : appIds) {
2282 if (appId >= AID_APP_START) {
2283 // App data
2284 uid_t uid = multiuser_get_uid(userId, appId);
2285 long projectId = uid - AID_APP_START + PROJECT_ID_EXT_DATA_START;
2286 totalAppDataSize += GetOccupiedSpaceForProjectId(uuid, projectId);
2287
2288 // App cache
2289 long cacheProjectId = uid - AID_APP_START + PROJECT_ID_EXT_CACHE_START;
2290 totalAppCacheSize += GetOccupiedSpaceForProjectId(uuid, cacheProjectId);
2291
2292 // App OBBs
2293 long obbProjectId = uid - AID_APP_START + PROJECT_ID_EXT_OBB_START;
2294 totalAppObbSize += GetOccupiedSpaceForProjectId(uuid, obbProjectId);
2295 }
2296 }
2297 // Total size should include app data + cache
2298 totalSize += totalAppDataSize;
2299 totalSize += totalAppCacheSize;
2300 sizes.totalSize = totalSize;
2301
2302 // Only OBB is separate
2303 sizes.obbSize = totalAppObbSize;
2304 }
2305
2306 return sizes;
2307}
2308
Jooyung Han149be4a2020-01-23 12:45:10 +09002309binder::Status InstalldNativeService::getUserSize(const std::optional<std::string>& uuid,
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002310 int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,
2311 std::vector<int64_t>* _aidl_return) {
2312 ENFORCE_UID(AID_SYSTEM);
2313 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07002314 // NOTE: Locking is relaxed on this method, since it's limited to
2315 // read-only measurements without mutation.
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002316
2317 // When modifying this logic, always verify using tests:
2318 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetUserSize
2319
2320#if MEASURE_DEBUG
2321 LOG(INFO) << "Measuring user " << userId;
2322#endif
2323
2324 struct stats stats;
2325 struct stats extStats;
2326 memset(&stats, 0, sizeof(stats));
2327 memset(&extStats, 0, sizeof(extStats));
2328
Jooyung Han149be4a2020-01-23 12:45:10 +09002329 auto uuidString = uuid.value_or("");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002330 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2331
Risan5f308262018-10-26 12:06:58 -06002332 if (!IsQuotaSupported(uuidString)) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002333 flags &= ~FLAG_USE_QUOTA;
2334 }
2335
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002336 if (flags & FLAG_USE_QUOTA) {
Jeff Sharkey466459b2017-01-17 15:25:01 -07002337 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002338 calculate_tree_size(create_data_app_path(uuid_), &stats.codeSize, -1, -1, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07002339 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002340
Jeff Sharkey466459b2017-01-17 15:25:01 -07002341 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002342 auto cePath = create_data_user_ce_path(uuid_, userId);
2343 collectManualStatsForUser(cePath, &stats, true);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002344 auto dePath = create_data_user_de_path(uuid_, userId);
2345 collectManualStatsForUser(dePath, &stats, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07002346 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002347
Jeff Sharkey06a61842017-04-15 12:03:31 -06002348 if (!uuid) {
2349 ATRACE_BEGIN("profile");
2350 auto userProfilePath = create_primary_cur_profile_dir_path(userId);
2351 calculate_tree_size(userProfilePath, &stats.dataSize, -1, -1, true);
2352 auto refProfilePath = create_primary_ref_profile_dir_path();
2353 calculate_tree_size(refProfilePath, &stats.codeSize, -1, -1, true);
2354 ATRACE_END();
2355 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002356
Jeff Sharkey466459b2017-01-17 15:25:01 -07002357 ATRACE_BEGIN("external");
Martijn Coenen771cc342020-02-19 23:26:56 +01002358 auto sizes = getExternalSizesForUserWithQuota(uuidString, userId, appIds);
2359 extStats.dataSize += sizes.totalSize;
2360 extStats.codeSize += sizes.obbSize;
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002361 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002362
Jeff Sharkey06a61842017-04-15 12:03:31 -06002363 if (!uuid) {
2364 ATRACE_BEGIN("dalvik");
2365 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
2366 -1, -1, true);
2367 calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize,
2368 -1, -1, true);
2369 ATRACE_END();
2370 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07002371 ATRACE_BEGIN("quota");
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002372 int64_t dataSize = extStats.dataSize;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002373 for (auto appId : appIds) {
2374 if (appId >= AID_APP_START) {
Risan5f308262018-10-26 12:06:58 -06002375 collectQuotaStats(uuidString, userId, appId, &stats, &extStats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002376#if MEASURE_DEBUG
2377 // Sleep to make sure we don't lose logs
2378 usleep(1);
2379#endif
2380 }
2381 }
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002382 extStats.dataSize = dataSize;
Jeff Sharkey466459b2017-01-17 15:25:01 -07002383 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002384 } else {
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002385 ATRACE_BEGIN("obb");
2386 auto obbPath = create_data_path(uuid_) + "/media/obb";
2387 calculate_tree_size(obbPath, &extStats.codeSize);
2388 ATRACE_END();
2389
Jeff Sharkey466459b2017-01-17 15:25:01 -07002390 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002391 calculate_tree_size(create_data_app_path(uuid_), &stats.codeSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07002392 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002393
Jeff Sharkey466459b2017-01-17 15:25:01 -07002394 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002395 auto cePath = create_data_user_ce_path(uuid_, userId);
2396 collectManualStatsForUser(cePath, &stats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002397 auto dePath = create_data_user_de_path(uuid_, userId);
2398 collectManualStatsForUser(dePath, &stats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07002399 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002400
Jeff Sharkey06a61842017-04-15 12:03:31 -06002401 if (!uuid) {
2402 ATRACE_BEGIN("profile");
2403 auto userProfilePath = create_primary_cur_profile_dir_path(userId);
2404 calculate_tree_size(userProfilePath, &stats.dataSize);
2405 auto refProfilePath = create_primary_ref_profile_dir_path();
2406 calculate_tree_size(refProfilePath, &stats.codeSize);
2407 ATRACE_END();
2408 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002409
Jeff Sharkey466459b2017-01-17 15:25:01 -07002410 ATRACE_BEGIN("external");
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002411 auto dataMediaPath = create_data_media_path(uuid_, userId);
2412 collectManualExternalStatsForUser(dataMediaPath, &extStats);
2413#if MEASURE_DEBUG
2414 LOG(DEBUG) << "Measured external data " << extStats.dataSize << " cache "
2415 << extStats.cacheSize;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002416#endif
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07002417 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002418
Jeff Sharkey06a61842017-04-15 12:03:31 -06002419 if (!uuid) {
2420 ATRACE_BEGIN("dalvik");
2421 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize);
2422 calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize);
2423 ATRACE_END();
2424 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002425 }
2426
2427 std::vector<int64_t> ret;
2428 ret.push_back(stats.codeSize);
2429 ret.push_back(stats.dataSize);
2430 ret.push_back(stats.cacheSize);
2431 ret.push_back(extStats.codeSize);
2432 ret.push_back(extStats.dataSize);
2433 ret.push_back(extStats.cacheSize);
2434#if MEASURE_DEBUG
2435 LOG(DEBUG) << "Final result " << toString(ret);
2436#endif
2437 *_aidl_return = ret;
2438 return ok();
2439}
2440
Jooyung Han149be4a2020-01-23 12:45:10 +09002441binder::Status InstalldNativeService::getExternalSize(const std::optional<std::string>& uuid,
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002442 int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,
2443 std::vector<int64_t>* _aidl_return) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002444 ENFORCE_UID(AID_SYSTEM);
2445 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07002446 // NOTE: Locking is relaxed on this method, since it's limited to
2447 // read-only measurements without mutation.
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002448
2449 // When modifying this logic, always verify using tests:
2450 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetExternalSize
2451
2452#if MEASURE_DEBUG
2453 LOG(INFO) << "Measuring external " << userId;
2454#endif
2455
Jooyung Han149be4a2020-01-23 12:45:10 +09002456 auto uuidString = uuid.value_or("");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002457 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2458
2459 int64_t totalSize = 0;
2460 int64_t audioSize = 0;
2461 int64_t videoSize = 0;
2462 int64_t imageSize = 0;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002463 int64_t appSize = 0;
Jeff Sharkeya0136982017-07-06 11:29:37 -06002464 int64_t obbSize = 0;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002465
Risan5f308262018-10-26 12:06:58 -06002466 if (!IsQuotaSupported(uuidString)) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002467 flags &= ~FLAG_USE_QUOTA;
2468 }
2469
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002470 if (flags & FLAG_USE_QUOTA) {
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002471 ATRACE_BEGIN("quota");
Martijn Coenen771cc342020-02-19 23:26:56 +01002472 auto sizes = getExternalSizesForUserWithQuota(uuidString, userId, appIds);
2473 totalSize = sizes.totalSize;
2474 audioSize = sizes.audioSize;
2475 videoSize = sizes.videoSize;
2476 imageSize = sizes.imageSize;
2477 obbSize = sizes.obbSize;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002478 ATRACE_END();
2479
2480 ATRACE_BEGIN("apps");
2481 struct stats extStats;
2482 memset(&extStats, 0, sizeof(extStats));
2483 for (auto appId : appIds) {
2484 if (appId >= AID_APP_START) {
Risan5f308262018-10-26 12:06:58 -06002485 collectQuotaStats(uuidString, userId, appId, nullptr, &extStats);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002486 }
2487 }
Jeff Sharkey4ca8ff92017-06-07 15:59:03 -06002488 appSize = extStats.dataSize;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002489 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002490 } else {
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002491 ATRACE_BEGIN("manual");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002492 FTS *fts;
2493 FTSENT *p;
2494 auto path = create_data_media_path(uuid_, userId);
2495 char *argv[] = { (char*) path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -07002496 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002497 return error("Failed to fts_open " + path);
2498 }
Yi Konge7bf3772018-07-17 16:16:24 -07002499 while ((p = fts_read(fts)) != nullptr) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002500 char* ext;
2501 int64_t size = (p->fts_statp->st_blocks * 512);
2502 switch (p->fts_info) {
2503 case FTS_F:
2504 // Only categorize files not belonging to apps
Jeff Sharkey444ad1e2017-03-12 16:25:36 -06002505 if (p->fts_parent->fts_number == 0) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002506 ext = strrchr(p->fts_name, '.');
2507 if (ext != nullptr) {
2508 switch (MatchExtension(++ext)) {
2509 case AID_MEDIA_AUDIO: audioSize += size; break;
2510 case AID_MEDIA_VIDEO: videoSize += size; break;
2511 case AID_MEDIA_IMAGE: imageSize += size; break;
2512 }
2513 }
2514 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -07002515 [[fallthrough]]; // always count against total
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002516 case FTS_D:
Jeff Sharkey444ad1e2017-03-12 16:25:36 -06002517 // Ignore data belonging to specific apps
2518 p->fts_number = p->fts_parent->fts_number;
2519 if (p->fts_level == 1 && !strcmp(p->fts_name, "Android")) {
2520 p->fts_number = 1;
2521 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -07002522 [[fallthrough]]; // always count against total
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002523 case FTS_DEFAULT:
2524 case FTS_SL:
2525 case FTS_SLNONE:
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002526 if (p->fts_parent->fts_number == 1) {
2527 appSize += size;
2528 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002529 totalSize += size;
2530 break;
2531 }
2532 }
2533 fts_close(fts);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002534 ATRACE_END();
Jeff Sharkeya0136982017-07-06 11:29:37 -06002535
2536 ATRACE_BEGIN("obb");
Jeff Sharkey6d775c52019-03-22 13:46:20 -06002537 auto obbPath = StringPrintf("%s/Android/obb",
2538 create_data_media_path(uuid_, userId).c_str());
Jeff Sharkeya0136982017-07-06 11:29:37 -06002539 calculate_tree_size(obbPath, &obbSize);
2540 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002541 }
2542
2543 std::vector<int64_t> ret;
2544 ret.push_back(totalSize);
2545 ret.push_back(audioSize);
2546 ret.push_back(videoSize);
2547 ret.push_back(imageSize);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002548 ret.push_back(appSize);
Jeff Sharkeya0136982017-07-06 11:29:37 -06002549 ret.push_back(obbSize);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002550#if MEASURE_DEBUG
2551 LOG(DEBUG) << "Final result " << toString(ret);
2552#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002553 *_aidl_return = ret;
Jeff Sharkey423e7462016-12-09 18:18:43 -07002554 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002555}
2556
Felka Chang2a0a2462019-11-20 14:20:40 +08002557binder::Status InstalldNativeService::getAppCrates(
Jooyung Han149be4a2020-01-23 12:45:10 +09002558 const std::optional<std::string>& uuid,
Felka Chang2a0a2462019-11-20 14:20:40 +08002559 const std::vector<std::string>& packageNames, int32_t userId,
Jooyung Han149be4a2020-01-23 12:45:10 +09002560 std::optional<std::vector<std::optional<CrateMetadata>>>* _aidl_return) {
Felka Chang2a0a2462019-11-20 14:20:40 +08002561 ENFORCE_UID(AID_SYSTEM);
2562 CHECK_ARGUMENT_UUID(uuid);
2563 for (const auto& packageName : packageNames) {
2564 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
2565 }
Felka Chang4df87f62020-02-11 19:08:43 +08002566#ifdef ENABLE_STORAGE_CRATES
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002567 LOCK_PACKAGE_USER();
Felka Chang2a0a2462019-11-20 14:20:40 +08002568
Jooyung Han149be4a2020-01-23 12:45:10 +09002569 auto retVector = std::vector<std::optional<CrateMetadata>>();
Felka Chang2a0a2462019-11-20 14:20:40 +08002570 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2571
Jooyung Han149be4a2020-01-23 12:45:10 +09002572 std::function<void(CratedFolder, CrateMetadata&&)> onCreateCrate =
2573 [&](CratedFolder cratedFolder, CrateMetadata&& crateMetadata) -> void {
Felka Chang2a0a2462019-11-20 14:20:40 +08002574 if (cratedFolder == nullptr) {
2575 return;
2576 }
Jooyung Han149be4a2020-01-23 12:45:10 +09002577 retVector.push_back(std::move(crateMetadata));
Felka Chang2a0a2462019-11-20 14:20:40 +08002578 };
2579
2580 for (const auto& packageName : packageNames) {
2581#if CRATE_DEBUG
2582 LOG(DEBUG) << "packageName = " << packageName;
2583#endif
2584 auto crateManager = std::make_unique<CrateManager>(uuid_, userId, packageName);
2585 crateManager->traverseAllCrates(onCreateCrate);
2586 }
2587
2588#if CRATE_DEBUG
Jooyung Han149be4a2020-01-23 12:45:10 +09002589 LOG(WARNING) << "retVector.size() =" << retVector.size();
2590 for (auto& item : retVector) {
Jooyung Hand520e802020-03-03 02:56:34 +09002591 CrateManager::dump(*item);
Felka Chang2a0a2462019-11-20 14:20:40 +08002592 }
2593#endif
2594
2595 *_aidl_return = std::move(retVector);
Felka Chang4df87f62020-02-11 19:08:43 +08002596#else // ENABLE_STORAGE_CRATES
Jooyung Han149be4a2020-01-23 12:45:10 +09002597 _aidl_return->reset();
Felka Chang4df87f62020-02-11 19:08:43 +08002598
2599 /* prevent compile warning fail */
2600 if (userId < 0) {
2601 return error();
2602 }
2603#endif // ENABLE_STORAGE_CRATES
Felka Chang2a0a2462019-11-20 14:20:40 +08002604 return ok();
2605}
2606
2607binder::Status InstalldNativeService::getUserCrates(
Jooyung Han149be4a2020-01-23 12:45:10 +09002608 const std::optional<std::string>& uuid, int32_t userId,
2609 std::optional<std::vector<std::optional<CrateMetadata>>>* _aidl_return) {
Felka Chang2a0a2462019-11-20 14:20:40 +08002610 ENFORCE_UID(AID_SYSTEM);
2611 CHECK_ARGUMENT_UUID(uuid);
Felka Chang4df87f62020-02-11 19:08:43 +08002612#ifdef ENABLE_STORAGE_CRATES
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002613 LOCK_USER();
Felka Chang2a0a2462019-11-20 14:20:40 +08002614
2615 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jooyung Han149be4a2020-01-23 12:45:10 +09002616 auto retVector = std::vector<std::optional<CrateMetadata>>();
Felka Chang2a0a2462019-11-20 14:20:40 +08002617
Jooyung Han149be4a2020-01-23 12:45:10 +09002618 std::function<void(CratedFolder, CrateMetadata&&)> onCreateCrate =
2619 [&](CratedFolder cratedFolder, CrateMetadata&& crateMetadata) -> void {
Felka Chang2a0a2462019-11-20 14:20:40 +08002620 if (cratedFolder == nullptr) {
2621 return;
2622 }
Jooyung Hand520e802020-03-03 02:56:34 +09002623 retVector.push_back(std::move(crateMetadata));
Felka Chang2a0a2462019-11-20 14:20:40 +08002624 };
2625
2626 std::function<void(FTSENT*)> onHandingPackage = [&](FTSENT* packageDir) -> void {
2627 auto crateManager = std::make_unique<CrateManager>(uuid_, userId, packageDir->fts_name);
2628 crateManager->traverseAllCrates(onCreateCrate);
2629 };
2630 CrateManager::traverseAllPackagesForUser(uuid, userId, onHandingPackage);
2631
2632#if CRATE_DEBUG
Jooyung Han149be4a2020-01-23 12:45:10 +09002633 LOG(DEBUG) << "retVector.size() =" << retVector.size();
2634 for (auto& item : retVector) {
Jooyung Hand520e802020-03-03 02:56:34 +09002635 CrateManager::dump(*item);
Felka Chang2a0a2462019-11-20 14:20:40 +08002636 }
2637#endif
2638
2639 *_aidl_return = std::move(retVector);
Felka Chang4df87f62020-02-11 19:08:43 +08002640#else // ENABLE_STORAGE_CRATES
Jooyung Han149be4a2020-01-23 12:45:10 +09002641 _aidl_return->reset();
Felka Chang4df87f62020-02-11 19:08:43 +08002642
2643 /* prevent compile warning fail */
2644 if (userId < 0) {
2645 return error();
2646 }
2647#endif // ENABLE_STORAGE_CRATES
Felka Chang2a0a2462019-11-20 14:20:40 +08002648 return ok();
2649}
2650
Jooyung Han149be4a2020-01-23 12:45:10 +09002651binder::Status InstalldNativeService::setAppQuota(const std::optional<std::string>& uuid,
Jeff Sharkey88ddd942017-01-17 18:05:54 -07002652 int32_t userId, int32_t appId, int64_t cacheQuota) {
2653 ENFORCE_UID(AID_SYSTEM);
2654 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002655 std::lock_guard<std::recursive_mutex> lock(mQuotasLock);
Jeff Sharkey88ddd942017-01-17 18:05:54 -07002656
2657 int32_t uid = multiuser_get_uid(userId, appId);
2658 mCacheQuotas[uid] = cacheQuota;
2659
2660 return ok();
2661}
2662
David Sehr6727c2d2016-05-17 16:06:22 -07002663// Dumps the contents of a profile file, using pkgname's dex files for pretty
2664// printing the result.
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002665binder::Status InstalldNativeService::dumpProfiles(int32_t uid, const std::string& packageName,
Calin Juravle562de812018-01-20 23:34:18 -08002666 const std::string& profileName, const std::string& codePath, bool* _aidl_return) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002667 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002668 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07002669 CHECK_ARGUMENT_PATH(codePath);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002670 LOCK_PACKAGE();
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002671
Calin Juravle562de812018-01-20 23:34:18 -08002672 *_aidl_return = dump_profiles(uid, packageName, profileName, codePath);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002673 return ok();
David Sehr6727c2d2016-05-17 16:06:22 -07002674}
2675
Mathieu Chartierf966f2a2017-05-10 12:48:37 -07002676// Copy the contents of a system profile over the data profile.
2677binder::Status InstalldNativeService::copySystemProfile(const std::string& systemProfile,
Calin Juravle562de812018-01-20 23:34:18 -08002678 int32_t packageUid, const std::string& packageName, const std::string& profileName,
2679 bool* _aidl_return) {
Mathieu Chartierf966f2a2017-05-10 12:48:37 -07002680 ENFORCE_UID(AID_SYSTEM);
2681 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002682 LOCK_PACKAGE();
Calin Juravle562de812018-01-20 23:34:18 -08002683 *_aidl_return = copy_system_profile(systemProfile, packageUid, packageName, profileName);
Mathieu Chartierf966f2a2017-05-10 12:48:37 -07002684 return ok();
2685}
2686
Andreas Gampe4d0f8252016-03-20 11:30:28 -07002687// TODO: Consider returning error codes.
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002688binder::Status InstalldNativeService::mergeProfiles(int32_t uid, const std::string& packageName,
Calin Juravle3b758282021-06-08 08:04:52 -07002689 const std::string& profileName, int* _aidl_return) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002690 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002691 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002692 LOCK_PACKAGE();
Jeff Sharkey423e7462016-12-09 18:18:43 -07002693
Calin Juravle562de812018-01-20 23:34:18 -08002694 *_aidl_return = analyze_primary_profiles(uid, packageName, profileName);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002695 return ok();
Andreas Gampe4d0f8252016-03-20 11:30:28 -07002696}
2697
Calin Juravlec41dac22017-12-05 12:29:15 -08002698binder::Status InstalldNativeService::createProfileSnapshot(int32_t appId,
Calin Juravlee61189e2018-01-23 19:54:11 -08002699 const std::string& packageName, const std::string& profileName,
2700 const std::string& classpath, bool* _aidl_return) {
Calin Juravle29591732017-11-20 17:46:19 -08002701 ENFORCE_UID(AID_SYSTEM);
2702 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002703 LOCK_PACKAGE();
Calin Juravle29591732017-11-20 17:46:19 -08002704
Calin Juravlee61189e2018-01-23 19:54:11 -08002705 *_aidl_return = create_profile_snapshot(appId, packageName, profileName, classpath);
Calin Juravle29591732017-11-20 17:46:19 -08002706 return ok();
2707}
2708
2709binder::Status InstalldNativeService::destroyProfileSnapshot(const std::string& packageName,
Calin Juravlecfcd6aa2018-01-18 20:23:17 -08002710 const std::string& profileName) {
Calin Juravle29591732017-11-20 17:46:19 -08002711 ENFORCE_UID(AID_SYSTEM);
2712 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002713 LOCK_PACKAGE();
Calin Juravle29591732017-11-20 17:46:19 -08002714
Calin Juravlecfcd6aa2018-01-18 20:23:17 -08002715 std::string snapshot = create_snapshot_profile_path(packageName, profileName);
Calin Juravle29591732017-11-20 17:46:19 -08002716 if ((unlink(snapshot.c_str()) != 0) && (errno != ENOENT)) {
Calin Juravlecfcd6aa2018-01-18 20:23:17 -08002717 return error("Failed to destroy profile snapshot for " + packageName + ":" + profileName);
Calin Juravle29591732017-11-20 17:46:19 -08002718 }
2719 return ok();
2720}
2721
Jooyung Han149be4a2020-01-23 12:45:10 +09002722static const char* getCStr(const std::optional<std::string>& data,
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002723 const char* default_value = nullptr) {
Jooyung Han149be4a2020-01-23 12:45:10 +09002724 return data ? data->c_str() : default_value;
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002725}
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002726binder::Status InstalldNativeService::dexopt(const std::string& apkPath, int32_t uid,
Jooyung Han149be4a2020-01-23 12:45:10 +09002727 const std::optional<std::string>& packageName, const std::string& instructionSet,
2728 int32_t dexoptNeeded, const std::optional<std::string>& outputPath, int32_t dexFlags,
2729 const std::string& compilerFilter, const std::optional<std::string>& uuid,
2730 const std::optional<std::string>& classLoaderContext,
2731 const std::optional<std::string>& seInfo, bool downgrade, int32_t targetSdkVersion,
2732 const std::optional<std::string>& profileName,
2733 const std::optional<std::string>& dexMetadataPath,
Keun young Park65578d62021-06-28 17:52:05 -07002734 const std::optional<std::string>& compilationReason,
2735 bool* aidl_return) {
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002736 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002737 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey53594302018-02-24 18:59:39 -07002738 CHECK_ARGUMENT_PATH(apkPath);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002739 if (packageName && *packageName != "*") {
2740 CHECK_ARGUMENT_PACKAGE_NAME(*packageName);
2741 }
Jeff Sharkey53594302018-02-24 18:59:39 -07002742 CHECK_ARGUMENT_PATH(outputPath);
2743 CHECK_ARGUMENT_PATH(dexMetadataPath);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002744 const auto userId = multiuser_get_user_id(uid);
2745 LOCK_PACKAGE_USER();
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002746
Alex Buynytskyy17d8f822019-06-20 16:29:57 -07002747 const char* oat_dir = getCStr(outputPath);
2748 const char* instruction_set = instructionSet.c_str();
2749 if (oat_dir != nullptr && !createOatDir(oat_dir, instruction_set).isOk()) {
2750 // Can't create oat dir - let dexopt use cache dir.
2751 oat_dir = nullptr;
2752 }
2753
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002754 const char* apk_path = apkPath.c_str();
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002755 const char* pkgname = getCStr(packageName, "*");
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002756 const char* compiler_filter = compilerFilter.c_str();
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002757 const char* volume_uuid = getCStr(uuid);
2758 const char* class_loader_context = getCStr(classLoaderContext);
2759 const char* se_info = getCStr(seInfo);
2760 const char* profile_name = getCStr(profileName);
2761 const char* dm_path = getCStr(dexMetadataPath);
Calin Juravledcccd832018-02-13 18:31:32 -08002762 const char* compilation_reason = getCStr(compilationReason);
Andreas Gampe023b2242018-02-28 16:03:25 -08002763 std::string error_msg;
Keun young Park65578d62021-06-28 17:52:05 -07002764 bool completed = false; // not necessary but for compiler
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002765 int res = android::installd::dexopt(apk_path, uid, pkgname, instruction_set, dexoptNeeded,
Calin Juravle1d667612017-07-13 22:50:21 -07002766 oat_dir, dexFlags, compiler_filter, volume_uuid, class_loader_context, se_info,
Keun young Park65578d62021-06-28 17:52:05 -07002767 downgrade, targetSdkVersion, profile_name, dm_path, compilation_reason, &error_msg,
2768 &completed);
2769 *aidl_return = completed;
Andreas Gampe023b2242018-02-28 16:03:25 -08002770 return res ? error(res, error_msg) : ok();
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002771}
2772
Keun young Park65578d62021-06-28 17:52:05 -07002773binder::Status InstalldNativeService::controlDexOptBlocking(bool block) {
2774 android::installd::control_dexopt_blocking(block);
2775 return ok();
2776}
2777
Eric Holk0ebbe0f2019-01-09 18:17:27 -08002778binder::Status InstalldNativeService::compileLayouts(const std::string& apkPath,
2779 const std::string& packageName,
2780 const std ::string& outDexFile, int uid,
2781 bool* _aidl_return) {
2782 const char* apk_path = apkPath.c_str();
2783 const char* package_name = packageName.c_str();
2784 const char* out_dex_file = outDexFile.c_str();
2785 *_aidl_return = android::installd::view_compiler(apk_path, package_name, out_dex_file, uid);
2786 return *_aidl_return ? ok() : error("viewcompiler failed");
2787}
2788
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002789binder::Status InstalldNativeService::linkNativeLibraryDirectory(
Jooyung Han149be4a2020-01-23 12:45:10 +09002790 const std::optional<std::string>& uuid, const std::string& packageName,
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002791 const std::string& nativeLibPath32, int32_t userId) {
2792 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002793 CHECK_ARGUMENT_UUID(uuid);
2794 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07002795 CHECK_ARGUMENT_PATH(nativeLibPath32);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002796 LOCK_PACKAGE_USER();
Jeff Sharkey423e7462016-12-09 18:18:43 -07002797
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002798 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2799 const char* pkgname = packageName.c_str();
2800 const char* asecLibDir = nativeLibPath32.c_str();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002801 struct stat s, libStat;
Jeff Sharkey423e7462016-12-09 18:18:43 -07002802 binder::Status res = ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002803
Jeff Sharkey423e7462016-12-09 18:18:43 -07002804 auto _pkgdir = create_data_user_ce_package_path(uuid_, userId, pkgname);
2805 auto _libsymlink = _pkgdir + PKG_LIB_POSTFIX;
Jeff Sharkeyc03de092015-04-07 18:14:05 -07002806
2807 const char* pkgdir = _pkgdir.c_str();
2808 const char* libsymlink = _libsymlink.c_str();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002809
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002810 if (stat(pkgdir, &s) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002811 return error("Failed to stat " + _pkgdir);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002812 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07002813
Nick Kralevich85958b62019-01-30 12:32:21 -08002814 char *con = nullptr;
2815 if (lgetfilecon(pkgdir, &con) < 0) {
2816 return error("Failed to lgetfilecon " + _pkgdir);
2817 }
2818
Mike Lockwood94afecf2012-10-24 10:45:23 -07002819 if (chown(pkgdir, AID_INSTALL, AID_INSTALL) < 0) {
Nick Kralevich85958b62019-01-30 12:32:21 -08002820 res = error("Failed to chown " + _pkgdir);
2821 goto out;
Mike Lockwood94afecf2012-10-24 10:45:23 -07002822 }
2823
2824 if (chmod(pkgdir, 0700) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002825 res = error("Failed to chmod " + _pkgdir);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002826 goto out;
2827 }
2828
2829 if (lstat(libsymlink, &libStat) < 0) {
2830 if (errno != ENOENT) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002831 res = error("Failed to stat " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002832 goto out;
2833 }
2834 } else {
2835 if (S_ISDIR(libStat.st_mode)) {
Yi Konge7bf3772018-07-17 16:16:24 -07002836 if (delete_dir_contents(libsymlink, 1, nullptr) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002837 res = error("Failed to delete " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002838 goto out;
2839 }
2840 } else if (S_ISLNK(libStat.st_mode)) {
2841 if (unlink(libsymlink) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002842 res = error("Failed to unlink " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002843 goto out;
2844 }
2845 }
2846 }
2847
2848 if (symlink(asecLibDir, libsymlink) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002849 res = error("Failed to symlink " + _libsymlink + " to " + nativeLibPath32);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002850 goto out;
2851 }
2852
Nick Kralevich85958b62019-01-30 12:32:21 -08002853 if (lsetfilecon(libsymlink, con) < 0) {
2854 res = error("Failed to lsetfilecon " + _libsymlink);
2855 goto out;
2856 }
2857
Mike Lockwood94afecf2012-10-24 10:45:23 -07002858out:
Nick Kralevich85958b62019-01-30 12:32:21 -08002859 free(con);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002860 if (chmod(pkgdir, s.st_mode) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002861 auto msg = "Failed to cleanup chmod " + _pkgdir;
2862 if (res.isOk()) {
2863 res = error(msg);
2864 } else {
2865 PLOG(ERROR) << msg;
2866 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07002867 }
2868
2869 if (chown(pkgdir, s.st_uid, s.st_gid) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002870 auto msg = "Failed to cleanup chown " + _pkgdir;
2871 if (res.isOk()) {
2872 res = error(msg);
2873 } else {
2874 PLOG(ERROR) << msg;
2875 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07002876 }
2877
Jeff Sharkey423e7462016-12-09 18:18:43 -07002878 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -07002879}
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002880
Jooyung Han149be4a2020-01-23 12:45:10 +09002881binder::Status InstalldNativeService::restoreconAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002882 const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,
2883 const std::string& seInfo) {
2884 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002885 CHECK_ARGUMENT_UUID(uuid);
2886 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002887 LOCK_PACKAGE_USER();
Alex Buynytskyyfcd5bf32021-11-23 11:31:34 -08002888 return restoreconAppDataLocked(uuid, packageName, userId, flags, appId, seInfo);
2889}
2890
2891binder::Status InstalldNativeService::restoreconAppDataLocked(
2892 const std::optional<std::string>& uuid, const std::string& packageName, int32_t userId,
2893 int32_t flags, int32_t appId, const std::string& seInfo) {
2894 ENFORCE_UID(AID_SYSTEM);
2895 CHECK_ARGUMENT_UUID(uuid);
2896 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002897
2898 binder::Status res = ok();
Robert Craige9887e42014-02-20 10:25:56 -05002899
Robert Craigda30dc72014-03-27 10:21:12 -04002900 // SELINUX_ANDROID_RESTORECON_DATADATA flag is set by libselinux. Not needed here.
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002901 unsigned int seflags = SELINUX_ANDROID_RESTORECON_RECURSE;
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002902 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2903 const char* pkgName = packageName.c_str();
2904 const char* seinfo = seInfo.c_str();
Robert Craigda30dc72014-03-27 10:21:12 -04002905
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002906 uid_t uid = multiuser_get_uid(userId, appId);
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07002907 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002908 auto path = create_data_user_ce_package_path(uuid_, userId, pkgName);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002909 if (selinux_android_restorecon_pkgdir(path.c_str(), seinfo, uid, seflags) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002910 res = error("restorecon failed for " + path);
Jeff Sharkeyebf728f2015-11-18 14:15:17 -07002911 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002912 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07002913 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002914 auto path = create_data_user_de_package_path(uuid_, userId, pkgName);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002915 if (selinux_android_restorecon_pkgdir(path.c_str(), seinfo, uid, seflags) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002916 res = error("restorecon failed for " + path);
Jeff Sharkey41ea4242015-04-09 11:34:03 -07002917 }
Robert Craige9887e42014-02-20 10:25:56 -05002918 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002919 return res;
Robert Craige9887e42014-02-20 10:25:56 -05002920}
Narayan Kamath3aee2c52014-06-10 13:16:47 +01002921
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002922binder::Status InstalldNativeService::createOatDir(const std::string& oatDir,
2923 const std::string& instructionSet) {
2924 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002925 CHECK_ARGUMENT_PATH(oatDir);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002926 LOCK_PACKAGE();
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002927
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002928 const char* oat_dir = oatDir.c_str();
2929 const char* instruction_set = instructionSet.c_str();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002930 char oat_instr_dir[PKG_PATH_MAX];
2931
2932 if (validate_apk_path(oat_dir)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002933 return error("Invalid path " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002934 }
Fyodor Kupolov8eed7e62015-04-06 19:09:02 -07002935 if (fs_prepare_dir(oat_dir, S_IRWXU | S_IRWXG | S_IXOTH, AID_SYSTEM, AID_INSTALL)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002936 return error("Failed to prepare " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002937 }
2938 if (selinux_android_restorecon(oat_dir, 0)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002939 return error("Failed to restorecon " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002940 }
2941 snprintf(oat_instr_dir, PKG_PATH_MAX, "%s/%s", oat_dir, instruction_set);
Fyodor Kupolov8eed7e62015-04-06 19:09:02 -07002942 if (fs_prepare_dir(oat_instr_dir, S_IRWXU | S_IRWXG | S_IXOTH, AID_SYSTEM, AID_INSTALL)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002943 return error(StringPrintf("Failed to prepare %s", oat_instr_dir));
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002944 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002945 return ok();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002946}
2947
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002948binder::Status InstalldNativeService::rmPackageDir(const std::string& packageDir) {
2949 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002950 CHECK_ARGUMENT_PATH(packageDir);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002951 LOCK_PACKAGE();
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002952
Jeff Sharkey423e7462016-12-09 18:18:43 -07002953 if (validate_apk_path(packageDir.c_str())) {
2954 return error("Invalid path " + packageDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002955 }
Oleksandr Peletskyid2be6322019-01-24 17:59:45 +01002956 if (rm_package_dir(packageDir) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002957 return error("Failed to delete " + packageDir);
2958 }
2959 return ok();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002960}
2961
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002962binder::Status InstalldNativeService::linkFile(const std::string& relativePath,
2963 const std::string& fromBase, const std::string& toBase) {
2964 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002965 CHECK_ARGUMENT_PATH(fromBase);
2966 CHECK_ARGUMENT_PATH(toBase);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002967 LOCK_PACKAGE();
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002968
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002969 const char* relative_path = relativePath.c_str();
2970 const char* from_base = fromBase.c_str();
2971 const char* to_base = toBase.c_str();
Narayan Kamathd845c962015-06-04 13:20:27 +01002972 char from_path[PKG_PATH_MAX];
2973 char to_path[PKG_PATH_MAX];
2974 snprintf(from_path, PKG_PATH_MAX, "%s/%s", from_base, relative_path);
2975 snprintf(to_path, PKG_PATH_MAX, "%s/%s", to_base, relative_path);
2976
2977 if (validate_apk_path_subdirs(from_path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002978 return error(StringPrintf("Invalid from path %s", from_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002979 }
2980
2981 if (validate_apk_path_subdirs(to_path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002982 return error(StringPrintf("Invalid to path %s", to_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002983 }
2984
Jeff Sharkey423e7462016-12-09 18:18:43 -07002985 if (link(from_path, to_path) < 0) {
2986 return error(StringPrintf("Failed to link from %s to %s", from_path, to_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002987 }
2988
Jeff Sharkey423e7462016-12-09 18:18:43 -07002989 return ok();
Narayan Kamathd845c962015-06-04 13:20:27 +01002990}
2991
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002992binder::Status InstalldNativeService::moveAb(const std::string& apkPath,
2993 const std::string& instructionSet, const std::string& outputPath) {
2994 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002995 CHECK_ARGUMENT_PATH(apkPath);
2996 CHECK_ARGUMENT_PATH(outputPath);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08002997 LOCK_PACKAGE();
Jeff Sharkey90aff262016-12-12 14:28:24 -07002998
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002999 const char* apk_path = apkPath.c_str();
3000 const char* instruction_set = instructionSet.c_str();
3001 const char* oat_dir = outputPath.c_str();
Andreas Gampe0354bd02016-06-27 14:25:30 -07003002
Jeff Sharkey90aff262016-12-12 14:28:24 -07003003 bool success = move_ab(apk_path, instruction_set, oat_dir);
Jeff Sharkey423e7462016-12-09 18:18:43 -07003004 return success ? ok() : error();
Andreas Gampee65b4fa2016-03-01 11:46:45 -08003005}
3006
Jeff Sharkey475c6f92016-12-07 10:37:27 -07003007binder::Status InstalldNativeService::deleteOdex(const std::string& apkPath,
Calin Juravleea214ad2021-06-11 09:17:20 -07003008 const std::string& instructionSet, const std::optional<std::string>& outputPath,
3009 int64_t* _aidl_return) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07003010 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07003011 CHECK_ARGUMENT_PATH(apkPath);
3012 CHECK_ARGUMENT_PATH(outputPath);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08003013 LOCK_PACKAGE();
Jeff Sharkey90aff262016-12-12 14:28:24 -07003014
Jeff Sharkey475c6f92016-12-07 10:37:27 -07003015 const char* apk_path = apkPath.c_str();
3016 const char* instruction_set = instructionSet.c_str();
Andreas Gampec5234092017-05-31 16:39:58 -07003017 const char* oat_dir = outputPath ? outputPath->c_str() : nullptr;
Jeff Sharkey475c6f92016-12-07 10:37:27 -07003018
Calin Juravleea214ad2021-06-11 09:17:20 -07003019 *_aidl_return = delete_odex(apk_path, instruction_set, oat_dir);
3020 return *_aidl_return == -1 ? error() : ok();
Andreas Gampe3964da02016-09-09 17:07:04 -07003021}
3022
Calin Juravlebd968362017-01-25 01:17:17 -08003023binder::Status InstalldNativeService::reconcileSecondaryDexFile(
3024 const std::string& dexPath, const std::string& packageName, int32_t uid,
Jooyung Han149be4a2020-01-23 12:45:10 +09003025 const std::vector<std::string>& isas, const std::optional<std::string>& volumeUuid,
Calin Juravlebd968362017-01-25 01:17:17 -08003026 int32_t storage_flag, bool* _aidl_return) {
3027 ENFORCE_UID(AID_SYSTEM);
3028 CHECK_ARGUMENT_UUID(volumeUuid);
3029 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07003030 CHECK_ARGUMENT_PATH(dexPath);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08003031 const auto userId = multiuser_get_user_id(uid);
3032 LOCK_PACKAGE_USER();
Jeff Sharkey53594302018-02-24 18:59:39 -07003033
Calin Juravlebd968362017-01-25 01:17:17 -08003034 bool result = android::installd::reconcile_secondary_dex_file(
3035 dexPath, packageName, uid, isas, volumeUuid, storage_flag, _aidl_return);
3036 return result ? ok() : error();
3037}
3038
Alan Stokes753dc712017-10-16 10:56:00 +01003039binder::Status InstalldNativeService::hashSecondaryDexFile(
3040 const std::string& dexPath, const std::string& packageName, int32_t uid,
Jooyung Han149be4a2020-01-23 12:45:10 +09003041 const std::optional<std::string>& volumeUuid, int32_t storageFlag,
Alan Stokes753dc712017-10-16 10:56:00 +01003042 std::vector<uint8_t>* _aidl_return) {
3043 ENFORCE_UID(AID_SYSTEM);
3044 CHECK_ARGUMENT_UUID(volumeUuid);
3045 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07003046 CHECK_ARGUMENT_PATH(dexPath);
Alan Stokes753dc712017-10-16 10:56:00 +01003047
3048 // mLock is not taken here since we will never modify the file system.
3049 // If a file is modified just as we are reading it this may result in an
3050 // anomalous hash, but that's ok.
3051 bool result = android::installd::hash_secondary_dex_file(
3052 dexPath, packageName, uid, volumeUuid, storageFlag, _aidl_return);
3053 return result ? ok() : error();
3054}
3055
Jeff Sharkey66b1a122017-01-16 20:57:45 -07003056binder::Status InstalldNativeService::invalidateMounts() {
3057 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06003058 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
Jeff Sharkey66b1a122017-01-16 20:57:45 -07003059
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06003060 mStorageMounts.clear();
Risan5f308262018-10-26 12:06:58 -06003061
3062#if !BYPASS_QUOTA
3063 if (!InvalidateQuotaMounts()) {
3064 return error("Failed to read mounts");
3065 }
3066#endif
Jeff Sharkey66b1a122017-01-16 20:57:45 -07003067
3068 std::ifstream in("/proc/mounts");
3069 if (!in.is_open()) {
3070 return error("Failed to read mounts");
3071 }
3072
3073 std::string source;
3074 std::string target;
3075 std::string ignored;
Jeff Sharkey66b1a122017-01-16 20:57:45 -07003076 while (!in.eof()) {
3077 std::getline(in, source, ' ');
3078 std::getline(in, target, ' ');
3079 std::getline(in, ignored);
3080
Zim0ce832d2019-12-03 17:03:58 +00003081 if (android::base::GetBoolProperty(kFuseProp, false)) {
Zim1edb92a2020-01-09 08:48:00 +00003082 if (target.find(kMntFuse) == 0) {
Zim0ce832d2019-12-03 17:03:58 +00003083 LOG(DEBUG) << "Found storage mount " << source << " at " << target;
3084 mStorageMounts[source] = target;
3085 }
3086 } else {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06003087#if !BYPASS_SDCARDFS
Zim1edb92a2020-01-09 08:48:00 +00003088 if (target.find(kMntSdcardfs) == 0) {
Zim0ce832d2019-12-03 17:03:58 +00003089 LOG(DEBUG) << "Found storage mount " << source << " at " << target;
3090 mStorageMounts[source] = target;
3091 }
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06003092#endif
Zim0ce832d2019-12-03 17:03:58 +00003093 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -07003094 }
3095 return ok();
3096}
3097
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003098// Mount volume's CE and DE storage to mirror
Ricky Wai2a4983f2020-02-07 14:25:45 +00003099binder::Status InstalldNativeService::tryMountDataMirror(
Jooyung Han149be4a2020-01-23 12:45:10 +09003100 const std::optional<std::string>& uuid) {
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003101 ENFORCE_UID(AID_SYSTEM);
3102 CHECK_ARGUMENT_UUID(uuid);
3103 if (!sAppDataIsolationEnabled) {
3104 return ok();
3105 }
3106 if (!uuid) {
3107 return error("Should not happen, mounting uuid == null");
3108 }
3109
3110 const char* uuid_ = uuid->c_str();
Ricky Wai2a4983f2020-02-07 14:25:45 +00003111
Alex Buynytskyy40c45ba2021-11-18 15:16:27 -08003112 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
3113
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003114 std::string mirrorVolCePath(StringPrintf("%s/%s", kDataMirrorCePath, uuid_));
Ricky Wai2a4983f2020-02-07 14:25:45 +00003115 if (fs_prepare_dir(mirrorVolCePath.c_str(), 0711, AID_SYSTEM, AID_SYSTEM) != 0) {
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003116 return error("Failed to create CE mirror");
3117 }
Ricky Wai2a4983f2020-02-07 14:25:45 +00003118
3119 std::string mirrorVolDePath(StringPrintf("%s/%s", kDataMirrorDePath, uuid_));
3120 if (fs_prepare_dir(mirrorVolDePath.c_str(), 0711, AID_SYSTEM, AID_SYSTEM) != 0) {
3121 return error("Failed to create DE mirror");
3122 }
3123
3124 auto cePath = StringPrintf("%s/user", create_data_path(uuid_).c_str());
3125 auto dePath = StringPrintf("%s/user_de", create_data_path(uuid_).c_str());
3126
3127 if (access(cePath.c_str(), F_OK) != 0) {
3128 return error("Cannot access CE path: " + cePath);
3129 }
3130 if (access(dePath.c_str(), F_OK) != 0) {
3131 return error("Cannot access DE path: " + dePath);
3132 }
3133
3134 struct stat ceStat, mirrorCeStat;
3135 if (stat(cePath.c_str(), &ceStat) != 0) {
3136 return error("Failed to stat " + cePath);
3137 }
3138 if (stat(mirrorVolCePath.c_str(), &mirrorCeStat) != 0) {
3139 return error("Failed to stat " + mirrorVolCePath);
3140 }
3141
3142 if (mirrorCeStat.st_ino == ceStat.st_ino) {
3143 // As it's being called by prepareUserStorage, it can be called multiple times.
3144 // Hence, we if we mount it already, we should skip it.
3145 LOG(WARNING) << "CE dir is mounted already: " + cePath;
3146 return ok();
3147 }
3148
3149 // Mount CE mirror
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003150 if (TEMP_FAILURE_RETRY(mount(cePath.c_str(), mirrorVolCePath.c_str(), NULL,
3151 MS_NOSUID | MS_NODEV | MS_NOATIME | MS_BIND | MS_NOEXEC, nullptr)) == -1) {
3152 return error("Failed to mount " + mirrorVolCePath);
3153 }
3154
3155 // Mount DE mirror
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003156 if (TEMP_FAILURE_RETRY(mount(dePath.c_str(), mirrorVolDePath.c_str(), NULL,
3157 MS_NOSUID | MS_NODEV | MS_NOATIME | MS_BIND | MS_NOEXEC, nullptr)) == -1) {
3158 return error("Failed to mount " + mirrorVolDePath);
3159 }
3160 return ok();
3161}
3162
3163// Unmount volume's CE and DE storage from mirror
3164binder::Status InstalldNativeService::onPrivateVolumeRemoved(
Jooyung Han149be4a2020-01-23 12:45:10 +09003165 const std::optional<std::string>& uuid) {
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003166 ENFORCE_UID(AID_SYSTEM);
3167 CHECK_ARGUMENT_UUID(uuid);
3168 if (!sAppDataIsolationEnabled) {
3169 return ok();
3170 }
3171 if (!uuid) {
3172 // It happens when private volume failed to mount.
3173 LOG(INFO) << "Ignore unmount uuid=null";
3174 return ok();
3175 }
3176 const char* uuid_ = uuid->c_str();
3177
3178 binder::Status res = ok();
3179
3180 std::string mirrorCeVolPath(StringPrintf("%s/%s", kDataMirrorCePath, uuid_));
3181 std::string mirrorDeVolPath(StringPrintf("%s/%s", kDataMirrorDePath, uuid_));
3182
Alex Buynytskyy40c45ba2021-11-18 15:16:27 -08003183 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
3184
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003185 // Unmount CE storage
Ricky Waiff9d3ea2019-11-18 18:18:24 +00003186 if (TEMP_FAILURE_RETRY(umount(mirrorCeVolPath.c_str())) != 0) {
3187 if (errno != ENOENT) {
3188 res = error(StringPrintf("Failed to umount %s %s", mirrorCeVolPath.c_str(),
3189 strerror(errno)));
3190 }
3191 }
3192 if (delete_dir_contents_and_dir(mirrorCeVolPath, true) != 0) {
3193 res = error("Failed to delete " + mirrorCeVolPath);
3194 }
3195
3196 // Unmount DE storage
3197 if (TEMP_FAILURE_RETRY(umount(mirrorDeVolPath.c_str())) != 0) {
3198 if (errno != ENOENT) {
3199 res = error(StringPrintf("Failed to umount %s %s", mirrorDeVolPath.c_str(),
3200 strerror(errno)));
3201 }
3202 }
3203 if (delete_dir_contents_and_dir(mirrorDeVolPath, true) != 0) {
3204 res = error("Failed to delete " + mirrorDeVolPath);
3205 }
3206 return res;
3207}
3208
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06003209std::string InstalldNativeService::findDataMediaPath(
Jooyung Han149be4a2020-01-23 12:45:10 +09003210 const std::optional<std::string>& uuid, userid_t userid) {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06003211 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
3212 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
3213 auto path = StringPrintf("%s/media", create_data_path(uuid_).c_str());
3214 auto resolved = mStorageMounts[path];
3215 if (resolved.empty()) {
3216 LOG(WARNING) << "Failed to find storage mount for " << path;
3217 resolved = path;
3218 }
3219 return StringPrintf("%s/%u", resolved.c_str(), userid);
3220}
3221
Jeff Sharkey325b8c92017-02-21 10:00:53 -07003222binder::Status InstalldNativeService::isQuotaSupported(
Jooyung Han149be4a2020-01-23 12:45:10 +09003223 const std::optional<std::string>& uuid, bool* _aidl_return) {
3224 *_aidl_return = IsQuotaSupported(uuid.value_or(""));
Jeff Sharkey325b8c92017-02-21 10:00:53 -07003225 return ok();
3226}
3227
Calin Juravlebc5ab872018-01-18 22:32:58 -08003228binder::Status InstalldNativeService::prepareAppProfile(const std::string& packageName,
3229 int32_t userId, int32_t appId, const std::string& profileName, const std::string& codePath,
Jooyung Han149be4a2020-01-23 12:45:10 +09003230 const std::optional<std::string>& dexMetadata, bool* _aidl_return) {
Calin Juravlebc5ab872018-01-18 22:32:58 -08003231 ENFORCE_UID(AID_SYSTEM);
3232 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07003233 CHECK_ARGUMENT_PATH(codePath);
Alex Buynytskyy4fef8862021-11-21 16:09:33 -08003234 LOCK_PACKAGE_USER();
Calin Juravlebc5ab872018-01-18 22:32:58 -08003235
3236 *_aidl_return = prepare_app_profile(packageName, userId, appId, profileName, codePath,
3237 dexMetadata);
3238 return ok();
3239}
3240
Narayan Kamath28ab93b2019-05-15 18:29:44 +01003241binder::Status InstalldNativeService::migrateLegacyObbData() {
3242 ENFORCE_UID(AID_SYSTEM);
3243 // NOTE: The lint warning doesn't apply to the use of system(3) with
3244 // absolute parse and no command line arguments.
3245 if (system("/system/bin/migrate_legacy_obb_data.sh") != 0) { // NOLINT(cert-env33-c)
3246 LOG(ERROR) << "Unable to migrate legacy obb data";
3247 }
3248
3249 return ok();
3250}
3251
Alex Buynytskyy58a73092022-02-14 13:15:53 -08003252binder::Status InstalldNativeService::cleanupInvalidPackageDirs(
3253 const std::optional<std::string>& uuid, int32_t userId, int32_t flags) {
Alex Buynytskyy038a19b2022-02-09 19:51:52 -08003254 const char* uuid_cstr = uuid ? uuid->c_str() : nullptr;
Alex Buynytskyy038a19b2022-02-09 19:51:52 -08003255
Alex Buynytskyy58a73092022-02-14 13:15:53 -08003256 if (flags & FLAG_STORAGE_CE) {
3257 auto ce_path = create_data_user_ce_path(uuid_cstr, userId);
3258 cleanup_invalid_package_dirs_under_path(ce_path);
Alex Buynytskyy038a19b2022-02-09 19:51:52 -08003259 }
Alex Buynytskyy58a73092022-02-14 13:15:53 -08003260
3261 if (flags & FLAG_STORAGE_DE) {
3262 auto de_path = create_data_user_de_path(uuid_cstr, userId);
3263 cleanup_invalid_package_dirs_under_path(de_path);
3264 }
3265
Alex Buynytskyy038a19b2022-02-09 19:51:52 -08003266 return ok();
3267}
3268
Andreas Gampe02d0de52015-11-11 20:43:16 -08003269} // namespace installd
3270} // namespace android