blob: dc0583e3db23166bfd2cc758c58c2f6b199eca6f [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
Victor Hsiehc6d738a2018-01-20 15:06:39 -080021#include <algorithm>
Andreas Gampe02d0de52015-11-11 20:43:16 -080022#include <errno.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070023#include <fstream>
24#include <fts.h>
Victor Hsieh18ac0272018-03-12 16:03:02 -070025#include <functional>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080026#include <inttypes.h>
Jooyung Han9fcc4ef2020-01-23 12:45:10 +090027#include <memory>
Andreas Gampe0354bd02016-06-27 14:25:30 -070028#include <regex>
Andreas Gampe02d0de52015-11-11 20:43:16 -080029#include <stdlib.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070030#include <string.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080031#include <sys/capability.h>
32#include <sys/file.h>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080033#include <sys/ioctl.h>
34#include <sys/mman.h>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080035#include <sys/resource.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080036#include <sys/stat.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070037#include <sys/statvfs.h>
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070038#include <sys/types.h>
Calin Juravle6a1648e2016-02-01 12:12:16 +000039#include <sys/wait.h>
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070040#include <sys/xattr.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080041#include <unistd.h>
Jeff Sharkey41ea4242015-04-09 11:34:03 -070042
Nikita Ioffeb68f0d12019-02-04 11:06:37 +000043#include <android-base/file.h>
Andreas Gampeafa58d12016-06-03 16:09:32 -070044#include <android-base/logging.h>
Jeff Sharkeyf29a3bc2018-01-08 10:40:19 -070045#include <android-base/properties.h>
Narayan Kamathe63ca7d2019-01-14 15:21:52 +000046#include <android-base/scopeguard.h>
Elliott Hughese4ec9eb2015-12-04 15:39:32 -080047#include <android-base/stringprintf.h>
David Sehr6727c2d2016-05-17 16:06:22 -070048#include <android-base/strings.h>
Roland Levillain64b59cc2016-04-05 16:41:12 +010049#include <android-base/unique_fd.h>
Victor Hsieh3f16dd62018-01-13 13:43:11 -080050#include <cutils/ashmem.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080051#include <cutils/fs.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070052#include <cutils/properties.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070053#include <cutils/sched_policy.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070054#include <log/log.h> // TODO: Move everything to base/logging.
Jeff Sharkeye3637242015-04-08 20:56:42 -070055#include <logwrap/logwrap.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080056#include <private/android_filesystem_config.h>
Martijn Coenen771cc342020-02-19 23:26:56 +010057#include <private/android_projectid_config.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070058#include <selinux/android.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080059#include <system/thread_defs.h>
Jeff Sharkey466459b2017-01-17 15:25:01 -070060#include <utils/Trace.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070061
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070062#include "dexopt.h"
Jeff Sharkeyf3e30b92016-12-09 17:06:57 -070063#include "globals.h"
64#include "installd_deps.h"
65#include "otapreopt_utils.h"
66#include "utils.h"
Eric Holk0ebbe0f2019-01-09 18:17:27 -080067#include "view_compiler.h"
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070068
Jeff Sharkey88ddd942017-01-17 18:05:54 -070069#include "CacheTracker.h"
Jeff Sharkeydf2d7542017-01-07 09:19:35 -070070#include "MatchExtensionGen.h"
Risan5f308262018-10-26 12:06:58 -060071#include "QuotaUtils.h"
Jeff Sharkeydf2d7542017-01-07 09:19:35 -070072
Andreas Gampe02d0de52015-11-11 20:43:16 -080073#ifndef LOG_TAG
74#define LOG_TAG "installd"
75#endif
Jeff Sharkey41ea4242015-04-09 11:34:03 -070076
77using android::base::StringPrintf;
Jeff Sharkey66b1a122017-01-16 20:57:45 -070078using std::endl;
Mike Lockwood94afecf2012-10-24 10:45:23 -070079
Andreas Gampe02d0de52015-11-11 20:43:16 -080080namespace android {
81namespace installd {
Mike Lockwood94afecf2012-10-24 10:45:23 -070082
Nikita Ioffe8e4d3462019-01-21 17:56:03 +000083// An uuid used in unit tests.
84static constexpr const char* kTestUuid = "TEST";
85
Nikita Ioffeb68f0d12019-02-04 11:06:37 +000086static constexpr const mode_t kRollbackFolderMode = 0700;
87
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070088static constexpr const char* kCpPath = "/system/bin/cp";
89static constexpr const char* kXattrDefault = "user.default";
Jeff Sharkeye3637242015-04-08 20:56:42 -070090
Janis Danisevskis40bd3ef2016-06-07 10:31:27 -070091static constexpr const int MIN_RESTRICTED_HOME_SDK_VERSION = 24; // > M
Janis Danisevskiseecb2d22016-01-12 14:45:55 +000092
Andreas Gampe0354bd02016-06-27 14:25:30 -070093static constexpr const char* PKG_LIB_POSTFIX = "/lib";
94static constexpr const char* CACHE_DIR_POSTFIX = "/cache";
95static constexpr const char* CODE_CACHE_DIR_POSTFIX = "/code_cache";
96
Jaekyun Seok5cb903e2017-05-18 00:13:44 +090097static constexpr const char *kIdMapPath = "/system/bin/idmap";
Andreas Gampe0354bd02016-06-27 14:25:30 -070098static constexpr const char* IDMAP_PREFIX = "/data/resource-cache/";
99static constexpr const char* IDMAP_SUFFIX = "@idmap";
100
Victor Hsieh3f16dd62018-01-13 13:43:11 -0800101// fsverity assumes the page size is always 4096. If not, the feature can not be
102// enabled.
103static constexpr int kVerityPageSize = 4096;
Victor Hsiehc6d738a2018-01-20 15:06:39 -0800104static constexpr size_t kSha256Size = 32;
Victor Hsieh99de5162017-10-06 14:44:14 -0700105static constexpr const char* kPropApkVerityMode = "ro.apk_verity.mode";
Zim0ce832d2019-12-03 17:03:58 +0000106static constexpr const char* kFuseProp = "persist.sys.fuse";
Victor Hsieh99de5162017-10-06 14:44:14 -0700107
Zim4527e3a2020-01-09 08:48:00 +0000108static constexpr const char* kMntSdcardfs = "/mnt/runtime/default/";
109static constexpr const char* kMntFuse = "/mnt/pass_through/0/";
110
Jeff Sharkey0274c972016-12-06 09:32:04 -0700111namespace {
112
113constexpr const char* kDump = "android.permission.DUMP";
114
Jeff Sharkey423e7462016-12-09 18:18:43 -0700115static binder::Status ok() {
116 return binder::Status::ok();
117}
118
119static binder::Status exception(uint32_t code, const std::string& msg) {
Jeff Sharkey8e9bf352018-02-27 11:40:45 -0700120 LOG(ERROR) << msg << " (" << code << ")";
Jeff Sharkey423e7462016-12-09 18:18:43 -0700121 return binder::Status::fromExceptionCode(code, String8(msg.c_str()));
122}
123
124static binder::Status error() {
125 return binder::Status::fromServiceSpecificError(errno);
126}
127
128static binder::Status error(const std::string& msg) {
129 PLOG(ERROR) << msg;
130 return binder::Status::fromServiceSpecificError(errno, String8(msg.c_str()));
131}
132
133static binder::Status error(uint32_t code, const std::string& msg) {
134 LOG(ERROR) << msg << " (" << code << ")";
135 return binder::Status::fromServiceSpecificError(code, String8(msg.c_str()));
136}
137
Jeff Sharkey0274c972016-12-06 09:32:04 -0700138binder::Status checkPermission(const char* permission) {
139 pid_t pid;
140 uid_t uid;
141
142 if (checkCallingPermission(String16(permission), reinterpret_cast<int32_t*>(&pid),
143 reinterpret_cast<int32_t*>(&uid))) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700144 return ok();
Jeff Sharkey0274c972016-12-06 09:32:04 -0700145 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700146 return exception(binder::Status::EX_SECURITY,
147 StringPrintf("UID %d / PID %d lacks permission %s", uid, pid, permission));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700148 }
149}
150
151binder::Status checkUid(uid_t expectedUid) {
152 uid_t uid = IPCThreadState::self()->getCallingUid();
153 if (uid == expectedUid || uid == AID_ROOT) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700154 return ok();
Jeff Sharkey0274c972016-12-06 09:32:04 -0700155 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700156 return exception(binder::Status::EX_SECURITY,
157 StringPrintf("UID %d is not expected UID %d", uid, expectedUid));
158 }
159}
160
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900161binder::Status checkArgumentUuid(const std::optional<std::string>& uuid) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700162 if (!uuid || is_valid_filename(*uuid)) {
163 return ok();
164 } else {
165 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
166 StringPrintf("UUID %s is malformed", uuid->c_str()));
167 }
168}
169
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900170binder::Status checkArgumentUuidTestOrNull(const std::optional<std::string>& uuid) {
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000171 if (!uuid || strcmp(uuid->c_str(), kTestUuid) == 0) {
172 return ok();
173 } else {
174 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
175 StringPrintf("UUID must be null or \"%s\", got: %s", kTestUuid, uuid->c_str()));
176 }
177}
178
Jeff Sharkey423e7462016-12-09 18:18:43 -0700179binder::Status checkArgumentPackageName(const std::string& packageName) {
Greg Kaiser6d758fc2019-03-26 08:55:32 -0700180 if (is_valid_package_name(packageName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700181 return ok();
182 } else {
183 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
184 StringPrintf("Package name %s is malformed", packageName.c_str()));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700185 }
186}
187
Jeff Sharkey53594302018-02-24 18:59:39 -0700188binder::Status checkArgumentPath(const std::string& path) {
189 if (path.empty()) {
190 return exception(binder::Status::EX_ILLEGAL_ARGUMENT, "Missing path");
191 }
192 if (path[0] != '/') {
193 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
194 StringPrintf("Path %s is relative", path.c_str()));
195 }
196 if ((path + '/').find("/../") != std::string::npos) {
197 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
198 StringPrintf("Path %s is shady", path.c_str()));
199 }
200 for (const char& c : path) {
201 if (c == '\0' || c == '\n') {
202 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
203 StringPrintf("Path %s is malformed", path.c_str()));
204 }
205 }
206 return ok();
207}
208
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900209binder::Status checkArgumentPath(const std::optional<std::string>& path) {
Jeff Sharkey53594302018-02-24 18:59:39 -0700210 if (path) {
211 return checkArgumentPath(*path);
212 } else {
213 return ok();
214 }
215}
216
Jeff Sharkey0274c972016-12-06 09:32:04 -0700217#define ENFORCE_UID(uid) { \
218 binder::Status status = checkUid((uid)); \
219 if (!status.isOk()) { \
220 return status; \
221 } \
222}
223
Jeff Sharkey423e7462016-12-09 18:18:43 -0700224#define CHECK_ARGUMENT_UUID(uuid) { \
225 binder::Status status = checkArgumentUuid((uuid)); \
226 if (!status.isOk()) { \
227 return status; \
228 } \
229}
230
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000231#define CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(uuid) { \
232 auto status = checkArgumentUuidTestOrNull(uuid); \
233 if (!status.isOk()) { \
234 return status; \
235 } \
236} \
237
Jeff Sharkey423e7462016-12-09 18:18:43 -0700238#define CHECK_ARGUMENT_PACKAGE_NAME(packageName) { \
239 binder::Status status = \
240 checkArgumentPackageName((packageName)); \
241 if (!status.isOk()) { \
242 return status; \
243 } \
244}
245
Jeff Sharkey53594302018-02-24 18:59:39 -0700246#define CHECK_ARGUMENT_PATH(path) { \
247 binder::Status status = checkArgumentPath((path)); \
248 if (!status.isOk()) { \
249 return status; \
250 } \
251}
252
Victor Hsieh3f16dd62018-01-13 13:43:11 -0800253#define ASSERT_PAGE_SIZE_4K() { \
254 if (getpagesize() != kVerityPageSize) { \
Victor Hsieh7ebd5132018-01-23 07:52:17 -0800255 return error("FSVerity only supports 4K pages"); \
Victor Hsieh3f16dd62018-01-13 13:43:11 -0800256 } \
257}
258
Jeff Sharkey0274c972016-12-06 09:32:04 -0700259} // namespace
260
261status_t InstalldNativeService::start() {
262 IPCThreadState::self()->disableBackgroundScheduling(true);
263 status_t ret = BinderService<InstalldNativeService>::publish();
264 if (ret != android::OK) {
265 return ret;
266 }
267 sp<ProcessState> ps(ProcessState::self());
268 ps->startThreadPool();
269 ps->giveThreadPoolName();
270 return android::OK;
271}
272
273status_t InstalldNativeService::dump(int fd, const Vector<String16> & /* args */) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700274 auto out = std::fstream(StringPrintf("/proc/self/fd/%d", fd));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700275 const binder::Status dump_permission = checkPermission(kDump);
276 if (!dump_permission.isOk()) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700277 out << dump_permission.toString8() << endl;
Jeff Sharkey0274c972016-12-06 09:32:04 -0700278 return PERMISSION_DENIED;
279 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700280 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey0274c972016-12-06 09:32:04 -0700281
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700282 out << "installd is happy!" << endl;
283
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700284 {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -0600285 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
286 out << endl << "Storage mounts:" << endl;
287 for (const auto& n : mStorageMounts) {
288 out << " " << n.first << " = " << n.second << endl;
289 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700290 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700291
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700292 {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -0600293 std::lock_guard<std::recursive_mutex> lock(mQuotasLock);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700294 out << endl << "Per-UID cache quotas:" << endl;
295 for (const auto& n : mCacheQuotas) {
296 out << " " << n.first << " = " << n.second << endl;
297 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700298 }
299
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700300 out << endl;
301 out.flush();
302
Jeff Sharkey0274c972016-12-06 09:32:04 -0700303 return NO_ERROR;
304}
305
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600306/**
307 * Perform restorecon of the given path, but only perform recursive restorecon
308 * if the label of that top-level file actually changed. This can save us
309 * significant time by avoiding no-op traversals of large filesystem trees.
310 */
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700311static int restorecon_app_data_lazy(const std::string& path, const std::string& seInfo, uid_t uid,
312 bool existing) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600313 int res = 0;
314 char* before = nullptr;
315 char* after = nullptr;
316
317 // Note that SELINUX_ANDROID_RESTORECON_DATADATA flag is set by
318 // libselinux. Not needed here.
319
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600320 if (lgetfilecon(path.c_str(), &before) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600321 PLOG(ERROR) << "Failed before getfilecon for " << path;
322 goto fail;
323 }
Jeff Sharkey0274c972016-12-06 09:32:04 -0700324 if (selinux_android_restorecon_pkgdir(path.c_str(), seInfo.c_str(), uid, 0) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600325 PLOG(ERROR) << "Failed top-level restorecon for " << path;
326 goto fail;
327 }
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600328 if (lgetfilecon(path.c_str(), &after) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600329 PLOG(ERROR) << "Failed after getfilecon for " << path;
330 goto fail;
331 }
332
333 // If the initial top-level restorecon above changed the label, then go
334 // back and restorecon everything recursively
335 if (strcmp(before, after)) {
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700336 if (existing) {
337 LOG(DEBUG) << "Detected label change from " << before << " to " << after << " at "
338 << path << "; running recursive restorecon";
339 }
Jeff Sharkey0274c972016-12-06 09:32:04 -0700340 if (selinux_android_restorecon_pkgdir(path.c_str(), seInfo.c_str(), uid,
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600341 SELINUX_ANDROID_RESTORECON_RECURSE) < 0) {
342 PLOG(ERROR) << "Failed recursive restorecon for " << path;
343 goto fail;
344 }
345 }
346
347 goto done;
348fail:
349 res = -1;
350done:
351 free(before);
352 free(after);
353 return res;
354}
355
Jeff Sharkey0274c972016-12-06 09:32:04 -0700356static int restorecon_app_data_lazy(const std::string& parent, const char* name,
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700357 const std::string& seInfo, uid_t uid, bool existing) {
358 return restorecon_app_data_lazy(StringPrintf("%s/%s", parent.c_str(), name), seInfo, uid,
359 existing);
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600360}
361
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600362static int prepare_app_dir(const std::string& path, mode_t target_mode, uid_t uid) {
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600363 if (fs_prepare_dir_strict(path.c_str(), target_mode, uid, uid) != 0) {
364 PLOG(ERROR) << "Failed to prepare " << path;
365 return -1;
366 }
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600367 return 0;
368}
369
Calin Juravled2affb82017-11-28 17:41:43 -0800370static bool prepare_app_profile_dir(const std::string& packageName, int32_t appId, int32_t userId) {
371 if (!property_get_bool("dalvik.vm.usejitprofiles", false)) {
372 return true;
373 }
374
375 int32_t uid = multiuser_get_uid(userId, appId);
376 int shared_app_gid = multiuser_get_shared_gid(userId, appId);
377 if (shared_app_gid == -1) {
378 // TODO(calin): this should no longer be possible but do not continue if we don't get
379 // a valid shared gid.
380 PLOG(WARNING) << "Invalid shared_app_gid for " << packageName;
381 return true;
382 }
383
384 const std::string profile_dir =
385 create_primary_current_profile_package_dir_path(userId, packageName);
386 // read-write-execute only for the app user.
387 if (fs_prepare_dir_strict(profile_dir.c_str(), 0700, uid, uid) != 0) {
388 PLOG(ERROR) << "Failed to prepare " << profile_dir;
389 return false;
390 }
Calin Juravlecfcd6aa2018-01-18 20:23:17 -0800391
Calin Juravled2affb82017-11-28 17:41:43 -0800392 const std::string ref_profile_path =
393 create_primary_reference_profile_package_dir_path(packageName);
Calin Juravle6f06eb62017-11-28 18:44:53 -0800394
395 // Prepare the reference profile directory. Note that we use the non strict version of
396 // fs_prepare_dir. This will fix the permission and the ownership to the correct values.
397 // This is particularly important given that in O there were some fixes for how the
398 // shared_app_gid is computed.
399 //
400 // Note that by the time we get here we know that we are using a correct uid (otherwise
401 // prepare_app_dir and the above fs_prepare_file_strict which check the uid). So we
402 // are sure that the gid being used belongs to the owning app and not someone else.
403 //
404 // dex2oat/profman runs under the shared app gid and it needs to read/write reference profiles.
405 if (fs_prepare_dir(ref_profile_path.c_str(), 0770, AID_SYSTEM, shared_app_gid) != 0) {
Calin Juravled2affb82017-11-28 17:41:43 -0800406 PLOG(ERROR) << "Failed to prepare " << ref_profile_path;
407 return false;
408 }
Calin Juravle6f06eb62017-11-28 18:44:53 -0800409
Calin Juravled2affb82017-11-28 17:41:43 -0800410 return true;
411}
412
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900413binder::Status InstalldNativeService::createAppData(const std::optional<std::string>& uuid,
Jeff Sharkey0274c972016-12-06 09:32:04 -0700414 const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700415 const std::string& seInfo, int32_t targetSdkVersion, int64_t* _aidl_return) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700416 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700417 CHECK_ARGUMENT_UUID(uuid);
418 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700419 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey0274c972016-12-06 09:32:04 -0700420
421 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
422 const char* pkgname = packageName.c_str();
423
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700424 // Assume invalid inode unless filled in below
425 if (_aidl_return != nullptr) *_aidl_return = -1;
426
Jeff Sharkey24ef15b2017-01-12 19:27:03 -0700427 int32_t uid = multiuser_get_uid(userId, appId);
428 int32_t cacheGid = multiuser_get_cache_gid(userId, appId);
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -0700429 mode_t targetMode = targetSdkVersion >= MIN_RESTRICTED_HOME_SDK_VERSION ? 0700 : 0751;
430
Jeff Sharkey24ef15b2017-01-12 19:27:03 -0700431 // If UID doesn't have a specific cache GID, use UID value
432 if (cacheGid == -1) {
433 cacheGid = uid;
434 }
435
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700436 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700437 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname);
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700438 bool existing = (access(path.c_str(), F_OK) == 0);
439
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -0700440 if (prepare_app_dir(path, targetMode, uid) ||
441 prepare_app_cache_dir(path, "cache", 02771, uid, cacheGid) ||
442 prepare_app_cache_dir(path, "code_cache", 02771, uid, cacheGid)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700443 return error("Failed to prepare " + path);
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600444 }
445
446 // Consider restorecon over contents if label changed
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700447 if (restorecon_app_data_lazy(path, seInfo, uid, existing) ||
448 restorecon_app_data_lazy(path, "cache", seInfo, uid, existing) ||
449 restorecon_app_data_lazy(path, "code_cache", seInfo, uid, existing)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700450 return error("Failed to restorecon " + path);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700451 }
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600452
453 // Remember inode numbers of cache directories so that we can clear
454 // contents while CE storage is locked
455 if (write_path_inode(path, "cache", kXattrInodeCache) ||
456 write_path_inode(path, "code_cache", kXattrInodeCodeCache)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700457 return error("Failed to write_path_inode for " + path);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700458 }
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700459
460 // And return the CE inode of the top-level data directory so we can
461 // clear contents while CE storage is locked
462 if ((_aidl_return != nullptr)
463 && get_path_inode(path, reinterpret_cast<ino_t*>(_aidl_return)) != 0) {
464 return error("Failed to get_path_inode for " + path);
465 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700466 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700467 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700468 auto path = create_data_user_de_package_path(uuid_, userId, pkgname);
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700469 bool existing = (access(path.c_str(), F_OK) == 0);
470
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -0700471 if (prepare_app_dir(path, targetMode, uid) ||
472 prepare_app_cache_dir(path, "cache", 02771, uid, cacheGid) ||
473 prepare_app_cache_dir(path, "code_cache", 02771, uid, cacheGid)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700474 return error("Failed to prepare " + path);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700475 }
Calin Juravle6a1648e2016-02-01 12:12:16 +0000476
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600477 // Consider restorecon over contents if label changed
Jeff Sharkey7b6c8402017-04-15 12:09:22 -0600478 if (restorecon_app_data_lazy(path, seInfo, uid, existing) ||
479 restorecon_app_data_lazy(path, "cache", seInfo, uid, existing) ||
480 restorecon_app_data_lazy(path, "code_cache", seInfo, uid, existing)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700481 return error("Failed to restorecon " + path);
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600482 }
483
Calin Juravled2affb82017-11-28 17:41:43 -0800484 if (!prepare_app_profile_dir(packageName, appId, userId)) {
485 return error("Failed to prepare profiles for " + packageName);
Calin Juravle6a1648e2016-02-01 12:12:16 +0000486 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700487 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700488 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -0700489}
490
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900491binder::Status InstalldNativeService::migrateAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700492 const std::string& packageName, int32_t userId, int32_t flags) {
493 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700494 CHECK_ARGUMENT_UUID(uuid);
495 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700496 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700497
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700498 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
499 const char* pkgname = packageName.c_str();
500
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700501 // This method only exists to upgrade system apps that have requested
502 // forceDeviceEncrypted, so their default storage always lives in a
503 // consistent location. This only works on non-FBE devices, since we
504 // never want to risk exposing data on a device with real CE/DE storage.
505
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700506 auto ce_path = create_data_user_ce_package_path(uuid_, userId, pkgname);
507 auto de_path = create_data_user_de_package_path(uuid_, userId, pkgname);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700508
509 // If neither directory is marked as default, assume CE is default
510 if (getxattr(ce_path.c_str(), kXattrDefault, nullptr, 0) == -1
511 && getxattr(de_path.c_str(), kXattrDefault, nullptr, 0) == -1) {
512 if (setxattr(ce_path.c_str(), kXattrDefault, nullptr, 0, 0) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700513 return error("Failed to mark default storage " + ce_path);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700514 }
515 }
516
517 // Migrate default data location if needed
518 auto target = (flags & FLAG_STORAGE_DE) ? de_path : ce_path;
519 auto source = (flags & FLAG_STORAGE_DE) ? ce_path : de_path;
520
521 if (getxattr(target.c_str(), kXattrDefault, nullptr, 0) == -1) {
522 LOG(WARNING) << "Requested default storage " << target
523 << " is not active; migrating from " << source;
524 if (delete_dir_contents_and_dir(target) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700525 return error("Failed to delete " + target);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700526 }
527 if (rename(source.c_str(), target.c_str()) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700528 return error("Failed to rename " + source + " to " + target);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700529 }
530 }
531
Jeff Sharkey423e7462016-12-09 18:18:43 -0700532 return ok();
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700533}
534
Calin Juravle6a1648e2016-02-01 12:12:16 +0000535
Calin Juravle562de812018-01-20 23:34:18 -0800536binder::Status InstalldNativeService::clearAppProfiles(const std::string& packageName,
537 const std::string& profileName) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700538 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700539 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700540 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700541
Jeff Sharkey423e7462016-12-09 18:18:43 -0700542 binder::Status res = ok();
Calin Juravle562de812018-01-20 23:34:18 -0800543 if (!clear_primary_reference_profile(packageName, profileName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700544 res = error("Failed to clear reference profile for " + packageName);
545 }
Calin Juravle562de812018-01-20 23:34:18 -0800546 if (!clear_primary_current_profiles(packageName, profileName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700547 res = error("Failed to clear current profiles for " + packageName);
548 }
549 return res;
Calin Juravle6a1648e2016-02-01 12:12:16 +0000550}
551
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900552binder::Status InstalldNativeService::clearAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700553 const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {
554 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700555 CHECK_ARGUMENT_UUID(uuid);
556 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700557 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700558
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700559 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
560 const char* pkgname = packageName.c_str();
561
Jeff Sharkey423e7462016-12-09 18:18:43 -0700562 binder::Status res = ok();
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700563 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700564 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInode);
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600565 if (flags & FLAG_CLEAR_CACHE_ONLY) {
566 path = read_path_inode(path, "cache", kXattrInodeCache);
567 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
568 path = read_path_inode(path, "code_cache", kXattrInodeCodeCache);
569 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700570 if (access(path.c_str(), F_OK) == 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700571 if (delete_dir_contents(path) != 0) {
572 res = error("Failed to delete contents of " + path);
Ryuki Nakamurac7342f82017-09-30 11:57:00 +0900573 } else if ((flags & (FLAG_CLEAR_CACHE_ONLY | FLAG_CLEAR_CODE_CACHE_ONLY)) == 0) {
574 remove_path_xattr(path, kXattrInodeCache);
575 remove_path_xattr(path, kXattrInodeCodeCache);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700576 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700577 }
578 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700579 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600580 std::string suffix = "";
581 bool only_cache = false;
582 if (flags & FLAG_CLEAR_CACHE_ONLY) {
583 suffix = CACHE_DIR_POSTFIX;
584 only_cache = true;
585 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
586 suffix = CODE_CACHE_DIR_POSTFIX;
587 only_cache = true;
588 }
589
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700590 auto path = create_data_user_de_package_path(uuid_, userId, pkgname) + suffix;
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700591 if (access(path.c_str(), F_OK) == 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700592 if (delete_dir_contents(path) != 0) {
593 res = error("Failed to delete contents of " + path);
594 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700595 }
596 }
Jeff Sharkey6e175692019-05-14 14:55:33 -0600597 if (flags & FLAG_STORAGE_EXTERNAL) {
598 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
599 for (const auto& n : mStorageMounts) {
600 auto extPath = n.second;
Zim0ce832d2019-12-03 17:03:58 +0000601
602 if (android::base::GetBoolProperty(kFuseProp, false)) {
603 std::regex re("^\\/mnt\\/pass_through\\/[0-9]+\\/emulated");
604 if (std::regex_match(extPath, re)) {
605 extPath += "/" + std::to_string(userId);
606 }
607 } else {
608 if (n.first.compare(0, 14, "/mnt/media_rw/") != 0) {
609 extPath += StringPrintf("/%d", userId);
610 } else if (userId != 0) {
611 // TODO: support devices mounted under secondary users
612 continue;
613 }
Jeff Sharkey6e175692019-05-14 14:55:33 -0600614 }
Zim0ce832d2019-12-03 17:03:58 +0000615
Jeff Sharkey6e175692019-05-14 14:55:33 -0600616 if (flags & FLAG_CLEAR_CACHE_ONLY) {
617 // Clear only cached data from shared storage
618 auto path = StringPrintf("%s/Android/data/%s/cache", extPath.c_str(), pkgname);
619 if (delete_dir_contents(path, true) != 0) {
620 res = error("Failed to delete contents of " + path);
621 }
622 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
623 // No code cache on shared storage
624 } else {
625 // Clear everything on shared storage
626 auto path = StringPrintf("%s/Android/data/%s", extPath.c_str(), pkgname);
627 if (delete_dir_contents(path, true) != 0) {
628 res = error("Failed to delete contents of " + path);
629 }
630 path = StringPrintf("%s/Android/media/%s", extPath.c_str(), pkgname);
631 if (delete_dir_contents(path, true) != 0) {
632 res = error("Failed to delete contents of " + path);
633 }
Martijn Coenen24a93072020-01-08 10:10:43 +0100634 // Note that we explicitly don't delete OBBs - those are only removed on
635 // app uninstall.
Jeff Sharkey6e175692019-05-14 14:55:33 -0600636 }
637 }
638 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700639 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700640}
641
Calin Juravle76268c52017-03-09 13:19:42 -0800642static int destroy_app_reference_profile(const std::string& pkgname) {
Calin Juravle7535e8e2016-03-29 16:05:40 +0100643 return delete_dir_contents_and_dir(
Calin Juravle114f0812017-03-08 19:05:07 -0800644 create_primary_reference_profile_package_dir_path(pkgname),
Calin Juravle7535e8e2016-03-29 16:05:40 +0100645 /*ignore_if_missing*/ true);
646}
647
Calin Juravle76268c52017-03-09 13:19:42 -0800648static int destroy_app_current_profiles(const std::string& pkgname, userid_t userid) {
Calin Juravleb06f98a2016-03-28 15:11:01 +0100649 return delete_dir_contents_and_dir(
Calin Juravle114f0812017-03-08 19:05:07 -0800650 create_primary_current_profile_package_dir_path(userid, pkgname),
Calin Juravleb06f98a2016-03-28 15:11:01 +0100651 /*ignore_if_missing*/ true);
Calin Juravleedae6692016-03-23 13:55:31 +0000652}
653
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700654binder::Status InstalldNativeService::destroyAppProfiles(const std::string& packageName) {
655 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700656 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700657 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700658
Jeff Sharkey423e7462016-12-09 18:18:43 -0700659 binder::Status res = ok();
Calin Juravleedae6692016-03-23 13:55:31 +0000660 std::vector<userid_t> users = get_known_users(/*volume_uuid*/ nullptr);
661 for (auto user : users) {
Calin Juravle76268c52017-03-09 13:19:42 -0800662 if (destroy_app_current_profiles(packageName, user) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700663 res = error("Failed to destroy current profiles for " + packageName);
664 }
Calin Juravleedae6692016-03-23 13:55:31 +0000665 }
Calin Juravle76268c52017-03-09 13:19:42 -0800666 if (destroy_app_reference_profile(packageName) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700667 res = error("Failed to destroy reference profile for " + packageName);
668 }
669 return res;
Calin Juravlecaa6b802016-03-22 14:15:52 +0000670}
671
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900672binder::Status InstalldNativeService::destroyAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700673 const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {
674 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700675 CHECK_ARGUMENT_UUID(uuid);
676 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700677 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700678
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700679 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
680 const char* pkgname = packageName.c_str();
681
Jeff Sharkey423e7462016-12-09 18:18:43 -0700682 binder::Status res = ok();
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700683 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700684 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInode);
685 if (delete_dir_contents_and_dir(path) != 0) {
686 res = error("Failed to delete " + path);
687 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700688 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700689 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700690 auto path = create_data_user_de_package_path(uuid_, userId, pkgname);
691 if (delete_dir_contents_and_dir(path) != 0) {
692 res = error("Failed to delete " + path);
693 }
Alan Stokesabc45c82020-02-14 14:36:58 +0000694 if ((flags & FLAG_CLEAR_APP_DATA_KEEP_ART_PROFILES) == 0) {
695 destroy_app_current_profiles(packageName, userId);
696 // TODO(calin): If the package is still installed by other users it's probably
697 // beneficial to keep the reference profile around.
698 // Verify if it's ok to do that.
699 destroy_app_reference_profile(packageName);
700 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700701 }
Jeff Sharkey6e175692019-05-14 14:55:33 -0600702 if (flags & FLAG_STORAGE_EXTERNAL) {
703 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
704 for (const auto& n : mStorageMounts) {
705 auto extPath = n.second;
Zim0ce832d2019-12-03 17:03:58 +0000706
707 if (android::base::GetBoolProperty(kFuseProp, false)) {
708 std::regex re("^\\/mnt\\/pass_through\\/[0-9]+\\/emulated");
709 if (std::regex_match(extPath, re)) {
710 extPath += "/" + std::to_string(userId);
711 }
712 } else {
713 if (n.first.compare(0, 14, "/mnt/media_rw/") != 0) {
714 extPath += StringPrintf("/%d", userId);
715 } else if (userId != 0) {
716 // TODO: support devices mounted under secondary users
717 continue;
718 }
Jeff Sharkey6e175692019-05-14 14:55:33 -0600719 }
Zim0ce832d2019-12-03 17:03:58 +0000720
Jeff Sharkey6e175692019-05-14 14:55:33 -0600721 auto path = StringPrintf("%s/Android/data/%s", extPath.c_str(), pkgname);
722 if (delete_dir_contents_and_dir(path, true) != 0) {
723 res = error("Failed to delete contents of " + path);
724 }
Zim0ce832d2019-12-03 17:03:58 +0000725
Jeff Sharkey6e175692019-05-14 14:55:33 -0600726 path = StringPrintf("%s/Android/media/%s", extPath.c_str(), pkgname);
727 if (delete_dir_contents_and_dir(path, true) != 0) {
728 res = error("Failed to delete contents of " + path);
729 }
730 path = StringPrintf("%s/Android/obb/%s", extPath.c_str(), pkgname);
731 if (delete_dir_contents_and_dir(path, true) != 0) {
732 res = error("Failed to delete contents of " + path);
733 }
734 }
735 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700736 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700737}
738
Jeff Sharkeye12d5962017-04-03 16:41:02 -0600739static gid_t get_cache_gid(uid_t uid) {
740 int32_t gid = multiuser_get_cache_gid(multiuser_get_user_id(uid), multiuser_get_app_id(uid));
741 return (gid != -1) ? gid : uid;
742}
743
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900744binder::Status InstalldNativeService::fixupAppData(const std::optional<std::string>& uuid,
Jeff Sharkeye12d5962017-04-03 16:41:02 -0600745 int32_t flags) {
746 ENFORCE_UID(AID_SYSTEM);
747 CHECK_ARGUMENT_UUID(uuid);
748 std::lock_guard<std::recursive_mutex> lock(mLock);
749
750 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
751 for (auto user : get_known_users(uuid_)) {
752 ATRACE_BEGIN("fixup user");
753 FTS* fts;
754 FTSENT* p;
Jeff Sharkeyd9ff77f2017-04-14 18:54:49 -0600755 auto ce_path = create_data_user_ce_path(uuid_, user);
756 auto de_path = create_data_user_de_path(uuid_, user);
757 char *argv[] = { (char*) ce_path.c_str(), (char*) de_path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -0700758 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkeye12d5962017-04-03 16:41:02 -0600759 return error("Failed to fts_open");
760 }
761 while ((p = fts_read(fts)) != nullptr) {
762 if (p->fts_info == FTS_D && p->fts_level == 1) {
763 // Track down inodes of cache directories
764 uint64_t raw = 0;
765 ino_t inode_cache = 0;
766 ino_t inode_code_cache = 0;
767 if (getxattr(p->fts_path, kXattrInodeCache, &raw, sizeof(raw)) == sizeof(raw)) {
768 inode_cache = raw;
769 }
770 if (getxattr(p->fts_path, kXattrInodeCodeCache, &raw, sizeof(raw)) == sizeof(raw)) {
771 inode_code_cache = raw;
772 }
773
774 // Figure out expected GID of each child
775 FTSENT* child = fts_children(fts, 0);
776 while (child != nullptr) {
777 if ((child->fts_statp->st_ino == inode_cache)
778 || (child->fts_statp->st_ino == inode_code_cache)
779 || !strcmp(child->fts_name, "cache")
780 || !strcmp(child->fts_name, "code_cache")) {
781 child->fts_number = get_cache_gid(p->fts_statp->st_uid);
782 } else {
783 child->fts_number = p->fts_statp->st_uid;
784 }
785 child = child->fts_link;
786 }
787 } else if (p->fts_level >= 2) {
788 if (p->fts_level > 2) {
789 // Inherit GID from parent once we're deeper into tree
790 p->fts_number = p->fts_parent->fts_number;
791 }
792
793 uid_t uid = p->fts_parent->fts_statp->st_uid;
794 gid_t cache_gid = get_cache_gid(uid);
795 gid_t expected = p->fts_number;
796 gid_t actual = p->fts_statp->st_gid;
797 if (actual == expected) {
798#if FIXUP_DEBUG
799 LOG(DEBUG) << "Ignoring " << p->fts_path << " with expected GID " << expected;
800#endif
801 if (!(flags & FLAG_FORCE)) {
802 fts_set(fts, p, FTS_SKIP);
803 }
804 } else if ((actual == uid) || (actual == cache_gid)) {
805 // Only consider fixing up when current GID belongs to app
806 if (p->fts_info != FTS_D) {
807 LOG(INFO) << "Fixing " << p->fts_path << " with unexpected GID " << actual
808 << " instead of " << expected;
809 }
810 switch (p->fts_info) {
811 case FTS_DP:
812 // If we're moving towards cache GID, we need to set S_ISGID
813 if (expected == cache_gid) {
814 if (chmod(p->fts_path, 02771) != 0) {
815 PLOG(WARNING) << "Failed to chmod " << p->fts_path;
816 }
817 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -0700818 [[fallthrough]]; // also set GID
Jeff Sharkeye12d5962017-04-03 16:41:02 -0600819 case FTS_F:
820 if (chown(p->fts_path, -1, expected) != 0) {
821 PLOG(WARNING) << "Failed to chown " << p->fts_path;
822 }
823 break;
824 case FTS_SL:
825 case FTS_SLNONE:
826 if (lchown(p->fts_path, -1, expected) != 0) {
827 PLOG(WARNING) << "Failed to chown " << p->fts_path;
828 }
829 break;
830 }
831 } else {
832 // Ignore all other GID transitions, since they're kinda shady
833 LOG(WARNING) << "Ignoring " << p->fts_path << " with unexpected GID " << actual
834 << " instead of " << expected;
Jeff Sharkey6b63b912017-09-21 15:41:37 -0600835 if (!(flags & FLAG_FORCE)) {
836 fts_set(fts, p, FTS_SKIP);
837 }
Jeff Sharkeye12d5962017-04-03 16:41:02 -0600838 }
839 }
840 }
841 fts_close(fts);
842 ATRACE_END();
843 }
844 return ok();
845}
846
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000847static int32_t copy_directory_recursive(const char* from, const char* to) {
848 char *argv[] = {
849 (char*) kCpPath,
850 (char*) "-F", /* delete any existing destination file first (--remove-destination) */
851 (char*) "-p", /* preserve timestamps, ownership, and permissions */
852 (char*) "-R", /* recurse into subdirectories (DEST must be a directory) */
853 (char*) "-P", /* Do not follow symlinks [default] */
854 (char*) "-d", /* don't dereference symlinks */
855 (char*) from,
856 (char*) to
857 };
858
859 LOG(DEBUG) << "Copying " << from << " to " << to;
Tom Cherrye79cde52019-09-25 16:51:56 -0700860 return logwrap_fork_execvp(ARRAY_SIZE(argv), argv, nullptr, false, LOG_ALOG, false, nullptr);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000861}
862
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000863binder::Status InstalldNativeService::snapshotAppData(
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900864 const std::optional<std::string>& volumeUuid,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000865 const std::string& packageName, int32_t user, int32_t snapshotId,
866 int32_t storageFlags, int64_t* _aidl_return) {
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000867 ENFORCE_UID(AID_SYSTEM);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000868 CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(volumeUuid);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000869 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
870 std::lock_guard<std::recursive_mutex> lock(mLock);
871
872 const char* volume_uuid = volumeUuid ? volumeUuid->c_str() : nullptr;
873 const char* package_name = packageName.c_str();
874
875 binder::Status res = ok();
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000876 // Default result to 0, it will be populated with inode of ce data snapshot
877 // if FLAG_STORAGE_CE has been passed.
878 if (_aidl_return != nullptr) *_aidl_return = 0;
879
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000880 bool clear_ce_on_exit = false;
881 bool clear_de_on_exit = false;
882
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000883 auto deleter = [&clear_ce_on_exit, &clear_de_on_exit, &volume_uuid, &user, &package_name,
884 &snapshotId] {
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000885 if (clear_de_on_exit) {
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000886 auto to = create_data_misc_de_rollback_package_path(volume_uuid, user, snapshotId,
887 package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000888 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
889 LOG(WARNING) << "Failed to delete app data snapshot: " << to;
890 }
891 }
892
893 if (clear_ce_on_exit) {
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000894 auto to = create_data_misc_ce_rollback_package_path(volume_uuid, user, snapshotId,
895 package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000896 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
897 LOG(WARNING) << "Failed to delete app data snapshot: " << to;
898 }
899 }
900 };
901
902 auto scope_guard = android::base::make_scope_guard(deleter);
903
904 // The app may not have any data at all, in which case it's OK to skip here.
905 auto from_ce = create_data_user_ce_package_path(volume_uuid, user, package_name);
906 if (access(from_ce.c_str(), F_OK) != 0) {
907 LOG(INFO) << "Missing source " << from_ce;
908 return ok();
909 }
910
Nikita Ioffe900b3c22019-01-23 14:32:48 +0000911 // ce_data_inode is not needed when FLAG_CLEAR_CACHE_ONLY is set.
912 binder::Status clear_cache_result = clearAppData(volumeUuid, packageName, user,
913 storageFlags | FLAG_CLEAR_CACHE_ONLY, 0);
914 if (!clear_cache_result.isOk()) {
915 // It should be fine to continue snapshot if we for some reason failed
916 // to clear cache.
917 LOG(WARNING) << "Failed to clear cache of app " << packageName;
918 }
919
920 // ce_data_inode is not needed when FLAG_CLEAR_CODE_CACHE_ONLY is set.
921 binder::Status clear_code_cache_result = clearAppData(volumeUuid, packageName, user,
922 storageFlags | FLAG_CLEAR_CODE_CACHE_ONLY, 0);
923 if (!clear_code_cache_result.isOk()) {
924 // It should be fine to continue snapshot if we for some reason failed
925 // to clear code_cache.
926 LOG(WARNING) << "Failed to clear code_cache of app " << packageName;
927 }
928
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000929 if (storageFlags & FLAG_STORAGE_DE) {
930 auto from = create_data_user_de_package_path(volume_uuid, user, package_name);
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000931 auto to = create_data_misc_de_rollback_path(volume_uuid, user, snapshotId);
932 auto rollback_package_path = create_data_misc_de_rollback_package_path(volume_uuid, user,
933 snapshotId, package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000934
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000935 int rc = create_dir_if_needed(to.c_str(), kRollbackFolderMode);
936 if (rc != 0) {
937 return error(rc, "Failed to create folder " + to);
Nikita Ioffe835ae772019-01-23 16:32:13 +0000938 }
939
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000940 rc = delete_dir_contents(rollback_package_path, true /* ignore_if_missing */);
941 if (rc != 0) {
942 return error(rc, "Failed clearing existing snapshot " + rollback_package_path);
943 }
944
945 rc = copy_directory_recursive(from.c_str(), to.c_str());
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000946 if (rc != 0) {
947 res = error(rc, "Failed copying " + from + " to " + to);
948 clear_de_on_exit = true;
949 return res;
950 }
951 }
952
953 if (storageFlags & FLAG_STORAGE_CE) {
954 auto from = create_data_user_ce_package_path(volume_uuid, user, package_name);
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000955 auto to = create_data_misc_ce_rollback_path(volume_uuid, user, snapshotId);
956 auto rollback_package_path = create_data_misc_ce_rollback_package_path(volume_uuid, user,
957 snapshotId, package_name);
Nikita Ioffe835ae772019-01-23 16:32:13 +0000958
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000959 int rc = create_dir_if_needed(to.c_str(), kRollbackFolderMode);
960 if (rc != 0) {
961 return error(rc, "Failed to create folder " + to);
Nikita Ioffe835ae772019-01-23 16:32:13 +0000962 }
963
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000964 rc = delete_dir_contents(rollback_package_path, true /* ignore_if_missing */);
965 if (rc != 0) {
966 return error(rc, "Failed clearing existing snapshot " + rollback_package_path);
967 }
968
969 rc = copy_directory_recursive(from.c_str(), to.c_str());
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000970 if (rc != 0) {
971 res = error(rc, "Failed copying " + from + " to " + to);
972 clear_ce_on_exit = true;
973 return res;
974 }
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000975 if (_aidl_return != nullptr) {
976 auto ce_snapshot_path = create_data_misc_ce_rollback_package_path(volume_uuid, user,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000977 snapshotId, package_name);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000978 rc = get_path_inode(ce_snapshot_path, reinterpret_cast<ino_t*>(_aidl_return));
979 if (rc != 0) {
980 res = error(rc, "Failed to get_path_inode for " + ce_snapshot_path);
981 clear_ce_on_exit = true;
982 return res;
983 }
984 }
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000985 }
986
987 return res;
988}
989
990binder::Status InstalldNativeService::restoreAppDataSnapshot(
Jooyung Han9fcc4ef2020-01-23 12:45:10 +0900991 const std::optional<std::string>& volumeUuid, const std::string& packageName,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +0000992 const int32_t appId, const std::string& seInfo, const int32_t user,
993 const int32_t snapshotId, int32_t storageFlags) {
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000994 ENFORCE_UID(AID_SYSTEM);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +0000995 CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(volumeUuid);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +0000996 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
997 std::lock_guard<std::recursive_mutex> lock(mLock);
998
999 const char* volume_uuid = volumeUuid ? volumeUuid->c_str() : nullptr;
1000 const char* package_name = packageName.c_str();
1001
1002 auto from_ce = create_data_misc_ce_rollback_package_path(volume_uuid,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001003 user, snapshotId, package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001004 auto from_de = create_data_misc_de_rollback_package_path(volume_uuid,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001005 user, snapshotId, package_name);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001006
1007 const bool needs_ce_rollback = (storageFlags & FLAG_STORAGE_CE) &&
1008 (access(from_ce.c_str(), F_OK) == 0);
1009 const bool needs_de_rollback = (storageFlags & FLAG_STORAGE_DE) &&
1010 (access(from_de.c_str(), F_OK) == 0);
1011
1012 if (!needs_ce_rollback && !needs_de_rollback) {
1013 return ok();
1014 }
1015
1016 // We know we're going to rollback one of the CE or DE data, so we clear
1017 // application data first. Note that it's possible that we're asked to
1018 // restore both CE & DE data but that one of the restores fail. Leaving the
1019 // app with no data in those cases is arguably better than leaving the app
1020 // with mismatched / stale data.
1021 LOG(INFO) << "Clearing app data for " << packageName << " to restore snapshot.";
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001022 // It's fine to pass 0 as ceDataInode here, because restoreAppDataSnapshot
1023 // can only be called when user unlocks the phone, meaning that CE user data
1024 // is decrypted.
1025 binder::Status res = clearAppData(volumeUuid, packageName, user, storageFlags,
1026 0 /* ceDataInode */);
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001027 if (!res.isOk()) {
1028 return res;
1029 }
1030
1031 if (needs_ce_rollback) {
1032 auto to_ce = create_data_user_ce_path(volume_uuid, user);
1033 int rc = copy_directory_recursive(from_ce.c_str(), to_ce.c_str());
1034 if (rc != 0) {
1035 res = error(rc, "Failed copying " + from_ce + " to " + to_ce);
1036 return res;
1037 }
1038 }
1039
1040 if (needs_de_rollback) {
1041 auto to_de = create_data_user_de_path(volume_uuid, user);
1042 int rc = copy_directory_recursive(from_de.c_str(), to_de.c_str());
1043 if (rc != 0) {
Nikita Ioffefd2ccd42019-01-25 11:44:36 +00001044 if (needs_ce_rollback) {
1045 auto ce_data = create_data_user_ce_package_path(volume_uuid, user, package_name);
1046 LOG(WARNING) << "de_data rollback failed. Erasing rolled back ce_data " << ce_data;
1047 if (delete_dir_contents(ce_data.c_str(), 1, nullptr) != 0) {
1048 LOG(WARNING) << "Failed to delete rolled back ce_data " << ce_data;
1049 }
1050 }
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001051 res = error(rc, "Failed copying " + from_de + " to " + to_de);
1052 return res;
1053 }
1054 }
1055
1056 // Finally, restore the SELinux label on the app data.
1057 return restoreconAppData(volumeUuid, packageName, user, storageFlags, appId, seInfo);
1058}
1059
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001060binder::Status InstalldNativeService::destroyAppDataSnapshot(
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001061 const std::optional<std::string> &volumeUuid, const std::string& packageName,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001062 const int32_t user, const int64_t ceSnapshotInode, const int32_t snapshotId,
1063 int32_t storageFlags) {
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001064 ENFORCE_UID(AID_SYSTEM);
1065 CHECK_ARGUMENT_UUID_IS_TEST_OR_NULL(volumeUuid);
1066 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
1067 std::lock_guard<std::recursive_mutex> lock(mLock);
1068
1069 const char* volume_uuid = volumeUuid ? volumeUuid->c_str() : nullptr;
1070 const char* package_name = packageName.c_str();
1071
1072 if (storageFlags & FLAG_STORAGE_DE) {
1073 auto de_snapshot_path = create_data_misc_de_rollback_package_path(volume_uuid,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001074 user, snapshotId, package_name);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001075
1076 int res = delete_dir_contents_and_dir(de_snapshot_path, true /* ignore_if_missing */);
1077 if (res != 0) {
1078 return error(res, "Failed clearing snapshot " + de_snapshot_path);
1079 }
1080 }
1081
1082 if (storageFlags & FLAG_STORAGE_CE) {
1083 auto ce_snapshot_path = create_data_misc_ce_rollback_package_path(volume_uuid,
Nikita Ioffeb68f0d12019-02-04 11:06:37 +00001084 user, snapshotId, package_name, ceSnapshotInode);
Nikita Ioffe77be2ed2019-01-25 13:54:43 +00001085 int res = delete_dir_contents_and_dir(ce_snapshot_path, true /* ignore_if_missing */);
1086 if (res != 0) {
1087 return error(res, "Failed clearing snapshot " + ce_snapshot_path);
1088 }
1089 }
1090 return ok();
1091}
1092
1093
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001094binder::Status InstalldNativeService::moveCompleteApp(const std::optional<std::string>& fromUuid,
1095 const std::optional<std::string>& toUuid, const std::string& packageName,
Jeff Sharkey0274c972016-12-06 09:32:04 -07001096 const std::string& dataAppName, int32_t appId, const std::string& seInfo,
1097 int32_t targetSdkVersion) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001098 ENFORCE_UID(AID_SYSTEM);
1099 CHECK_ARGUMENT_UUID(fromUuid);
1100 CHECK_ARGUMENT_UUID(toUuid);
1101 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001102 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey0274c972016-12-06 09:32:04 -07001103
1104 const char* from_uuid = fromUuid ? fromUuid->c_str() : nullptr;
1105 const char* to_uuid = toUuid ? toUuid->c_str() : nullptr;
1106 const char* package_name = packageName.c_str();
1107 const char* data_app_name = dataAppName.c_str();
Jeff Sharkey0274c972016-12-06 09:32:04 -07001108
Jeff Sharkey423e7462016-12-09 18:18:43 -07001109 binder::Status res = ok();
Jeff Sharkeye3637242015-04-08 20:56:42 -07001110 std::vector<userid_t> users = get_known_users(from_uuid);
1111
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001112 // Copy app
1113 {
Jeff Sharkey51c94492016-05-10 17:46:39 -06001114 auto from = create_data_app_package_path(from_uuid, data_app_name);
1115 auto to = create_data_app_package_path(to_uuid, data_app_name);
1116 auto to_parent = create_data_app_path(to_uuid);
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001117
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001118 int rc = copy_directory_recursive(from.c_str(), to_parent.c_str());
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001119 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001120 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001121 goto fail;
1122 }
1123
1124 if (selinux_android_restorecon(to.c_str(), SELINUX_ANDROID_RESTORECON_RECURSE) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001125 res = error("Failed to restorecon " + to);
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001126 goto fail;
1127 }
1128 }
1129
1130 // Copy private data for all known users
Jeff Sharkeye3637242015-04-08 20:56:42 -07001131 for (auto user : users) {
Jeff Sharkeye3637242015-04-08 20:56:42 -07001132
1133 // Data source may not exist for all users; that's okay
Jeff Sharkey51c94492016-05-10 17:46:39 -06001134 auto from_ce = create_data_user_ce_package_path(from_uuid, user, package_name);
1135 if (access(from_ce.c_str(), F_OK) != 0) {
1136 LOG(INFO) << "Missing source " << from_ce;
Jeff Sharkeye3637242015-04-08 20:56:42 -07001137 continue;
1138 }
1139
Jeff Sharkey0274c972016-12-06 09:32:04 -07001140 if (!createAppData(toUuid, packageName, user, FLAG_STORAGE_CE | FLAG_STORAGE_DE, appId,
Jeff Sharkey36a900a2016-12-19 16:39:18 -07001141 seInfo, targetSdkVersion, nullptr).isOk()) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001142 res = error("Failed to create package target");
Jeff Sharkeye3637242015-04-08 20:56:42 -07001143 goto fail;
1144 }
1145
Jeff Sharkey51c94492016-05-10 17:46:39 -06001146 {
1147 auto from = create_data_user_de_package_path(from_uuid, user, package_name);
1148 auto to = create_data_user_de_path(to_uuid, user);
Jeff Sharkeye3637242015-04-08 20:56:42 -07001149
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001150 int rc = copy_directory_recursive(from.c_str(), to.c_str());
Jeff Sharkey51c94492016-05-10 17:46:39 -06001151 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001152 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkey51c94492016-05-10 17:46:39 -06001153 goto fail;
1154 }
1155 }
1156 {
1157 auto from = create_data_user_ce_package_path(from_uuid, user, package_name);
1158 auto to = create_data_user_ce_path(to_uuid, user);
Jeff Sharkey51c94492016-05-10 17:46:39 -06001159
Narayan Kamathe63ca7d2019-01-14 15:21:52 +00001160 int rc = copy_directory_recursive(from.c_str(), to.c_str());
Jeff Sharkey51c94492016-05-10 17:46:39 -06001161 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001162 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkey51c94492016-05-10 17:46:39 -06001163 goto fail;
1164 }
Jeff Sharkeye3637242015-04-08 20:56:42 -07001165 }
1166
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001167 if (!restoreconAppData(toUuid, packageName, user, FLAG_STORAGE_CE | FLAG_STORAGE_DE,
1168 appId, seInfo).isOk()) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001169 res = error("Failed to restorecon");
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07001170 goto fail;
1171 }
Jeff Sharkeye3637242015-04-08 20:56:42 -07001172 }
1173
Jeff Sharkey31f08982015-07-07 13:31:37 -07001174 // We let the framework scan the new location and persist that before
1175 // deleting the data in the old location; this ordering ensures that
1176 // we can recover from things like battery pulls.
Jeff Sharkey423e7462016-12-09 18:18:43 -07001177 return ok();
Jeff Sharkeye3637242015-04-08 20:56:42 -07001178
1179fail:
1180 // Nuke everything we might have already copied
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001181 {
Jeff Sharkey51c94492016-05-10 17:46:39 -06001182 auto to = create_data_app_package_path(to_uuid, data_app_name);
Yi Konge7bf3772018-07-17 16:16:24 -07001183 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
Jeff Sharkeyd7921182015-04-30 15:58:19 -07001184 LOG(WARNING) << "Failed to rollback " << to;
1185 }
1186 }
Jeff Sharkeye3637242015-04-08 20:56:42 -07001187 for (auto user : users) {
Jeff Sharkey51c94492016-05-10 17:46:39 -06001188 {
1189 auto to = create_data_user_de_package_path(to_uuid, user, package_name);
Yi Konge7bf3772018-07-17 16:16:24 -07001190 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
Jeff Sharkey51c94492016-05-10 17:46:39 -06001191 LOG(WARNING) << "Failed to rollback " << to;
1192 }
1193 }
1194 {
1195 auto to = create_data_user_ce_package_path(to_uuid, user, package_name);
Yi Konge7bf3772018-07-17 16:16:24 -07001196 if (delete_dir_contents(to.c_str(), 1, nullptr) != 0) {
Jeff Sharkey51c94492016-05-10 17:46:39 -06001197 LOG(WARNING) << "Failed to rollback " << to;
1198 }
Jeff Sharkeye3637242015-04-08 20:56:42 -07001199 }
1200 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07001201 return res;
Jeff Sharkeye3637242015-04-08 20:56:42 -07001202}
1203
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001204binder::Status InstalldNativeService::createUserData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001205 int32_t userId, int32_t userSerial ATTRIBUTE_UNUSED, int32_t flags) {
1206 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001207 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001208 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001209
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001210 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey379a12b2016-04-14 20:45:06 -06001211 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001212 if (uuid_ == nullptr) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001213 if (ensure_config_user_dirs(userId) != 0) {
Jeff Sharkey7be5ead2016-12-12 13:18:46 -07001214 return error(StringPrintf("Failed to ensure dirs for %d", userId));
Jeff Sharkey423e7462016-12-09 18:18:43 -07001215 }
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001216 }
1217 }
Jeff Sharkeye59c85c2017-04-02 21:53:14 -06001218
Jeff Sharkey7be5ead2016-12-12 13:18:46 -07001219 return ok();
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001220}
1221
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001222binder::Status InstalldNativeService::destroyUserData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001223 int32_t userId, int32_t flags) {
1224 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001225 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001226 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001227
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001228 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey423e7462016-12-09 18:18:43 -07001229 binder::Status res = ok();
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001230 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001231 auto path = create_data_user_de_path(uuid_, userId);
1232 if (delete_dir_contents_and_dir(path, true) != 0) {
1233 res = error("Failed to delete " + path);
1234 }
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07001235 if (uuid_ == nullptr) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001236 path = create_data_misc_legacy_path(userId);
1237 if (delete_dir_contents_and_dir(path, true) != 0) {
1238 res = error("Failed to delete " + path);
1239 }
Calin Juravle114f0812017-03-08 19:05:07 -08001240 path = create_primary_cur_profile_dir_path(userId);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001241 if (delete_dir_contents_and_dir(path, true) != 0) {
1242 res = error("Failed to delete " + path);
1243 }
Jeff Sharkey41ea4242015-04-09 11:34:03 -07001244 }
Robin Lee095c7632014-04-25 15:05:19 +01001245 }
Jeff Sharkey379a12b2016-04-14 20:45:06 -06001246 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001247 auto path = create_data_user_ce_path(uuid_, userId);
1248 if (delete_dir_contents_and_dir(path, true) != 0) {
1249 res = error("Failed to delete " + path);
1250 }
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001251 path = findDataMediaPath(uuid, userId);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001252 if (delete_dir_contents_and_dir(path, true) != 0) {
1253 res = error("Failed to delete " + path);
1254 }
Jeff Sharkey379a12b2016-04-14 20:45:06 -06001255 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07001256 return res;
Robin Lee095c7632014-04-25 15:05:19 +01001257}
1258
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001259binder::Status InstalldNativeService::freeCache(const std::optional<std::string>& uuid,
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001260 int64_t targetFreeBytes, int64_t cacheReservedBytes, int32_t flags) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001261 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001262 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001263 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001264
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001265 auto uuidString = uuid.value_or("");
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001266 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001267 auto data_path = create_data_path(uuid_);
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001268 auto noop = (flags & FLAG_FREE_CACHE_NOOP);
Jeff Sharkey41ea4242015-04-09 11:34:03 -07001269
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001270 int64_t free = data_disk_free(data_path);
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001271 if (free < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001272 return error("Failed to determine free space for " + data_path);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001273 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001274
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001275 int64_t cleared = 0;
1276 int64_t needed = targetFreeBytes - free;
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001277 LOG(DEBUG) << "Device " << data_path << " has " << free << " free; requested "
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001278 << targetFreeBytes << "; needed " << needed;
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001279
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001280 if (free >= targetFreeBytes) {
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001281 return ok();
1282 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001283
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001284 if (flags & FLAG_FREE_CACHE_V2) {
1285 // This new cache strategy fairly removes files from UIDs by deleting
1286 // files from the UIDs which are most over their allocated quota
1287
1288 // 1. Create trackers for every known UID
1289 ATRACE_BEGIN("create");
1290 std::unordered_map<uid_t, std::shared_ptr<CacheTracker>> trackers;
1291 for (auto user : get_known_users(uuid_)) {
1292 FTS *fts;
1293 FTSENT *p;
Jeff Sharkeyd9ff77f2017-04-14 18:54:49 -06001294 auto ce_path = create_data_user_ce_path(uuid_, user);
1295 auto de_path = create_data_user_de_path(uuid_, user);
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001296 auto media_path = findDataMediaPath(uuid, user) + "/Android/data/";
1297 char *argv[] = { (char*) ce_path.c_str(), (char*) de_path.c_str(),
1298 (char*) media_path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -07001299 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001300 return error("Failed to fts_open");
1301 }
Yi Konge7bf3772018-07-17 16:16:24 -07001302 while ((p = fts_read(fts)) != nullptr) {
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001303 if (p->fts_info == FTS_D && p->fts_level == 1) {
1304 uid_t uid = p->fts_statp->st_uid;
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001305 if (multiuser_get_app_id(uid) == AID_MEDIA_RW) {
1306 uid = (multiuser_get_app_id(p->fts_statp->st_gid) - AID_EXT_GID_START)
1307 + AID_APP_START;
1308 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001309 auto search = trackers.find(uid);
1310 if (search != trackers.end()) {
1311 search->second->addDataPath(p->fts_path);
1312 } else {
1313 auto tracker = std::shared_ptr<CacheTracker>(new CacheTracker(
Risan5f308262018-10-26 12:06:58 -06001314 multiuser_get_user_id(uid), multiuser_get_app_id(uid), uuidString));
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001315 tracker->addDataPath(p->fts_path);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001316 {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06001317 std::lock_guard<std::recursive_mutex> lock(mQuotasLock);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001318 tracker->cacheQuota = mCacheQuotas[uid];
1319 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001320 if (tracker->cacheQuota == 0) {
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001321#if MEASURE_DEBUG
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001322 LOG(WARNING) << "UID " << uid << " has no cache quota; assuming 64MB";
Jeff Sharkeyed909ae2017-03-22 21:27:40 -06001323#endif
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001324 tracker->cacheQuota = 67108864;
1325 }
1326 trackers[uid] = tracker;
1327 }
1328 fts_set(fts, p, FTS_SKIP);
1329 }
1330 }
1331 fts_close(fts);
1332 }
1333 ATRACE_END();
1334
1335 // 2. Populate tracker stats and insert into priority queue
1336 ATRACE_BEGIN("populate");
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001337 int64_t cacheTotal = 0;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001338 auto cmp = [](std::shared_ptr<CacheTracker> left, std::shared_ptr<CacheTracker> right) {
1339 return (left->getCacheRatio() < right->getCacheRatio());
1340 };
1341 std::priority_queue<std::shared_ptr<CacheTracker>,
1342 std::vector<std::shared_ptr<CacheTracker>>, decltype(cmp)> queue(cmp);
1343 for (const auto& it : trackers) {
1344 it.second->loadStats();
1345 queue.push(it.second);
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001346 cacheTotal += it.second->cacheUsed;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001347 }
1348 ATRACE_END();
1349
1350 // 3. Bounce across the queue, freeing items from whichever tracker is
1351 // the most over their assigned quota
1352 ATRACE_BEGIN("bounce");
1353 std::shared_ptr<CacheTracker> active;
1354 while (active || !queue.empty()) {
Jeff Sharkey871a8f22017-02-21 18:30:28 -07001355 // Only look at apps under quota when explicitly requested
1356 if (active && (active->getCacheRatio() < 10000)
1357 && !(flags & FLAG_FREE_CACHE_V2_DEFY_QUOTA)) {
1358 LOG(DEBUG) << "Active ratio " << active->getCacheRatio()
1359 << " isn't over quota, and defy not requested";
1360 break;
1361 }
1362
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001363 // Only keep clearing when we haven't pushed into reserved area
1364 if (cacheReservedBytes > 0 && cleared >= (cacheTotal - cacheReservedBytes)) {
1365 LOG(DEBUG) << "Refusing to clear cached data in reserved space";
1366 break;
1367 }
1368
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001369 // Find the best tracker to work with; this might involve swapping
1370 // if the active tracker is no longer the most over quota
1371 bool nextBetter = active && !queue.empty()
1372 && active->getCacheRatio() < queue.top()->getCacheRatio();
1373 if (!active || nextBetter) {
1374 if (active) {
1375 // Current tracker still has items, so we'll consider it
1376 // again later once it bubbles up to surface
1377 queue.push(active);
1378 }
1379 active = queue.top(); queue.pop();
1380 active->ensureItems();
1381 continue;
1382 }
1383
1384 // If no items remain, go find another tracker
1385 if (active->items.empty()) {
1386 active = nullptr;
1387 continue;
1388 } else {
1389 auto item = active->items.back();
1390 active->items.pop_back();
1391
1392 LOG(DEBUG) << "Purging " << item->toString() << " from " << active->toString();
1393 if (!noop) {
1394 item->purge();
1395 }
1396 active->cacheUsed -= item->size;
1397 needed -= item->size;
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001398 cleared += item->size;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001399 }
1400
1401 // Verify that we're actually done before bailing, since sneaky
1402 // apps might be using hardlinks
1403 if (needed <= 0) {
1404 free = data_disk_free(data_path);
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001405 needed = targetFreeBytes - free;
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001406 if (needed <= 0) {
1407 break;
1408 } else {
1409 LOG(WARNING) << "Expected to be done but still need " << needed;
1410 }
1411 }
1412 }
1413 ATRACE_END();
1414
1415 } else {
Jeff Sharkey1cb4aaf2017-03-27 16:41:06 -06001416 return error("Legacy cache logic no longer supported");
Mike Lockwood94afecf2012-10-24 10:45:23 -07001417 }
1418
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001419 free = data_disk_free(data_path);
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001420 if (free >= targetFreeBytes) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001421 return ok();
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001422 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001423 return error(StringPrintf("Failed to free up %" PRId64 " on %s; final free space %" PRId64,
Jeff Sharkey60f8a532017-05-30 14:38:42 -06001424 targetFreeBytes, data_path.c_str(), free));
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001425 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001426}
1427
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001428binder::Status InstalldNativeService::rmdex(const std::string& codePath,
1429 const std::string& instructionSet) {
1430 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07001431 CHECK_ARGUMENT_PATH(codePath);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001432 std::lock_guard<std::recursive_mutex> lock(mLock);
1433
Mike Lockwood94afecf2012-10-24 10:45:23 -07001434 char dex_path[PKG_PATH_MAX];
1435
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001436 const char* path = codePath.c_str();
1437 const char* instruction_set = instructionSet.c_str();
1438
Jeff Sharkey770180a2014-09-08 17:14:26 -07001439 if (validate_apk_path(path) && validate_system_app_path(path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001440 return error("Invalid path " + codePath);
Jeff Sharkey770180a2014-09-08 17:14:26 -07001441 }
1442
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001443 if (!create_cache_path(dex_path, path, instruction_set)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001444 return error("Failed to create cache path for " + codePath);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001445 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001446
1447 ALOGV("unlink %s\n", dex_path);
1448 if (unlink(dex_path) < 0) {
Calin Juravle249f2d32017-05-03 17:22:27 -07001449 // It's ok if we don't have a dalvik cache path. Report error only when the path exists
1450 // but could not be unlinked.
1451 if (errno != ENOENT) {
1452 return error(StringPrintf("Failed to unlink %s", dex_path));
1453 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001454 }
Calin Juravle249f2d32017-05-03 17:22:27 -07001455 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001456}
1457
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001458struct stats {
1459 int64_t codeSize;
1460 int64_t dataSize;
1461 int64_t cacheSize;
1462};
1463
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001464#if MEASURE_DEBUG
1465static std::string toString(std::vector<int64_t> values) {
1466 std::stringstream res;
1467 res << "[";
1468 for (size_t i = 0; i < values.size(); i++) {
1469 res << values[i];
1470 if (i < values.size() - 1) {
1471 res << ",";
1472 }
1473 }
1474 res << "]";
1475 return res.str();
1476}
1477#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001478
Risan5f308262018-10-26 12:06:58 -06001479static void collectQuotaStats(const std::string& uuid, int32_t userId,
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001480 int32_t appId, struct stats* stats, struct stats* extStats) {
Risan5f308262018-10-26 12:06:58 -06001481 int64_t space;
Martijn Coenen771cc342020-02-19 23:26:56 +01001482 uid_t uid = multiuser_get_uid(userId, appId);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001483 if (stats != nullptr) {
Risan5f308262018-10-26 12:06:58 -06001484 if ((space = GetOccupiedSpaceForUid(uuid, uid)) != -1) {
1485 stats->dataSize += space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001486 }
1487
1488 int cacheGid = multiuser_get_cache_gid(userId, appId);
1489 if (cacheGid != -1) {
Risan5f308262018-10-26 12:06:58 -06001490 if ((space = GetOccupiedSpaceForGid(uuid, cacheGid)) != -1) {
1491 stats->cacheSize += space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001492 }
1493 }
1494
1495 int sharedGid = multiuser_get_shared_gid(0, appId);
1496 if (sharedGid != -1) {
Risan5f308262018-10-26 12:06:58 -06001497 if ((space = GetOccupiedSpaceForGid(uuid, sharedGid)) != -1) {
1498 stats->codeSize += space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001499 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001500 }
1501 }
1502
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001503 if (extStats != nullptr) {
Martijn Coenen771cc342020-02-19 23:26:56 +01001504 static const bool supportsSdCardFs = supports_sdcardfs();
1505 space = get_occupied_app_space_external(uuid, userId, appId);
1506
1507 if (space != -1) {
1508 extStats->dataSize += space;
1509 if (!supportsSdCardFs && stats != nullptr) {
1510 // On devices without sdcardfs, if internal and external are on
1511 // the same volume, a uid such as u0_a123 is used for
1512 // application dirs on both internal and external storage;
1513 // therefore, substract that amount from internal to make sure
1514 // we don't count it double.
1515 stats->dataSize -= space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001516 }
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001517 }
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001518
Martijn Coenen771cc342020-02-19 23:26:56 +01001519 space = get_occupied_app_cache_space_external(uuid, userId, appId);
1520 if (space != -1) {
1521 extStats->dataSize += space; // cache counts for "data"
1522 extStats->cacheSize += space;
1523 if (!supportsSdCardFs && stats != nullptr) {
1524 // On devices without sdcardfs, if internal and external are on
1525 // the same volume, a uid such as u0_a123 is used for both
1526 // internal and external storage; therefore, substract that
1527 // amount from internal to make sure we don't count it double.
1528 stats->dataSize -= space;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001529 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001530 }
Martijn Coenen771cc342020-02-19 23:26:56 +01001531
1532 if (!supportsSdCardFs && stats != nullptr) {
1533 // On devices without sdcardfs, the UID of OBBs on external storage
1534 // matches the regular app UID (eg u0_a123); therefore, to avoid
1535 // OBBs being include in stats->dataSize, compute the OBB size for
1536 // this app, and substract it from the size reported on internal
1537 // storage
1538 long obbProjectId = uid - AID_APP_START + PROJECT_ID_EXT_OBB_START;
1539 int64_t appObbSize = GetOccupiedSpaceForProjectId(uuid, obbProjectId);
1540 stats->dataSize -= appObbSize;
1541 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001542 }
1543}
1544
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001545static void collectManualStats(const std::string& path, struct stats* stats) {
Mike Lockwood94afecf2012-10-24 10:45:23 -07001546 DIR *d;
1547 int dfd;
1548 struct dirent *de;
1549 struct stat s;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001550
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001551 d = opendir(path.c_str());
1552 if (d == nullptr) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001553 if (errno != ENOENT) {
1554 PLOG(WARNING) << "Failed to open " << path;
1555 }
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001556 return;
1557 }
1558 dfd = dirfd(d);
1559 while ((de = readdir(d))) {
1560 const char *name = de->d_name;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001561
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001562 int64_t size = 0;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001563 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001564 size = s.st_blocks * 512;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001565 }
1566
1567 if (de->d_type == DT_DIR) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001568 if (!strcmp(name, ".")) {
1569 // Don't recurse, but still count node size
1570 } else if (!strcmp(name, "..")) {
1571 // Don't recurse or count node size
1572 continue;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001573 } else {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001574 // Measure all children nodes
1575 size = 0;
1576 calculate_tree_size(StringPrintf("%s/%s", path.c_str(), name), &size);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001577 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001578
1579 if (!strcmp(name, "cache") || !strcmp(name, "code_cache")) {
1580 stats->cacheSize += size;
1581 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001582 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001583
1584 // Legacy symlink isn't owned by app
1585 if (de->d_type == DT_LNK && !strcmp(name, "lib")) {
1586 continue;
1587 }
1588
1589 // Everything found inside is considered data
1590 stats->dataSize += size;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001591 }
1592 closedir(d);
1593}
1594
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001595static void collectManualStatsForUser(const std::string& path, struct stats* stats,
1596 bool exclude_apps = false) {
1597 DIR *d;
1598 int dfd;
1599 struct dirent *de;
1600 struct stat s;
1601
1602 d = opendir(path.c_str());
1603 if (d == nullptr) {
1604 if (errno != ENOENT) {
1605 PLOG(WARNING) << "Failed to open " << path;
1606 }
1607 return;
1608 }
1609 dfd = dirfd(d);
1610 while ((de = readdir(d))) {
1611 if (de->d_type == DT_DIR) {
1612 const char *name = de->d_name;
1613 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) != 0) {
1614 continue;
1615 }
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001616 int32_t user_uid = multiuser_get_app_id(s.st_uid);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001617 if (!strcmp(name, ".") || !strcmp(name, "..")) {
1618 continue;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001619 } else if (exclude_apps && (user_uid >= AID_APP_START && user_uid <= AID_APP_END)) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001620 continue;
1621 } else {
1622 collectManualStats(StringPrintf("%s/%s", path.c_str(), name), stats);
1623 }
1624 }
1625 }
1626 closedir(d);
1627}
1628
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001629static void collectManualExternalStatsForUser(const std::string& path, struct stats* stats) {
1630 FTS *fts;
1631 FTSENT *p;
1632 char *argv[] = { (char*) path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -07001633 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001634 PLOG(ERROR) << "Failed to fts_open " << path;
1635 return;
1636 }
Yi Konge7bf3772018-07-17 16:16:24 -07001637 while ((p = fts_read(fts)) != nullptr) {
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07001638 p->fts_number = p->fts_parent->fts_number;
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001639 switch (p->fts_info) {
1640 case FTS_D:
1641 if (p->fts_level == 4
1642 && !strcmp(p->fts_name, "cache")
1643 && !strcmp(p->fts_parent->fts_parent->fts_name, "data")
1644 && !strcmp(p->fts_parent->fts_parent->fts_parent->fts_name, "Android")) {
1645 p->fts_number = 1;
1646 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -07001647 [[fallthrough]]; // to count the directory
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001648 case FTS_DEFAULT:
1649 case FTS_F:
1650 case FTS_SL:
1651 case FTS_SLNONE:
1652 int64_t size = (p->fts_statp->st_blocks * 512);
1653 if (p->fts_number == 1) {
1654 stats->cacheSize += size;
1655 }
1656 stats->dataSize += size;
1657 break;
1658 }
1659 }
1660 fts_close(fts);
1661}
1662
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001663binder::Status InstalldNativeService::getAppSize(const std::optional<std::string>& uuid,
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001664 const std::vector<std::string>& packageNames, int32_t userId, int32_t flags,
1665 int32_t appId, const std::vector<int64_t>& ceDataInodes,
1666 const std::vector<std::string>& codePaths, std::vector<int64_t>* _aidl_return) {
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001667 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001668 CHECK_ARGUMENT_UUID(uuid);
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07001669 for (const auto& packageName : packageNames) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001670 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
1671 }
Jeff Sharkey53594302018-02-24 18:59:39 -07001672 for (const auto& codePath : codePaths) {
1673 CHECK_ARGUMENT_PATH(codePath);
1674 }
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001675 // NOTE: Locking is relaxed on this method, since it's limited to
1676 // read-only measurements without mutation.
Jeff Sharkey423e7462016-12-09 18:18:43 -07001677
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001678 // When modifying this logic, always verify using tests:
1679 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetAppSize
1680
1681#if MEASURE_DEBUG
1682 LOG(INFO) << "Measuring user " << userId << " app " << appId;
1683#endif
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001684
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001685 // Here's a summary of the common storage locations across the platform,
1686 // and how they're each tagged:
1687 //
1688 // /data/app/com.example UID system
1689 // /data/app/com.example/oat UID system
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001690 // /data/user/0/com.example UID u0_a10 GID u0_a10
1691 // /data/user/0/com.example/cache UID u0_a10 GID u0_a10_cache
1692 // /data/media/0/foo.txt UID u0_media_rw
1693 // /data/media/0/bar.jpg UID u0_media_rw GID u0_media_image
1694 // /data/media/0/Android/data/com.example UID u0_media_rw GID u0_a10_ext
1695 // /data/media/0/Android/data/com.example/cache UID u0_media_rw GID u0_a10_ext_cache
1696 // /data/media/obb/com.example UID system
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001697
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001698 struct stats stats;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001699 struct stats extStats;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001700 memset(&stats, 0, sizeof(stats));
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001701 memset(&extStats, 0, sizeof(extStats));
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001702
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001703 auto uuidString = uuid.value_or("");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001704 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001705
Risan5f308262018-10-26 12:06:58 -06001706 if (!IsQuotaSupported(uuidString)) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -07001707 flags &= ~FLAG_USE_QUOTA;
1708 }
1709
Jeff Sharkey466459b2017-01-17 15:25:01 -07001710 ATRACE_BEGIN("obb");
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07001711 for (const auto& packageName : packageNames) {
Jeff Sharkey6d775c52019-03-22 13:46:20 -06001712 auto obbCodePath = create_data_media_package_path(uuid_, userId,
1713 "obb", packageName.c_str());
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001714 calculate_tree_size(obbCodePath, &extStats.codeSize);
1715 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001716 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001717
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001718 if (flags & FLAG_USE_QUOTA && appId >= AID_APP_START) {
Jeff Sharkey466459b2017-01-17 15:25:01 -07001719 ATRACE_BEGIN("code");
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07001720 for (const auto& codePath : codePaths) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001721 calculate_tree_size(codePath, &stats.codeSize, -1,
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001722 multiuser_get_shared_gid(0, appId));
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001723 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001724 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001725
Jeff Sharkey466459b2017-01-17 15:25:01 -07001726 ATRACE_BEGIN("quota");
Risan5f308262018-10-26 12:06:58 -06001727 collectQuotaStats(uuidString, userId, appId, &stats, &extStats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001728 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001729 } else {
Jeff Sharkey466459b2017-01-17 15:25:01 -07001730 ATRACE_BEGIN("code");
Chih-Hung Hsiehcb057c22017-08-03 15:48:25 -07001731 for (const auto& codePath : codePaths) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001732 calculate_tree_size(codePath, &stats.codeSize);
1733 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001734 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001735
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001736 for (size_t i = 0; i < packageNames.size(); i++) {
1737 const char* pkgname = packageNames[i].c_str();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001738
Jeff Sharkey466459b2017-01-17 15:25:01 -07001739 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001740 auto cePath = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInodes[i]);
1741 collectManualStats(cePath, &stats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001742 auto dePath = create_data_user_de_package_path(uuid_, userId, pkgname);
1743 collectManualStats(dePath, &stats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001744 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001745
Jeff Sharkey06a61842017-04-15 12:03:31 -06001746 if (!uuid) {
1747 ATRACE_BEGIN("profiles");
1748 calculate_tree_size(
1749 create_primary_current_profile_package_dir_path(userId, pkgname),
1750 &stats.dataSize);
1751 calculate_tree_size(
1752 create_primary_reference_profile_package_dir_path(pkgname),
1753 &stats.codeSize);
1754 ATRACE_END();
1755 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001756
Jeff Sharkey466459b2017-01-17 15:25:01 -07001757 ATRACE_BEGIN("external");
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07001758 auto extPath = create_data_media_package_path(uuid_, userId, "data", pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001759 collectManualStats(extPath, &extStats);
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07001760 auto mediaPath = create_data_media_package_path(uuid_, userId, "media", pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001761 calculate_tree_size(mediaPath, &extStats.dataSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001762 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001763 }
1764
Jeff Sharkey06a61842017-04-15 12:03:31 -06001765 if (!uuid) {
1766 ATRACE_BEGIN("dalvik");
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001767 int32_t sharedGid = multiuser_get_shared_gid(0, appId);
Jeff Sharkey06a61842017-04-15 12:03:31 -06001768 if (sharedGid != -1) {
1769 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
1770 sharedGid, -1);
1771 }
1772 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001773 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001774 }
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001775
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001776 std::vector<int64_t> ret;
1777 ret.push_back(stats.codeSize);
1778 ret.push_back(stats.dataSize);
1779 ret.push_back(stats.cacheSize);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001780 ret.push_back(extStats.codeSize);
1781 ret.push_back(extStats.dataSize);
1782 ret.push_back(extStats.cacheSize);
1783#if MEASURE_DEBUG
1784 LOG(DEBUG) << "Final result " << toString(ret);
1785#endif
1786 *_aidl_return = ret;
1787 return ok();
1788}
1789
Martijn Coenen771cc342020-02-19 23:26:56 +01001790struct external_sizes {
1791 int64_t audioSize;
1792 int64_t videoSize;
1793 int64_t imageSize;
1794 int64_t totalSize; // excludes OBBs (Android/obb), but includes app data + cache
1795 int64_t obbSize;
1796};
1797
1798#define PER_USER_RANGE 100000
1799
1800static long getProjectIdForUser(int userId, long projectId) {
1801 return userId * PER_USER_RANGE + projectId;
1802}
1803
1804static external_sizes getExternalSizesForUserWithQuota(const std::string& uuid, int32_t userId, const std::vector<int32_t>& appIds) {
1805 struct external_sizes sizes = {};
1806 int64_t space;
1807
1808 if (supports_sdcardfs()) {
1809 uid_t uid = multiuser_get_uid(userId, AID_MEDIA_RW);
1810 if ((space = GetOccupiedSpaceForUid(uuid, uid)) != -1) {
1811 sizes.totalSize = space;
1812 }
1813
1814 gid_t audioGid = multiuser_get_uid(userId, AID_MEDIA_AUDIO);
1815 if ((space = GetOccupiedSpaceForGid(uuid, audioGid)) != -1) {
1816 sizes.audioSize = space;
1817 }
1818
1819 gid_t videoGid = multiuser_get_uid(userId, AID_MEDIA_VIDEO);
1820 if ((space = GetOccupiedSpaceForGid(uuid, videoGid)) != -1) {
1821 sizes.videoSize = space;
1822 }
1823
1824 gid_t imageGid = multiuser_get_uid(userId, AID_MEDIA_IMAGE);
1825 if ((space = GetOccupiedSpaceForGid(uuid, imageGid)) != -1) {
1826 sizes.imageSize = space;
1827 }
1828
1829 if ((space = GetOccupiedSpaceForGid(uuid, AID_MEDIA_OBB)) != -1) {
1830 sizes.obbSize = space;
1831 }
1832 } else {
1833 int64_t totalSize = 0;
1834 long defaultProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_DEFAULT);
1835 if ((space = GetOccupiedSpaceForProjectId(uuid, defaultProjectId)) != -1) {
1836 // This is all files that are not audio/video/images, excluding
1837 // OBBs and app-private data
1838 totalSize += space;
1839 }
1840
1841 long audioProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_MEDIA_AUDIO);
1842 if ((space = GetOccupiedSpaceForProjectId(uuid, audioProjectId)) != -1) {
1843 sizes.audioSize = space;
1844 totalSize += space;
1845 }
1846
1847 long videoProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_MEDIA_VIDEO);
1848 if ((space = GetOccupiedSpaceForProjectId(uuid, videoProjectId)) != -1) {
1849 sizes.videoSize = space;
1850 totalSize += space;
1851 }
1852
1853 long imageProjectId = getProjectIdForUser(userId, PROJECT_ID_EXT_MEDIA_IMAGE);
1854 if ((space = GetOccupiedSpaceForProjectId(uuid, imageProjectId)) != -1) {
1855 sizes.imageSize = space;
1856 totalSize += space;
1857 }
1858
1859 int64_t totalAppDataSize = 0;
1860 int64_t totalAppCacheSize = 0;
1861 int64_t totalAppObbSize = 0;
1862 for (auto appId : appIds) {
1863 if (appId >= AID_APP_START) {
1864 // App data
1865 uid_t uid = multiuser_get_uid(userId, appId);
1866 long projectId = uid - AID_APP_START + PROJECT_ID_EXT_DATA_START;
1867 totalAppDataSize += GetOccupiedSpaceForProjectId(uuid, projectId);
1868
1869 // App cache
1870 long cacheProjectId = uid - AID_APP_START + PROJECT_ID_EXT_CACHE_START;
1871 totalAppCacheSize += GetOccupiedSpaceForProjectId(uuid, cacheProjectId);
1872
1873 // App OBBs
1874 long obbProjectId = uid - AID_APP_START + PROJECT_ID_EXT_OBB_START;
1875 totalAppObbSize += GetOccupiedSpaceForProjectId(uuid, obbProjectId);
1876 }
1877 }
1878 // Total size should include app data + cache
1879 totalSize += totalAppDataSize;
1880 totalSize += totalAppCacheSize;
1881 sizes.totalSize = totalSize;
1882
1883 // Only OBB is separate
1884 sizes.obbSize = totalAppObbSize;
1885 }
1886
1887 return sizes;
1888}
1889
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001890binder::Status InstalldNativeService::getUserSize(const std::optional<std::string>& uuid,
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001891 int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,
1892 std::vector<int64_t>* _aidl_return) {
1893 ENFORCE_UID(AID_SYSTEM);
1894 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001895 // NOTE: Locking is relaxed on this method, since it's limited to
1896 // read-only measurements without mutation.
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001897
1898 // When modifying this logic, always verify using tests:
1899 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetUserSize
1900
1901#if MEASURE_DEBUG
1902 LOG(INFO) << "Measuring user " << userId;
1903#endif
1904
1905 struct stats stats;
1906 struct stats extStats;
1907 memset(&stats, 0, sizeof(stats));
1908 memset(&extStats, 0, sizeof(extStats));
1909
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09001910 auto uuidString = uuid.value_or("");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001911 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
1912
Risan5f308262018-10-26 12:06:58 -06001913 if (!IsQuotaSupported(uuidString)) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -07001914 flags &= ~FLAG_USE_QUOTA;
1915 }
1916
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001917 if (flags & FLAG_USE_QUOTA) {
Jeff Sharkey466459b2017-01-17 15:25:01 -07001918 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001919 calculate_tree_size(create_data_app_path(uuid_), &stats.codeSize, -1, -1, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001920 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001921
Jeff Sharkey466459b2017-01-17 15:25:01 -07001922 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001923 auto cePath = create_data_user_ce_path(uuid_, userId);
1924 collectManualStatsForUser(cePath, &stats, true);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001925 auto dePath = create_data_user_de_path(uuid_, userId);
1926 collectManualStatsForUser(dePath, &stats, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001927 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001928
Jeff Sharkey06a61842017-04-15 12:03:31 -06001929 if (!uuid) {
1930 ATRACE_BEGIN("profile");
1931 auto userProfilePath = create_primary_cur_profile_dir_path(userId);
1932 calculate_tree_size(userProfilePath, &stats.dataSize, -1, -1, true);
1933 auto refProfilePath = create_primary_ref_profile_dir_path();
1934 calculate_tree_size(refProfilePath, &stats.codeSize, -1, -1, true);
1935 ATRACE_END();
1936 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001937
Jeff Sharkey466459b2017-01-17 15:25:01 -07001938 ATRACE_BEGIN("external");
Martijn Coenen771cc342020-02-19 23:26:56 +01001939 auto sizes = getExternalSizesForUserWithQuota(uuidString, userId, appIds);
1940 extStats.dataSize += sizes.totalSize;
1941 extStats.codeSize += sizes.obbSize;
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001942 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001943
Jeff Sharkey06a61842017-04-15 12:03:31 -06001944 if (!uuid) {
1945 ATRACE_BEGIN("dalvik");
1946 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
1947 -1, -1, true);
1948 calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize,
1949 -1, -1, true);
1950 ATRACE_END();
1951 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001952 ATRACE_BEGIN("quota");
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001953 int64_t dataSize = extStats.dataSize;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001954 for (auto appId : appIds) {
1955 if (appId >= AID_APP_START) {
Risan5f308262018-10-26 12:06:58 -06001956 collectQuotaStats(uuidString, userId, appId, &stats, &extStats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001957#if MEASURE_DEBUG
1958 // Sleep to make sure we don't lose logs
1959 usleep(1);
1960#endif
1961 }
1962 }
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06001963 extStats.dataSize = dataSize;
Jeff Sharkey466459b2017-01-17 15:25:01 -07001964 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001965 } else {
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001966 ATRACE_BEGIN("obb");
1967 auto obbPath = create_data_path(uuid_) + "/media/obb";
1968 calculate_tree_size(obbPath, &extStats.codeSize);
1969 ATRACE_END();
1970
Jeff Sharkey466459b2017-01-17 15:25:01 -07001971 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001972 calculate_tree_size(create_data_app_path(uuid_), &stats.codeSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001973 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001974
Jeff Sharkey466459b2017-01-17 15:25:01 -07001975 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001976 auto cePath = create_data_user_ce_path(uuid_, userId);
1977 collectManualStatsForUser(cePath, &stats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001978 auto dePath = create_data_user_de_path(uuid_, userId);
1979 collectManualStatsForUser(dePath, &stats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001980 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001981
Jeff Sharkey06a61842017-04-15 12:03:31 -06001982 if (!uuid) {
1983 ATRACE_BEGIN("profile");
1984 auto userProfilePath = create_primary_cur_profile_dir_path(userId);
1985 calculate_tree_size(userProfilePath, &stats.dataSize);
1986 auto refProfilePath = create_primary_ref_profile_dir_path();
1987 calculate_tree_size(refProfilePath, &stats.codeSize);
1988 ATRACE_END();
1989 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001990
Jeff Sharkey466459b2017-01-17 15:25:01 -07001991 ATRACE_BEGIN("external");
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001992 auto dataMediaPath = create_data_media_path(uuid_, userId);
1993 collectManualExternalStatsForUser(dataMediaPath, &extStats);
1994#if MEASURE_DEBUG
1995 LOG(DEBUG) << "Measured external data " << extStats.dataSize << " cache "
1996 << extStats.cacheSize;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001997#endif
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001998 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001999
Jeff Sharkey06a61842017-04-15 12:03:31 -06002000 if (!uuid) {
2001 ATRACE_BEGIN("dalvik");
2002 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize);
2003 calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize);
2004 ATRACE_END();
2005 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002006 }
2007
2008 std::vector<int64_t> ret;
2009 ret.push_back(stats.codeSize);
2010 ret.push_back(stats.dataSize);
2011 ret.push_back(stats.cacheSize);
2012 ret.push_back(extStats.codeSize);
2013 ret.push_back(extStats.dataSize);
2014 ret.push_back(extStats.cacheSize);
2015#if MEASURE_DEBUG
2016 LOG(DEBUG) << "Final result " << toString(ret);
2017#endif
2018 *_aidl_return = ret;
2019 return ok();
2020}
2021
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002022binder::Status InstalldNativeService::getExternalSize(const std::optional<std::string>& uuid,
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002023 int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,
2024 std::vector<int64_t>* _aidl_return) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002025 ENFORCE_UID(AID_SYSTEM);
2026 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07002027 // NOTE: Locking is relaxed on this method, since it's limited to
2028 // read-only measurements without mutation.
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002029
2030 // When modifying this logic, always verify using tests:
2031 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetExternalSize
2032
2033#if MEASURE_DEBUG
2034 LOG(INFO) << "Measuring external " << userId;
2035#endif
2036
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002037 auto uuidString = uuid.value_or("");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002038 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2039
2040 int64_t totalSize = 0;
2041 int64_t audioSize = 0;
2042 int64_t videoSize = 0;
2043 int64_t imageSize = 0;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002044 int64_t appSize = 0;
Jeff Sharkeya0136982017-07-06 11:29:37 -06002045 int64_t obbSize = 0;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002046
Risan5f308262018-10-26 12:06:58 -06002047 if (!IsQuotaSupported(uuidString)) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002048 flags &= ~FLAG_USE_QUOTA;
2049 }
2050
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002051 if (flags & FLAG_USE_QUOTA) {
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002052 ATRACE_BEGIN("quota");
Martijn Coenen771cc342020-02-19 23:26:56 +01002053 auto sizes = getExternalSizesForUserWithQuota(uuidString, userId, appIds);
2054 totalSize = sizes.totalSize;
2055 audioSize = sizes.audioSize;
2056 videoSize = sizes.videoSize;
2057 imageSize = sizes.imageSize;
2058 obbSize = sizes.obbSize;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002059 ATRACE_END();
2060
2061 ATRACE_BEGIN("apps");
2062 struct stats extStats;
2063 memset(&extStats, 0, sizeof(extStats));
2064 for (auto appId : appIds) {
2065 if (appId >= AID_APP_START) {
Risan5f308262018-10-26 12:06:58 -06002066 collectQuotaStats(uuidString, userId, appId, nullptr, &extStats);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002067 }
2068 }
Jeff Sharkey4ca8ff92017-06-07 15:59:03 -06002069 appSize = extStats.dataSize;
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002070 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002071 } else {
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002072 ATRACE_BEGIN("manual");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002073 FTS *fts;
2074 FTSENT *p;
2075 auto path = create_data_media_path(uuid_, userId);
2076 char *argv[] = { (char*) path.c_str(), nullptr };
Yi Konge7bf3772018-07-17 16:16:24 -07002077 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr))) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002078 return error("Failed to fts_open " + path);
2079 }
Yi Konge7bf3772018-07-17 16:16:24 -07002080 while ((p = fts_read(fts)) != nullptr) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002081 char* ext;
2082 int64_t size = (p->fts_statp->st_blocks * 512);
2083 switch (p->fts_info) {
2084 case FTS_F:
2085 // Only categorize files not belonging to apps
Jeff Sharkey444ad1e2017-03-12 16:25:36 -06002086 if (p->fts_parent->fts_number == 0) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002087 ext = strrchr(p->fts_name, '.');
2088 if (ext != nullptr) {
2089 switch (MatchExtension(++ext)) {
2090 case AID_MEDIA_AUDIO: audioSize += size; break;
2091 case AID_MEDIA_VIDEO: videoSize += size; break;
2092 case AID_MEDIA_IMAGE: imageSize += size; break;
2093 }
2094 }
2095 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -07002096 [[fallthrough]]; // always count against total
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002097 case FTS_D:
Jeff Sharkey444ad1e2017-03-12 16:25:36 -06002098 // Ignore data belonging to specific apps
2099 p->fts_number = p->fts_parent->fts_number;
2100 if (p->fts_level == 1 && !strcmp(p->fts_name, "Android")) {
2101 p->fts_number = 1;
2102 }
Chih-Hung Hsiehf1dd98e2018-10-16 14:17:11 -07002103 [[fallthrough]]; // always count against total
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002104 case FTS_DEFAULT:
2105 case FTS_SL:
2106 case FTS_SLNONE:
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002107 if (p->fts_parent->fts_number == 1) {
2108 appSize += size;
2109 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002110 totalSize += size;
2111 break;
2112 }
2113 }
2114 fts_close(fts);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002115 ATRACE_END();
Jeff Sharkeya0136982017-07-06 11:29:37 -06002116
2117 ATRACE_BEGIN("obb");
Jeff Sharkey6d775c52019-03-22 13:46:20 -06002118 auto obbPath = StringPrintf("%s/Android/obb",
2119 create_data_media_path(uuid_, userId).c_str());
Jeff Sharkeya0136982017-07-06 11:29:37 -06002120 calculate_tree_size(obbPath, &obbSize);
2121 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002122 }
2123
2124 std::vector<int64_t> ret;
2125 ret.push_back(totalSize);
2126 ret.push_back(audioSize);
2127 ret.push_back(videoSize);
2128 ret.push_back(imageSize);
Jeff Sharkeya084fcd2017-04-17 16:44:41 -06002129 ret.push_back(appSize);
Jeff Sharkeya0136982017-07-06 11:29:37 -06002130 ret.push_back(obbSize);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07002131#if MEASURE_DEBUG
2132 LOG(DEBUG) << "Final result " << toString(ret);
2133#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07002134 *_aidl_return = ret;
Jeff Sharkey423e7462016-12-09 18:18:43 -07002135 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002136}
2137
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002138binder::Status InstalldNativeService::setAppQuota(const std::optional<std::string>& uuid,
Jeff Sharkey88ddd942017-01-17 18:05:54 -07002139 int32_t userId, int32_t appId, int64_t cacheQuota) {
2140 ENFORCE_UID(AID_SYSTEM);
2141 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002142 std::lock_guard<std::recursive_mutex> lock(mQuotasLock);
Jeff Sharkey88ddd942017-01-17 18:05:54 -07002143
2144 int32_t uid = multiuser_get_uid(userId, appId);
2145 mCacheQuotas[uid] = cacheQuota;
2146
2147 return ok();
2148}
2149
David Sehr6727c2d2016-05-17 16:06:22 -07002150// Dumps the contents of a profile file, using pkgname's dex files for pretty
2151// printing the result.
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002152binder::Status InstalldNativeService::dumpProfiles(int32_t uid, const std::string& packageName,
Calin Juravle562de812018-01-20 23:34:18 -08002153 const std::string& profileName, const std::string& codePath, bool* _aidl_return) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002154 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002155 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07002156 CHECK_ARGUMENT_PATH(codePath);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002157 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002158
Calin Juravle562de812018-01-20 23:34:18 -08002159 *_aidl_return = dump_profiles(uid, packageName, profileName, codePath);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002160 return ok();
David Sehr6727c2d2016-05-17 16:06:22 -07002161}
2162
Mathieu Chartierf966f2a2017-05-10 12:48:37 -07002163// Copy the contents of a system profile over the data profile.
2164binder::Status InstalldNativeService::copySystemProfile(const std::string& systemProfile,
Calin Juravle562de812018-01-20 23:34:18 -08002165 int32_t packageUid, const std::string& packageName, const std::string& profileName,
2166 bool* _aidl_return) {
Mathieu Chartierf966f2a2017-05-10 12:48:37 -07002167 ENFORCE_UID(AID_SYSTEM);
2168 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
2169 std::lock_guard<std::recursive_mutex> lock(mLock);
Calin Juravle562de812018-01-20 23:34:18 -08002170 *_aidl_return = copy_system_profile(systemProfile, packageUid, packageName, profileName);
Mathieu Chartierf966f2a2017-05-10 12:48:37 -07002171 return ok();
2172}
2173
Andreas Gampe4d0f8252016-03-20 11:30:28 -07002174// TODO: Consider returning error codes.
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002175binder::Status InstalldNativeService::mergeProfiles(int32_t uid, const std::string& packageName,
Calin Juravle562de812018-01-20 23:34:18 -08002176 const std::string& profileName, bool* _aidl_return) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002177 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002178 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002179 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002180
Calin Juravle562de812018-01-20 23:34:18 -08002181 *_aidl_return = analyze_primary_profiles(uid, packageName, profileName);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002182 return ok();
Andreas Gampe4d0f8252016-03-20 11:30:28 -07002183}
2184
Calin Juravlec41dac22017-12-05 12:29:15 -08002185binder::Status InstalldNativeService::createProfileSnapshot(int32_t appId,
Calin Juravlee61189e2018-01-23 19:54:11 -08002186 const std::string& packageName, const std::string& profileName,
2187 const std::string& classpath, bool* _aidl_return) {
Calin Juravle29591732017-11-20 17:46:19 -08002188 ENFORCE_UID(AID_SYSTEM);
2189 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
2190 std::lock_guard<std::recursive_mutex> lock(mLock);
2191
Calin Juravlee61189e2018-01-23 19:54:11 -08002192 *_aidl_return = create_profile_snapshot(appId, packageName, profileName, classpath);
Calin Juravle29591732017-11-20 17:46:19 -08002193 return ok();
2194}
2195
2196binder::Status InstalldNativeService::destroyProfileSnapshot(const std::string& packageName,
Calin Juravlecfcd6aa2018-01-18 20:23:17 -08002197 const std::string& profileName) {
Calin Juravle29591732017-11-20 17:46:19 -08002198 ENFORCE_UID(AID_SYSTEM);
2199 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
2200 std::lock_guard<std::recursive_mutex> lock(mLock);
2201
Calin Juravlecfcd6aa2018-01-18 20:23:17 -08002202 std::string snapshot = create_snapshot_profile_path(packageName, profileName);
Calin Juravle29591732017-11-20 17:46:19 -08002203 if ((unlink(snapshot.c_str()) != 0) && (errno != ENOENT)) {
Calin Juravlecfcd6aa2018-01-18 20:23:17 -08002204 return error("Failed to destroy profile snapshot for " + packageName + ":" + profileName);
Calin Juravle29591732017-11-20 17:46:19 -08002205 }
2206 return ok();
2207}
2208
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002209static const char* getCStr(const std::optional<std::string>& data,
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002210 const char* default_value = nullptr) {
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002211 return !data ? default_value : data->c_str();
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002212}
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002213binder::Status InstalldNativeService::dexopt(const std::string& apkPath, int32_t uid,
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002214 const std::optional<std::string>& packageName, const std::string& instructionSet,
2215 int32_t dexoptNeeded, const std::optional<std::string>& outputPath, int32_t dexFlags,
2216 const std::string& compilerFilter, const std::optional<std::string>& uuid,
2217 const std::optional<std::string>& classLoaderContext,
2218 const std::optional<std::string>& seInfo, bool downgrade, int32_t targetSdkVersion,
2219 const std::optional<std::string>& profileName,
2220 const std::optional<std::string>& dexMetadataPath,
2221 const std::optional<std::string>& compilationReason) {
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002222 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002223 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey53594302018-02-24 18:59:39 -07002224 CHECK_ARGUMENT_PATH(apkPath);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002225 if (packageName && *packageName != "*") {
2226 CHECK_ARGUMENT_PACKAGE_NAME(*packageName);
2227 }
Jeff Sharkey53594302018-02-24 18:59:39 -07002228 CHECK_ARGUMENT_PATH(outputPath);
2229 CHECK_ARGUMENT_PATH(dexMetadataPath);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002230 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002231
Alex Buynytskyy17d8f822019-06-20 16:29:57 -07002232 const char* oat_dir = getCStr(outputPath);
2233 const char* instruction_set = instructionSet.c_str();
2234 if (oat_dir != nullptr && !createOatDir(oat_dir, instruction_set).isOk()) {
2235 // Can't create oat dir - let dexopt use cache dir.
2236 oat_dir = nullptr;
2237 }
2238
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002239 const char* apk_path = apkPath.c_str();
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002240 const char* pkgname = getCStr(packageName, "*");
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002241 const char* compiler_filter = compilerFilter.c_str();
Calin Juravlecc3b8ae2018-02-01 17:03:23 +00002242 const char* volume_uuid = getCStr(uuid);
2243 const char* class_loader_context = getCStr(classLoaderContext);
2244 const char* se_info = getCStr(seInfo);
2245 const char* profile_name = getCStr(profileName);
2246 const char* dm_path = getCStr(dexMetadataPath);
Calin Juravledcccd832018-02-13 18:31:32 -08002247 const char* compilation_reason = getCStr(compilationReason);
Andreas Gampe023b2242018-02-28 16:03:25 -08002248 std::string error_msg;
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002249 int res = android::installd::dexopt(apk_path, uid, pkgname, instruction_set, dexoptNeeded,
Calin Juravle1d667612017-07-13 22:50:21 -07002250 oat_dir, dexFlags, compiler_filter, volume_uuid, class_loader_context, se_info,
Andreas Gampe023b2242018-02-28 16:03:25 -08002251 downgrade, targetSdkVersion, profile_name, dm_path, compilation_reason, &error_msg);
2252 return res ? error(res, error_msg) : ok();
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002253}
2254
Eric Holk0ebbe0f2019-01-09 18:17:27 -08002255binder::Status InstalldNativeService::compileLayouts(const std::string& apkPath,
2256 const std::string& packageName,
2257 const std ::string& outDexFile, int uid,
2258 bool* _aidl_return) {
2259 const char* apk_path = apkPath.c_str();
2260 const char* package_name = packageName.c_str();
2261 const char* out_dex_file = outDexFile.c_str();
2262 *_aidl_return = android::installd::view_compiler(apk_path, package_name, out_dex_file, uid);
2263 return *_aidl_return ? ok() : error("viewcompiler failed");
2264}
2265
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002266binder::Status InstalldNativeService::markBootComplete(const std::string& instructionSet) {
2267 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002268 std::lock_guard<std::recursive_mutex> lock(mLock);
2269
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002270 const char* instruction_set = instructionSet.c_str();
2271
2272 char boot_marker_path[PKG_PATH_MAX];
2273 sprintf(boot_marker_path,
Andreas Gampe02d0de52015-11-11 20:43:16 -08002274 "%s/%s/%s/.booting",
Jeff Sharkey1b9d9a62017-09-21 14:51:09 -06002275 android_data_dir.c_str(),
Andreas Gampe02d0de52015-11-11 20:43:16 -08002276 DALVIK_CACHE,
2277 instruction_set);
Narayan Kamath091ea772014-11-10 15:03:46 +00002278
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002279 ALOGV("mark_boot_complete : %s", boot_marker_path);
2280 if (unlink(boot_marker_path) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002281 return error(StringPrintf("Failed to unlink %s", boot_marker_path));
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002282 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002283 return ok();
Narayan Kamath091ea772014-11-10 15:03:46 +00002284}
2285
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002286binder::Status InstalldNativeService::linkNativeLibraryDirectory(
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002287 const std::optional<std::string>& uuid, const std::string& packageName,
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002288 const std::string& nativeLibPath32, int32_t userId) {
2289 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002290 CHECK_ARGUMENT_UUID(uuid);
2291 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07002292 CHECK_ARGUMENT_PATH(nativeLibPath32);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002293 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002294
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002295 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2296 const char* pkgname = packageName.c_str();
2297 const char* asecLibDir = nativeLibPath32.c_str();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002298 struct stat s, libStat;
Jeff Sharkey423e7462016-12-09 18:18:43 -07002299 binder::Status res = ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002300
Jeff Sharkey423e7462016-12-09 18:18:43 -07002301 auto _pkgdir = create_data_user_ce_package_path(uuid_, userId, pkgname);
2302 auto _libsymlink = _pkgdir + PKG_LIB_POSTFIX;
Jeff Sharkeyc03de092015-04-07 18:14:05 -07002303
2304 const char* pkgdir = _pkgdir.c_str();
2305 const char* libsymlink = _libsymlink.c_str();
Mike Lockwood94afecf2012-10-24 10:45:23 -07002306
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002307 if (stat(pkgdir, &s) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002308 return error("Failed to stat " + _pkgdir);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002309 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07002310
Nick Kralevich85958b62019-01-30 12:32:21 -08002311 char *con = nullptr;
2312 if (lgetfilecon(pkgdir, &con) < 0) {
2313 return error("Failed to lgetfilecon " + _pkgdir);
2314 }
2315
Mike Lockwood94afecf2012-10-24 10:45:23 -07002316 if (chown(pkgdir, AID_INSTALL, AID_INSTALL) < 0) {
Nick Kralevich85958b62019-01-30 12:32:21 -08002317 res = error("Failed to chown " + _pkgdir);
2318 goto out;
Mike Lockwood94afecf2012-10-24 10:45:23 -07002319 }
2320
2321 if (chmod(pkgdir, 0700) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002322 res = error("Failed to chmod " + _pkgdir);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002323 goto out;
2324 }
2325
2326 if (lstat(libsymlink, &libStat) < 0) {
2327 if (errno != ENOENT) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002328 res = error("Failed to stat " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002329 goto out;
2330 }
2331 } else {
2332 if (S_ISDIR(libStat.st_mode)) {
Yi Konge7bf3772018-07-17 16:16:24 -07002333 if (delete_dir_contents(libsymlink, 1, nullptr) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002334 res = error("Failed to delete " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002335 goto out;
2336 }
2337 } else if (S_ISLNK(libStat.st_mode)) {
2338 if (unlink(libsymlink) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002339 res = error("Failed to unlink " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002340 goto out;
2341 }
2342 }
2343 }
2344
2345 if (symlink(asecLibDir, libsymlink) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002346 res = error("Failed to symlink " + _libsymlink + " to " + nativeLibPath32);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002347 goto out;
2348 }
2349
Nick Kralevich85958b62019-01-30 12:32:21 -08002350 if (lsetfilecon(libsymlink, con) < 0) {
2351 res = error("Failed to lsetfilecon " + _libsymlink);
2352 goto out;
2353 }
2354
Mike Lockwood94afecf2012-10-24 10:45:23 -07002355out:
Nick Kralevich85958b62019-01-30 12:32:21 -08002356 free(con);
Mike Lockwood94afecf2012-10-24 10:45:23 -07002357 if (chmod(pkgdir, s.st_mode) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002358 auto msg = "Failed to cleanup chmod " + _pkgdir;
2359 if (res.isOk()) {
2360 res = error(msg);
2361 } else {
2362 PLOG(ERROR) << msg;
2363 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07002364 }
2365
2366 if (chown(pkgdir, s.st_uid, s.st_gid) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002367 auto msg = "Failed to cleanup chown " + _pkgdir;
2368 if (res.isOk()) {
2369 res = error(msg);
2370 } else {
2371 PLOG(ERROR) << msg;
2372 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07002373 }
2374
Jeff Sharkey423e7462016-12-09 18:18:43 -07002375 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -07002376}
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002377
2378static void run_idmap(const char *target_apk, const char *overlay_apk, int idmap_fd)
2379{
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002380 execl(kIdMapPath, kIdMapPath, "--fd", target_apk, overlay_apk,
Yi Konge7bf3772018-07-17 16:16:24 -07002381 StringPrintf("%d", idmap_fd).c_str(), (char*)nullptr);
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002382 PLOG(ERROR) << "execl (" << kIdMapPath << ") failed";
2383}
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002384
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002385static void run_verify_idmap(const char *target_apk, const char *overlay_apk, int idmap_fd)
2386{
2387 execl(kIdMapPath, kIdMapPath, "--verify", target_apk, overlay_apk,
Yi Konge7bf3772018-07-17 16:16:24 -07002388 StringPrintf("%d", idmap_fd).c_str(), (char*)nullptr);
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002389 PLOG(ERROR) << "execl (" << kIdMapPath << ") failed";
2390}
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002391
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002392static bool delete_stale_idmap(const char* target_apk, const char* overlay_apk,
2393 const char* idmap_path, int32_t uid) {
2394 int idmap_fd = open(idmap_path, O_RDWR);
2395 if (idmap_fd < 0) {
2396 PLOG(ERROR) << "idmap open failed: " << idmap_path;
2397 unlink(idmap_path);
2398 return true;
2399 }
2400
2401 pid_t pid;
2402 pid = fork();
2403 if (pid == 0) {
2404 /* child -- drop privileges before continuing */
2405 if (setgid(uid) != 0) {
2406 LOG(ERROR) << "setgid(" << uid << ") failed during idmap";
2407 exit(1);
2408 }
2409 if (setuid(uid) != 0) {
2410 LOG(ERROR) << "setuid(" << uid << ") failed during idmap";
2411 exit(1);
2412 }
2413 if (flock(idmap_fd, LOCK_EX | LOCK_NB) != 0) {
2414 PLOG(ERROR) << "flock(" << idmap_path << ") failed during idmap";
2415 exit(1);
2416 }
2417
2418 run_verify_idmap(target_apk, overlay_apk, idmap_fd);
2419 exit(1); /* only if exec call to deleting stale idmap failed */
2420 } else {
2421 int status = wait_child(pid);
2422 close(idmap_fd);
2423
2424 if (status != 0) {
2425 // Failed on verifying if idmap is made from target_apk and overlay_apk.
2426 LOG(DEBUG) << "delete stale idmap: " << idmap_path;
2427 unlink(idmap_path);
2428 return true;
2429 }
2430 }
2431 return false;
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002432}
2433
2434// Transform string /a/b/c.apk to (prefix)/a@b@c.apk@(suffix)
2435// eg /a/b/c.apk to /data/resource-cache/a@b@c.apk@idmap
2436static int flatten_path(const char *prefix, const char *suffix,
2437 const char *overlay_path, char *idmap_path, size_t N)
2438{
Yi Konge7bf3772018-07-17 16:16:24 -07002439 if (overlay_path == nullptr || idmap_path == nullptr) {
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002440 return -1;
2441 }
2442 const size_t len_overlay_path = strlen(overlay_path);
2443 // will access overlay_path + 1 further below; requires absolute path
2444 if (len_overlay_path < 2 || *overlay_path != '/') {
2445 return -1;
2446 }
2447 const size_t len_idmap_root = strlen(prefix);
2448 const size_t len_suffix = strlen(suffix);
2449 if (SIZE_MAX - len_idmap_root < len_overlay_path ||
2450 SIZE_MAX - (len_idmap_root + len_overlay_path) < len_suffix) {
2451 // additions below would cause overflow
2452 return -1;
2453 }
2454 if (N < len_idmap_root + len_overlay_path + len_suffix) {
2455 return -1;
2456 }
2457 memset(idmap_path, 0, N);
2458 snprintf(idmap_path, N, "%s%s%s", prefix, overlay_path + 1, suffix);
2459 char *ch = idmap_path + len_idmap_root;
2460 while (*ch != '\0') {
2461 if (*ch == '/') {
2462 *ch = '@';
2463 }
2464 ++ch;
2465 }
2466 return 0;
2467}
2468
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002469binder::Status InstalldNativeService::idmap(const std::string& targetApkPath,
2470 const std::string& overlayApkPath, int32_t uid) {
2471 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002472 CHECK_ARGUMENT_PATH(targetApkPath);
2473 CHECK_ARGUMENT_PATH(overlayApkPath);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002474 std::lock_guard<std::recursive_mutex> lock(mLock);
2475
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002476 const char* target_apk = targetApkPath.c_str();
2477 const char* overlay_apk = overlayApkPath.c_str();
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002478 ALOGV("idmap target_apk=%s overlay_apk=%s uid=%d\n", target_apk, overlay_apk, uid);
2479
2480 int idmap_fd = -1;
2481 char idmap_path[PATH_MAX];
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002482 struct stat idmap_stat;
2483 bool outdated = false;
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002484
2485 if (flatten_path(IDMAP_PREFIX, IDMAP_SUFFIX, overlay_apk,
2486 idmap_path, sizeof(idmap_path)) == -1) {
2487 ALOGE("idmap cannot generate idmap path for overlay %s\n", overlay_apk);
2488 goto fail;
2489 }
2490
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002491 if (stat(idmap_path, &idmap_stat) < 0) {
2492 outdated = true;
2493 } else {
2494 outdated = delete_stale_idmap(target_apk, overlay_apk, idmap_path, uid);
2495 }
2496
2497 if (outdated) {
2498 idmap_fd = open(idmap_path, O_RDWR | O_CREAT | O_EXCL, 0644);
2499 } else {
2500 idmap_fd = open(idmap_path, O_RDWR);
2501 }
2502
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002503 if (idmap_fd < 0) {
2504 ALOGE("idmap cannot open '%s' for output: %s\n", idmap_path, strerror(errno));
2505 goto fail;
2506 }
2507 if (fchown(idmap_fd, AID_SYSTEM, uid) < 0) {
2508 ALOGE("idmap cannot chown '%s'\n", idmap_path);
2509 goto fail;
2510 }
2511 if (fchmod(idmap_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
2512 ALOGE("idmap cannot chmod '%s'\n", idmap_path);
2513 goto fail;
2514 }
2515
Jaekyun Seok5cb903e2017-05-18 00:13:44 +09002516 if (!outdated) {
2517 close(idmap_fd);
2518 return ok();
2519 }
2520
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002521 pid_t pid;
2522 pid = fork();
2523 if (pid == 0) {
2524 /* child -- drop privileges before continuing */
2525 if (setgid(uid) != 0) {
2526 ALOGE("setgid(%d) failed during idmap\n", uid);
2527 exit(1);
2528 }
2529 if (setuid(uid) != 0) {
2530 ALOGE("setuid(%d) failed during idmap\n", uid);
2531 exit(1);
2532 }
2533 if (flock(idmap_fd, LOCK_EX | LOCK_NB) != 0) {
2534 ALOGE("flock(%s) failed during idmap: %s\n", idmap_path, strerror(errno));
2535 exit(1);
2536 }
2537
2538 run_idmap(target_apk, overlay_apk, idmap_fd);
2539 exit(1); /* only if exec call to idmap failed */
2540 } else {
2541 int status = wait_child(pid);
2542 if (status != 0) {
2543 ALOGE("idmap failed, status=0x%04x\n", status);
2544 goto fail;
2545 }
2546 }
2547
2548 close(idmap_fd);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002549 return ok();
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002550fail:
2551 if (idmap_fd >= 0) {
2552 close(idmap_fd);
2553 unlink(idmap_path);
2554 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002555 return error();
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002556}
Robert Craige9887e42014-02-20 10:25:56 -05002557
MÃ¥rten Kongstad5c6944c2015-12-15 14:02:30 +01002558binder::Status InstalldNativeService::removeIdmap(const std::string& overlayApkPath) {
Jeff Sharkey53594302018-02-24 18:59:39 -07002559 ENFORCE_UID(AID_SYSTEM);
2560 CHECK_ARGUMENT_PATH(overlayApkPath);
2561 std::lock_guard<std::recursive_mutex> lock(mLock);
2562
MÃ¥rten Kongstad5c6944c2015-12-15 14:02:30 +01002563 const char* overlay_apk = overlayApkPath.c_str();
2564 char idmap_path[PATH_MAX];
2565
2566 if (flatten_path(IDMAP_PREFIX, IDMAP_SUFFIX, overlay_apk,
2567 idmap_path, sizeof(idmap_path)) == -1) {
2568 ALOGE("idmap cannot generate idmap path for overlay %s\n", overlay_apk);
2569 return error();
2570 }
2571 if (unlink(idmap_path) < 0) {
2572 ALOGE("couldn't unlink idmap file %s\n", idmap_path);
2573 return error();
2574 }
2575 return ok();
2576}
2577
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002578binder::Status InstalldNativeService::restoreconAppData(const std::optional<std::string>& uuid,
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002579 const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,
2580 const std::string& seInfo) {
2581 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002582 CHECK_ARGUMENT_UUID(uuid);
2583 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002584 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002585
2586 binder::Status res = ok();
Robert Craige9887e42014-02-20 10:25:56 -05002587
Robert Craigda30dc72014-03-27 10:21:12 -04002588 // SELINUX_ANDROID_RESTORECON_DATADATA flag is set by libselinux. Not needed here.
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002589 unsigned int seflags = SELINUX_ANDROID_RESTORECON_RECURSE;
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002590 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2591 const char* pkgName = packageName.c_str();
2592 const char* seinfo = seInfo.c_str();
Robert Craigda30dc72014-03-27 10:21:12 -04002593
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002594 uid_t uid = multiuser_get_uid(userId, appId);
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07002595 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002596 auto path = create_data_user_ce_package_path(uuid_, userId, pkgName);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002597 if (selinux_android_restorecon_pkgdir(path.c_str(), seinfo, uid, seflags) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002598 res = error("restorecon failed for " + path);
Jeff Sharkeyebf728f2015-11-18 14:15:17 -07002599 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002600 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07002601 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002602 auto path = create_data_user_de_package_path(uuid_, userId, pkgName);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002603 if (selinux_android_restorecon_pkgdir(path.c_str(), seinfo, uid, seflags) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002604 res = error("restorecon failed for " + path);
Jeff Sharkey41ea4242015-04-09 11:34:03 -07002605 }
Robert Craige9887e42014-02-20 10:25:56 -05002606 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002607 return res;
Robert Craige9887e42014-02-20 10:25:56 -05002608}
Narayan Kamath3aee2c52014-06-10 13:16:47 +01002609
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002610binder::Status InstalldNativeService::createOatDir(const std::string& oatDir,
2611 const std::string& instructionSet) {
2612 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002613 CHECK_ARGUMENT_PATH(oatDir);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002614 std::lock_guard<std::recursive_mutex> lock(mLock);
2615
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002616 const char* oat_dir = oatDir.c_str();
2617 const char* instruction_set = instructionSet.c_str();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002618 char oat_instr_dir[PKG_PATH_MAX];
2619
2620 if (validate_apk_path(oat_dir)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002621 return error("Invalid path " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002622 }
Fyodor Kupolov8eed7e62015-04-06 19:09:02 -07002623 if (fs_prepare_dir(oat_dir, S_IRWXU | S_IRWXG | S_IXOTH, AID_SYSTEM, AID_INSTALL)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002624 return error("Failed to prepare " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002625 }
2626 if (selinux_android_restorecon(oat_dir, 0)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002627 return error("Failed to restorecon " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002628 }
2629 snprintf(oat_instr_dir, PKG_PATH_MAX, "%s/%s", oat_dir, instruction_set);
Fyodor Kupolov8eed7e62015-04-06 19:09:02 -07002630 if (fs_prepare_dir(oat_instr_dir, S_IRWXU | S_IRWXG | S_IXOTH, AID_SYSTEM, AID_INSTALL)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002631 return error(StringPrintf("Failed to prepare %s", oat_instr_dir));
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002632 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002633 return ok();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002634}
2635
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002636binder::Status InstalldNativeService::rmPackageDir(const std::string& packageDir) {
2637 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002638 CHECK_ARGUMENT_PATH(packageDir);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002639 std::lock_guard<std::recursive_mutex> lock(mLock);
2640
Jeff Sharkey423e7462016-12-09 18:18:43 -07002641 if (validate_apk_path(packageDir.c_str())) {
2642 return error("Invalid path " + packageDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002643 }
Oleksandr Peletskyid2be6322019-01-24 17:59:45 +01002644 if (rm_package_dir(packageDir) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002645 return error("Failed to delete " + packageDir);
2646 }
2647 return ok();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002648}
2649
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002650binder::Status InstalldNativeService::linkFile(const std::string& relativePath,
2651 const std::string& fromBase, const std::string& toBase) {
2652 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002653 CHECK_ARGUMENT_PATH(fromBase);
2654 CHECK_ARGUMENT_PATH(toBase);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002655 std::lock_guard<std::recursive_mutex> lock(mLock);
2656
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002657 const char* relative_path = relativePath.c_str();
2658 const char* from_base = fromBase.c_str();
2659 const char* to_base = toBase.c_str();
Narayan Kamathd845c962015-06-04 13:20:27 +01002660 char from_path[PKG_PATH_MAX];
2661 char to_path[PKG_PATH_MAX];
2662 snprintf(from_path, PKG_PATH_MAX, "%s/%s", from_base, relative_path);
2663 snprintf(to_path, PKG_PATH_MAX, "%s/%s", to_base, relative_path);
2664
2665 if (validate_apk_path_subdirs(from_path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002666 return error(StringPrintf("Invalid from path %s", from_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002667 }
2668
2669 if (validate_apk_path_subdirs(to_path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002670 return error(StringPrintf("Invalid to path %s", to_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002671 }
2672
Jeff Sharkey423e7462016-12-09 18:18:43 -07002673 if (link(from_path, to_path) < 0) {
2674 return error(StringPrintf("Failed to link from %s to %s", from_path, to_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002675 }
2676
Jeff Sharkey423e7462016-12-09 18:18:43 -07002677 return ok();
Narayan Kamathd845c962015-06-04 13:20:27 +01002678}
2679
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002680binder::Status InstalldNativeService::moveAb(const std::string& apkPath,
2681 const std::string& instructionSet, const std::string& outputPath) {
2682 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002683 CHECK_ARGUMENT_PATH(apkPath);
2684 CHECK_ARGUMENT_PATH(outputPath);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002685 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey90aff262016-12-12 14:28:24 -07002686
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002687 const char* apk_path = apkPath.c_str();
2688 const char* instruction_set = instructionSet.c_str();
2689 const char* oat_dir = outputPath.c_str();
Andreas Gampe0354bd02016-06-27 14:25:30 -07002690
Jeff Sharkey90aff262016-12-12 14:28:24 -07002691 bool success = move_ab(apk_path, instruction_set, oat_dir);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002692 return success ? ok() : error();
Andreas Gampee65b4fa2016-03-01 11:46:45 -08002693}
2694
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002695binder::Status InstalldNativeService::deleteOdex(const std::string& apkPath,
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002696 const std::string& instructionSet, const std::optional<std::string>& outputPath) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002697 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002698 CHECK_ARGUMENT_PATH(apkPath);
2699 CHECK_ARGUMENT_PATH(outputPath);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002700 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey90aff262016-12-12 14:28:24 -07002701
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002702 const char* apk_path = apkPath.c_str();
2703 const char* instruction_set = instructionSet.c_str();
Andreas Gampec5234092017-05-31 16:39:58 -07002704 const char* oat_dir = outputPath ? outputPath->c_str() : nullptr;
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002705
Jeff Sharkey90aff262016-12-12 14:28:24 -07002706 bool res = delete_odex(apk_path, instruction_set, oat_dir);
2707 return res ? ok() : error();
Andreas Gampe3964da02016-09-09 17:07:04 -07002708}
2709
Victor Hsieh7ebd5132018-01-23 07:52:17 -08002710// This kernel feature is experimental.
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002711// TODO: remove local definition once upstreamed
Victor Hsieh18ac0272018-03-12 16:03:02 -07002712#ifndef FS_IOC_ENABLE_VERITY
2713
2714#define FS_IOC_ENABLE_VERITY _IO('f', 133)
2715#define FS_IOC_SET_VERITY_MEASUREMENT _IOW('f', 134, struct fsverity_measurement)
2716
2717#define FS_VERITY_ALG_SHA256 1
2718
2719struct fsverity_measurement {
2720 __u16 digest_algorithm;
2721 __u16 digest_size;
2722 __u32 reserved1;
2723 __u64 reserved2[3];
2724 __u8 digest[];
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002725};
2726
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002727#endif
2728
2729binder::Status InstalldNativeService::installApkVerity(const std::string& filePath,
Jiyong Park40b05d42019-11-25 11:06:16 +09002730 android::base::unique_fd verityInputAshmem, int32_t contentSize) {
Victor Hsieh99de5162017-10-06 14:44:14 -07002731 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002732 CHECK_ARGUMENT_PATH(filePath);
2733 std::lock_guard<std::recursive_mutex> lock(mLock);
2734
Victor Hsieh99de5162017-10-06 14:44:14 -07002735 if (!android::base::GetBoolProperty(kPropApkVerityMode, false)) {
2736 return ok();
2737 }
Victor Hsieh18ac0272018-03-12 16:03:02 -07002738#ifndef NDEBUG
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002739 ASSERT_PAGE_SIZE_4K();
2740#endif
2741 // TODO: also check fsverity support in the current file system if compiled with DEBUG.
2742 // TODO: change ashmem to some temporary file to support huge apk.
2743 if (!ashmem_valid(verityInputAshmem.get())) {
2744 return error("FD is not an ashmem");
2745 }
2746
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002747 // 1. Seek to the next page boundary beyond the end of the file.
Victor Hsieh93a98052018-01-24 14:56:32 -08002748 ::android::base::unique_fd wfd(open(filePath.c_str(), O_WRONLY));
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002749 if (wfd.get() < 0) {
Victor Hsieh18ac0272018-03-12 16:03:02 -07002750 return error("Failed to open " + filePath);
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002751 }
2752 struct stat st;
2753 if (fstat(wfd.get(), &st) < 0) {
Victor Hsieh18ac0272018-03-12 16:03:02 -07002754 return error("Failed to stat " + filePath);
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002755 }
2756 // fsverity starts from the block boundary.
Victor Hsieh93a98052018-01-24 14:56:32 -08002757 off_t padding = kVerityPageSize - st.st_size % kVerityPageSize;
2758 if (padding == kVerityPageSize) {
2759 padding = 0;
2760 }
2761 if (lseek(wfd.get(), st.st_size + padding, SEEK_SET) < 0) {
Victor Hsieh18ac0272018-03-12 16:03:02 -07002762 return error("Failed to lseek " + filePath);
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002763 }
2764
Victor Hsieh18ac0272018-03-12 16:03:02 -07002765 // 2. Write everything in the ashmem to the file. Note that allocated
2766 // ashmem size is multiple of page size, which is different from the
2767 // actual content size.
2768 int shmSize = ashmem_get_size_region(verityInputAshmem.get());
2769 if (shmSize < 0) {
2770 return error("Failed to get ashmem size: " + std::to_string(shmSize));
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002771 }
Victor Hsieh18ac0272018-03-12 16:03:02 -07002772 if (contentSize < 0) {
2773 return error("Invalid content size: " + std::to_string(contentSize));
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002774 }
Victor Hsieh18ac0272018-03-12 16:03:02 -07002775 if (contentSize > shmSize) {
2776 return error("Content size overflow: " + std::to_string(contentSize) + " > " +
2777 std::to_string(shmSize));
2778 }
2779 auto data = std::unique_ptr<void, std::function<void (void *)>>(
Yi Konge7bf3772018-07-17 16:16:24 -07002780 mmap(nullptr, contentSize, PROT_READ, MAP_SHARED, verityInputAshmem.get(), 0),
Victor Hsieh18ac0272018-03-12 16:03:02 -07002781 [contentSize] (void* ptr) {
2782 if (ptr != MAP_FAILED) {
2783 munmap(ptr, contentSize);
2784 }
2785 });
2786
2787 if (data.get() == MAP_FAILED) {
2788 return error("Failed to mmap the ashmem");
2789 }
2790 char* cursor = reinterpret_cast<char*>(data.get());
2791 int remaining = contentSize;
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002792 while (remaining > 0) {
Victor Hsieh93a98052018-01-24 14:56:32 -08002793 int ret = TEMP_FAILURE_RETRY(write(wfd.get(), cursor, remaining));
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002794 if (ret < 0) {
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002795 return error("Failed to write to " + filePath + " (" + std::to_string(remaining) +
Victor Hsieh18ac0272018-03-12 16:03:02 -07002796 + "/" + std::to_string(contentSize) + ")");
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002797 }
Victor Hsieh93a98052018-01-24 14:56:32 -08002798 cursor += ret;
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002799 remaining -= ret;
2800 }
Victor Hsieh18ac0272018-03-12 16:03:02 -07002801 wfd.reset();
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002802
Victor Hsieh18ac0272018-03-12 16:03:02 -07002803 // 3. Enable fsverity (needs readonly fd. Once it's done, the file becomes immutable.
2804 ::android::base::unique_fd rfd(open(filePath.c_str(), O_RDONLY));
2805 if (ioctl(rfd.get(), FS_IOC_ENABLE_VERITY, nullptr) < 0) {
2806 return error("Failed to enable fsverity on " + filePath);
Victor Hsieh3f16dd62018-01-13 13:43:11 -08002807 }
2808 return ok();
Victor Hsieh99de5162017-10-06 14:44:14 -07002809}
2810
Victor Hsiehc6d738a2018-01-20 15:06:39 -08002811binder::Status InstalldNativeService::assertFsverityRootHashMatches(const std::string& filePath,
2812 const std::vector<uint8_t>& expectedHash) {
2813 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey53594302018-02-24 18:59:39 -07002814 CHECK_ARGUMENT_PATH(filePath);
2815 std::lock_guard<std::recursive_mutex> lock(mLock);
2816
Victor Hsiehc6d738a2018-01-20 15:06:39 -08002817 if (!android::base::GetBoolProperty(kPropApkVerityMode, false)) {
2818 return ok();
2819 }
2820 // TODO: also check fsverity support in the current file system if compiled with DEBUG.
2821 if (expectedHash.size() != kSha256Size) {
2822 return error("verity hash size should be " + std::to_string(kSha256Size) + " but is " +
2823 std::to_string(expectedHash.size()));
2824 }
2825
Victor Hsiehc6d738a2018-01-20 15:06:39 -08002826 ::android::base::unique_fd fd(open(filePath.c_str(), O_RDONLY));
2827 if (fd.get() < 0) {
2828 return error("Failed to open " + filePath + ": " + strerror(errno));
2829 }
2830
Victor Hsieh18ac0272018-03-12 16:03:02 -07002831 unsigned int buffer_size = sizeof(fsverity_measurement) + kSha256Size;
2832 std::vector<char> buffer(buffer_size, 0);
2833
2834 fsverity_measurement* config = reinterpret_cast<fsverity_measurement*>(buffer.data());
2835 config->digest_algorithm = FS_VERITY_ALG_SHA256;
2836 config->digest_size = kSha256Size;
2837 memcpy(config->digest, expectedHash.data(), kSha256Size);
2838 if (ioctl(fd.get(), FS_IOC_SET_VERITY_MEASUREMENT, config) < 0) {
Victor Hsiehc6d738a2018-01-20 15:06:39 -08002839 // This includes an expected failure case with no FSVerity setup. It normally happens when
2840 // the apk does not contains the Merkle tree root hash.
2841 return error("Failed to measure fsverity on " + filePath + ": " + strerror(errno));
2842 }
2843 return ok(); // hashes match
2844}
2845
Calin Juravlebd968362017-01-25 01:17:17 -08002846binder::Status InstalldNativeService::reconcileSecondaryDexFile(
2847 const std::string& dexPath, const std::string& packageName, int32_t uid,
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002848 const std::vector<std::string>& isas, const std::optional<std::string>& volumeUuid,
Calin Juravlebd968362017-01-25 01:17:17 -08002849 int32_t storage_flag, bool* _aidl_return) {
2850 ENFORCE_UID(AID_SYSTEM);
2851 CHECK_ARGUMENT_UUID(volumeUuid);
2852 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07002853 CHECK_ARGUMENT_PATH(dexPath);
Calin Juravlebd968362017-01-25 01:17:17 -08002854 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey53594302018-02-24 18:59:39 -07002855
Calin Juravlebd968362017-01-25 01:17:17 -08002856 bool result = android::installd::reconcile_secondary_dex_file(
2857 dexPath, packageName, uid, isas, volumeUuid, storage_flag, _aidl_return);
2858 return result ? ok() : error();
2859}
2860
Alan Stokes753dc712017-10-16 10:56:00 +01002861binder::Status InstalldNativeService::hashSecondaryDexFile(
2862 const std::string& dexPath, const std::string& packageName, int32_t uid,
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002863 const std::optional<std::string>& volumeUuid, int32_t storageFlag,
Alan Stokes753dc712017-10-16 10:56:00 +01002864 std::vector<uint8_t>* _aidl_return) {
2865 ENFORCE_UID(AID_SYSTEM);
2866 CHECK_ARGUMENT_UUID(volumeUuid);
2867 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07002868 CHECK_ARGUMENT_PATH(dexPath);
Alan Stokes753dc712017-10-16 10:56:00 +01002869
2870 // mLock is not taken here since we will never modify the file system.
2871 // If a file is modified just as we are reading it this may result in an
2872 // anomalous hash, but that's ok.
2873 bool result = android::installd::hash_secondary_dex_file(
2874 dexPath, packageName, uid, volumeUuid, storageFlag, _aidl_return);
2875 return result ? ok() : error();
2876}
2877
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002878binder::Status InstalldNativeService::invalidateMounts() {
2879 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002880 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002881
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002882 mStorageMounts.clear();
Risan5f308262018-10-26 12:06:58 -06002883
2884#if !BYPASS_QUOTA
2885 if (!InvalidateQuotaMounts()) {
2886 return error("Failed to read mounts");
2887 }
2888#endif
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002889
2890 std::ifstream in("/proc/mounts");
2891 if (!in.is_open()) {
2892 return error("Failed to read mounts");
2893 }
2894
2895 std::string source;
2896 std::string target;
2897 std::string ignored;
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002898 while (!in.eof()) {
2899 std::getline(in, source, ' ');
2900 std::getline(in, target, ' ');
2901 std::getline(in, ignored);
2902
Zim0ce832d2019-12-03 17:03:58 +00002903 if (android::base::GetBoolProperty(kFuseProp, false)) {
Zim4527e3a2020-01-09 08:48:00 +00002904 if (target.find(kMntFuse) == 0) {
Zim0ce832d2019-12-03 17:03:58 +00002905 LOG(DEBUG) << "Found storage mount " << source << " at " << target;
2906 mStorageMounts[source] = target;
2907 }
2908 } else {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002909#if !BYPASS_SDCARDFS
Zim4527e3a2020-01-09 08:48:00 +00002910 if (target.find(kMntSdcardfs) == 0) {
Zim0ce832d2019-12-03 17:03:58 +00002911 LOG(DEBUG) << "Found storage mount " << source << " at " << target;
2912 mStorageMounts[source] = target;
2913 }
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002914#endif
Zim0ce832d2019-12-03 17:03:58 +00002915 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002916 }
2917 return ok();
2918}
2919
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002920std::string InstalldNativeService::findDataMediaPath(
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002921 const std::optional<std::string>& uuid, userid_t userid) {
Jeff Sharkeyd712f0c2017-05-03 11:36:42 -06002922 std::lock_guard<std::recursive_mutex> lock(mMountsLock);
2923 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2924 auto path = StringPrintf("%s/media", create_data_path(uuid_).c_str());
2925 auto resolved = mStorageMounts[path];
2926 if (resolved.empty()) {
2927 LOG(WARNING) << "Failed to find storage mount for " << path;
2928 resolved = path;
2929 }
2930 return StringPrintf("%s/%u", resolved.c_str(), userid);
2931}
2932
Jeff Sharkey325b8c92017-02-21 10:00:53 -07002933binder::Status InstalldNativeService::isQuotaSupported(
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002934 const std::optional<std::string>& uuid, bool* _aidl_return) {
2935 auto uuidString = uuid.value_or("");
Risan5f308262018-10-26 12:06:58 -06002936 *_aidl_return = IsQuotaSupported(uuidString);
Jeff Sharkey325b8c92017-02-21 10:00:53 -07002937 return ok();
2938}
2939
Calin Juravlebc5ab872018-01-18 22:32:58 -08002940binder::Status InstalldNativeService::prepareAppProfile(const std::string& packageName,
2941 int32_t userId, int32_t appId, const std::string& profileName, const std::string& codePath,
Jooyung Han9fcc4ef2020-01-23 12:45:10 +09002942 const std::optional<std::string>& dexMetadata, bool* _aidl_return) {
Calin Juravlebc5ab872018-01-18 22:32:58 -08002943 ENFORCE_UID(AID_SYSTEM);
2944 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey53594302018-02-24 18:59:39 -07002945 CHECK_ARGUMENT_PATH(codePath);
Calin Juravlebc5ab872018-01-18 22:32:58 -08002946 std::lock_guard<std::recursive_mutex> lock(mLock);
2947
2948 *_aidl_return = prepare_app_profile(packageName, userId, appId, profileName, codePath,
2949 dexMetadata);
2950 return ok();
2951}
2952
Narayan Kamath28ab93b2019-05-15 18:29:44 +01002953binder::Status InstalldNativeService::migrateLegacyObbData() {
2954 ENFORCE_UID(AID_SYSTEM);
2955 // NOTE: The lint warning doesn't apply to the use of system(3) with
2956 // absolute parse and no command line arguments.
2957 if (system("/system/bin/migrate_legacy_obb_data.sh") != 0) { // NOLINT(cert-env33-c)
2958 LOG(ERROR) << "Unable to migrate legacy obb data";
2959 }
2960
2961 return ok();
2962}
2963
Andreas Gampe02d0de52015-11-11 20:43:16 -08002964} // namespace installd
2965} // namespace android