blob: 4d8d9d1078400c07757e0f4022d7263546f0a811 [file] [log] [blame]
Mike Lockwood94afecf2012-10-24 10:45:23 -07001/*
2** Copyright 2008, The Android Open Source Project
3**
Dave Allisond9370732014-01-30 14:19:23 -08004** Licensed under the Apache License, Version 2.0 (the "License");
5** you may not use this file except in compliance with the License.
6** You may obtain a copy of the License at
Mike Lockwood94afecf2012-10-24 10:45:23 -07007**
Dave Allisond9370732014-01-30 14:19:23 -08008** http://www.apache.org/licenses/LICENSE-2.0
Mike Lockwood94afecf2012-10-24 10:45:23 -07009**
Dave Allisond9370732014-01-30 14:19:23 -080010** Unless required by applicable law or agreed to in writing, software
11** distributed under the License is distributed on an "AS IS" BASIS,
12** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13** See the License for the specific language governing permissions and
Mike Lockwood94afecf2012-10-24 10:45:23 -070014** limitations under the License.
15*/
16
Jeff Sharkeyf3e30b92016-12-09 17:06:57 -070017#include "InstalldNativeService.h"
Andreas Gampe02d0de52015-11-11 20:43:16 -080018
Jeff Sharkey466459b2017-01-17 15:25:01 -070019#define ATRACE_TAG ATRACE_TAG_PACKAGE_MANAGER
20
Andreas Gampe02d0de52015-11-11 20:43:16 -080021#include <errno.h>
22#include <inttypes.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070023#include <fstream>
24#include <fts.h>
Andreas Gampe0354bd02016-06-27 14:25:30 -070025#include <regex>
Andreas Gampe02d0de52015-11-11 20:43:16 -080026#include <stdlib.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070027#include <string.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080028#include <sys/capability.h>
29#include <sys/file.h>
30#include <sys/resource.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070031#include <sys/quota.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080032#include <sys/stat.h>
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070033#include <sys/statvfs.h>
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070034#include <sys/types.h>
Calin Juravle6a1648e2016-02-01 12:12:16 +000035#include <sys/wait.h>
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070036#include <sys/xattr.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080037#include <unistd.h>
Jeff Sharkey41ea4242015-04-09 11:34:03 -070038
Andreas Gampeafa58d12016-06-03 16:09:32 -070039#include <android-base/logging.h>
Elliott Hughese4ec9eb2015-12-04 15:39:32 -080040#include <android-base/stringprintf.h>
David Sehr6727c2d2016-05-17 16:06:22 -070041#include <android-base/strings.h>
Roland Levillain64b59cc2016-04-05 16:41:12 +010042#include <android-base/unique_fd.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080043#include <cutils/fs.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070044#include <cutils/properties.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070045#include <cutils/sched_policy.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070046#include <log/log.h> // TODO: Move everything to base/logging.
Jeff Sharkeye3637242015-04-08 20:56:42 -070047#include <logwrap/logwrap.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080048#include <private/android_filesystem_config.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070049#include <selinux/android.h>
Andreas Gampe02d0de52015-11-11 20:43:16 -080050#include <system/thread_defs.h>
Jeff Sharkey466459b2017-01-17 15:25:01 -070051#include <utils/Trace.h>
Jeff Sharkeye3637242015-04-08 20:56:42 -070052
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070053#include "dexopt.h"
Jeff Sharkeyf3e30b92016-12-09 17:06:57 -070054#include "globals.h"
55#include "installd_deps.h"
56#include "otapreopt_utils.h"
57#include "utils.h"
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070058
Jeff Sharkey88ddd942017-01-17 18:05:54 -070059#include "CacheTracker.h"
Jeff Sharkeydf2d7542017-01-07 09:19:35 -070060#include "MatchExtensionGen.h"
61
Andreas Gampe02d0de52015-11-11 20:43:16 -080062#ifndef LOG_TAG
63#define LOG_TAG "installd"
64#endif
Jeff Sharkey41ea4242015-04-09 11:34:03 -070065
66using android::base::StringPrintf;
Jeff Sharkey66b1a122017-01-16 20:57:45 -070067using std::endl;
Mike Lockwood94afecf2012-10-24 10:45:23 -070068
Andreas Gampe02d0de52015-11-11 20:43:16 -080069namespace android {
70namespace installd {
Mike Lockwood94afecf2012-10-24 10:45:23 -070071
Jeff Sharkeycc6281c2016-02-06 19:46:09 -070072static constexpr const char* kCpPath = "/system/bin/cp";
73static constexpr const char* kXattrDefault = "user.default";
Jeff Sharkeye3637242015-04-08 20:56:42 -070074
Janis Danisevskis40bd3ef2016-06-07 10:31:27 -070075static constexpr const int MIN_RESTRICTED_HOME_SDK_VERSION = 24; // > M
Janis Danisevskiseecb2d22016-01-12 14:45:55 +000076
Andreas Gampe0354bd02016-06-27 14:25:30 -070077static constexpr const char* PKG_LIB_POSTFIX = "/lib";
78static constexpr const char* CACHE_DIR_POSTFIX = "/cache";
79static constexpr const char* CODE_CACHE_DIR_POSTFIX = "/code_cache";
80
81static constexpr const char* IDMAP_PREFIX = "/data/resource-cache/";
82static constexpr const char* IDMAP_SUFFIX = "@idmap";
83
Andreas Gampe0354bd02016-06-27 14:25:30 -070084// NOTE: keep in sync with Installer
85static constexpr int FLAG_CLEAR_CACHE_ONLY = 1 << 8;
86static constexpr int FLAG_CLEAR_CODE_CACHE_ONLY = 1 << 9;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -070087static constexpr int FLAG_USE_QUOTA = 1 << 12;
Jeff Sharkey88ddd942017-01-17 18:05:54 -070088static constexpr int FLAG_FREE_CACHE_V2 = 1 << 13;
Jeff Sharkey871a8f22017-02-21 18:30:28 -070089static constexpr int FLAG_FREE_CACHE_V2_DEFY_QUOTA = 1 << 14;
90static constexpr int FLAG_FREE_CACHE_NOOP = 1 << 15;
Jeff Sharkeye12d5962017-04-03 16:41:02 -060091static constexpr int FLAG_FORCE = 1 << 16;
Calin Juravle6a1648e2016-02-01 12:12:16 +000092
Jeff Sharkey0274c972016-12-06 09:32:04 -070093namespace {
94
95constexpr const char* kDump = "android.permission.DUMP";
96
Jeff Sharkey423e7462016-12-09 18:18:43 -070097static binder::Status ok() {
98 return binder::Status::ok();
99}
100
101static binder::Status exception(uint32_t code, const std::string& msg) {
102 return binder::Status::fromExceptionCode(code, String8(msg.c_str()));
103}
104
105static binder::Status error() {
106 return binder::Status::fromServiceSpecificError(errno);
107}
108
109static binder::Status error(const std::string& msg) {
110 PLOG(ERROR) << msg;
111 return binder::Status::fromServiceSpecificError(errno, String8(msg.c_str()));
112}
113
114static binder::Status error(uint32_t code, const std::string& msg) {
115 LOG(ERROR) << msg << " (" << code << ")";
116 return binder::Status::fromServiceSpecificError(code, String8(msg.c_str()));
117}
118
Jeff Sharkey0274c972016-12-06 09:32:04 -0700119binder::Status checkPermission(const char* permission) {
120 pid_t pid;
121 uid_t uid;
122
123 if (checkCallingPermission(String16(permission), reinterpret_cast<int32_t*>(&pid),
124 reinterpret_cast<int32_t*>(&uid))) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700125 return ok();
Jeff Sharkey0274c972016-12-06 09:32:04 -0700126 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700127 return exception(binder::Status::EX_SECURITY,
128 StringPrintf("UID %d / PID %d lacks permission %s", uid, pid, permission));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700129 }
130}
131
132binder::Status checkUid(uid_t expectedUid) {
133 uid_t uid = IPCThreadState::self()->getCallingUid();
134 if (uid == expectedUid || uid == AID_ROOT) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700135 return ok();
Jeff Sharkey0274c972016-12-06 09:32:04 -0700136 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700137 return exception(binder::Status::EX_SECURITY,
138 StringPrintf("UID %d is not expected UID %d", uid, expectedUid));
139 }
140}
141
142binder::Status checkArgumentUuid(const std::unique_ptr<std::string>& uuid) {
143 if (!uuid || is_valid_filename(*uuid)) {
144 return ok();
145 } else {
146 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
147 StringPrintf("UUID %s is malformed", uuid->c_str()));
148 }
149}
150
151binder::Status checkArgumentPackageName(const std::string& packageName) {
152 if (is_valid_package_name(packageName.c_str())) {
153 return ok();
154 } else {
155 return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
156 StringPrintf("Package name %s is malformed", packageName.c_str()));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700157 }
158}
159
160#define ENFORCE_UID(uid) { \
161 binder::Status status = checkUid((uid)); \
162 if (!status.isOk()) { \
163 return status; \
164 } \
165}
166
Jeff Sharkey423e7462016-12-09 18:18:43 -0700167#define CHECK_ARGUMENT_UUID(uuid) { \
168 binder::Status status = checkArgumentUuid((uuid)); \
169 if (!status.isOk()) { \
170 return status; \
171 } \
172}
173
174#define CHECK_ARGUMENT_PACKAGE_NAME(packageName) { \
175 binder::Status status = \
176 checkArgumentPackageName((packageName)); \
177 if (!status.isOk()) { \
178 return status; \
179 } \
180}
181
Jeff Sharkey0274c972016-12-06 09:32:04 -0700182} // namespace
183
184status_t InstalldNativeService::start() {
185 IPCThreadState::self()->disableBackgroundScheduling(true);
186 status_t ret = BinderService<InstalldNativeService>::publish();
187 if (ret != android::OK) {
188 return ret;
189 }
190 sp<ProcessState> ps(ProcessState::self());
191 ps->startThreadPool();
192 ps->giveThreadPoolName();
193 return android::OK;
194}
195
196status_t InstalldNativeService::dump(int fd, const Vector<String16> & /* args */) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700197 auto out = std::fstream(StringPrintf("/proc/self/fd/%d", fd));
Jeff Sharkey0274c972016-12-06 09:32:04 -0700198 const binder::Status dump_permission = checkPermission(kDump);
199 if (!dump_permission.isOk()) {
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700200 out << dump_permission.toString8() << endl;
Jeff Sharkey0274c972016-12-06 09:32:04 -0700201 return PERMISSION_DENIED;
202 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700203 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey0274c972016-12-06 09:32:04 -0700204
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700205 out << "installd is happy!" << endl;
206
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700207 {
208 std::lock_guard<std::recursive_mutex> lock(mQuotaDevicesLock);
209 out << endl << "Devices with quota support:" << endl;
210 for (const auto& n : mQuotaDevices) {
211 out << " " << n.first << " = " << n.second << endl;
212 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700213 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700214
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700215 {
216 std::lock_guard<std::recursive_mutex> lock(mCacheQuotasLock);
217 out << endl << "Per-UID cache quotas:" << endl;
218 for (const auto& n : mCacheQuotas) {
219 out << " " << n.first << " = " << n.second << endl;
220 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700221 }
222
Jeff Sharkey66b1a122017-01-16 20:57:45 -0700223 out << endl;
224 out.flush();
225
Jeff Sharkey0274c972016-12-06 09:32:04 -0700226 return NO_ERROR;
227}
228
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600229/**
230 * Perform restorecon of the given path, but only perform recursive restorecon
231 * if the label of that top-level file actually changed. This can save us
232 * significant time by avoiding no-op traversals of large filesystem trees.
233 */
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700234static int restorecon_app_data_lazy(const std::string& path, const std::string& seInfo, uid_t uid,
235 bool existing) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600236 int res = 0;
237 char* before = nullptr;
238 char* after = nullptr;
239
240 // Note that SELINUX_ANDROID_RESTORECON_DATADATA flag is set by
241 // libselinux. Not needed here.
242
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600243 if (lgetfilecon(path.c_str(), &before) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600244 PLOG(ERROR) << "Failed before getfilecon for " << path;
245 goto fail;
246 }
Jeff Sharkey0274c972016-12-06 09:32:04 -0700247 if (selinux_android_restorecon_pkgdir(path.c_str(), seInfo.c_str(), uid, 0) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600248 PLOG(ERROR) << "Failed top-level restorecon for " << path;
249 goto fail;
250 }
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600251 if (lgetfilecon(path.c_str(), &after) < 0) {
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600252 PLOG(ERROR) << "Failed after getfilecon for " << path;
253 goto fail;
254 }
255
256 // If the initial top-level restorecon above changed the label, then go
257 // back and restorecon everything recursively
258 if (strcmp(before, after)) {
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700259 if (existing) {
260 LOG(DEBUG) << "Detected label change from " << before << " to " << after << " at "
261 << path << "; running recursive restorecon";
262 }
Jeff Sharkey0274c972016-12-06 09:32:04 -0700263 if (selinux_android_restorecon_pkgdir(path.c_str(), seInfo.c_str(), uid,
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600264 SELINUX_ANDROID_RESTORECON_RECURSE) < 0) {
265 PLOG(ERROR) << "Failed recursive restorecon for " << path;
266 goto fail;
267 }
268 }
269
270 goto done;
271fail:
272 res = -1;
273done:
274 free(before);
275 free(after);
276 return res;
277}
278
Jeff Sharkey0274c972016-12-06 09:32:04 -0700279static int restorecon_app_data_lazy(const std::string& parent, const char* name,
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700280 const std::string& seInfo, uid_t uid, bool existing) {
281 return restorecon_app_data_lazy(StringPrintf("%s/%s", parent.c_str(), name), seInfo, uid,
282 existing);
Jeff Sharkey8567ebf2016-10-31 11:22:19 -0600283}
284
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600285static int prepare_app_dir(const std::string& path, mode_t target_mode, uid_t uid) {
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600286 if (fs_prepare_dir_strict(path.c_str(), target_mode, uid, uid) != 0) {
287 PLOG(ERROR) << "Failed to prepare " << path;
288 return -1;
289 }
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600290 return 0;
291}
292
Jeff Sharkeye59c85c2017-04-02 21:53:14 -0600293/**
294 * Ensure that we have a hard-limit quota to protect against abusive apps;
295 * they should never use more than 90% of blocks or 50% of inodes.
296 */
297static int prepare_app_quota(const std::unique_ptr<std::string>& uuid, const std::string& device,
298 uid_t uid) {
299 if (device.empty()) return 0;
300
301 struct dqblk dq;
302 if (quotactl(QCMD(Q_GETQUOTA, USRQUOTA), device.c_str(), uid,
303 reinterpret_cast<char*>(&dq)) != 0) {
304 PLOG(WARNING) << "Failed to find quota for " << uid;
305 return -1;
306 }
307
308 if ((dq.dqb_bhardlimit == 0) || (dq.dqb_ihardlimit == 0)) {
309 auto path = create_data_path(uuid ? uuid->c_str() : nullptr);
310 struct statvfs stat;
311 if (statvfs(path.c_str(), &stat) != 0) {
312 PLOG(WARNING) << "Failed to statvfs " << path;
313 return -1;
314 }
315
316 dq.dqb_valid = QIF_LIMITS;
317 dq.dqb_bhardlimit = (((stat.f_blocks * stat.f_frsize) / 10) * 9) / QIF_DQBLKSIZE;
318 dq.dqb_ihardlimit = (stat.f_files / 2);
319 if (quotactl(QCMD(Q_SETQUOTA, USRQUOTA), device.c_str(), uid,
320 reinterpret_cast<char*>(&dq)) != 0) {
321 PLOG(WARNING) << "Failed to set hard quota for " << uid;
322 return -1;
323 } else {
324 LOG(DEBUG) << "Applied hard quotas for " << uid;
325 return 0;
326 }
327 } else {
328 // Hard quota already set; assume it's reasonable
329 return 0;
330 }
331}
332
Jeff Sharkey0274c972016-12-06 09:32:04 -0700333binder::Status InstalldNativeService::createAppData(const std::unique_ptr<std::string>& uuid,
334 const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700335 const std::string& seInfo, int32_t targetSdkVersion, int64_t* _aidl_return) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700336 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700337 CHECK_ARGUMENT_UUID(uuid);
338 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700339 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey0274c972016-12-06 09:32:04 -0700340
341 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
342 const char* pkgname = packageName.c_str();
343
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700344 // Assume invalid inode unless filled in below
345 if (_aidl_return != nullptr) *_aidl_return = -1;
346
Jeff Sharkey24ef15b2017-01-12 19:27:03 -0700347 int32_t uid = multiuser_get_uid(userId, appId);
348 int32_t cacheGid = multiuser_get_cache_gid(userId, appId);
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -0700349 mode_t targetMode = targetSdkVersion >= MIN_RESTRICTED_HOME_SDK_VERSION ? 0700 : 0751;
350
Jeff Sharkey24ef15b2017-01-12 19:27:03 -0700351 // If UID doesn't have a specific cache GID, use UID value
352 if (cacheGid == -1) {
353 cacheGid = uid;
354 }
355
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700356 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700357 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname);
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700358 bool existing = (access(path.c_str(), F_OK) == 0);
359
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -0700360 if (prepare_app_dir(path, targetMode, uid) ||
361 prepare_app_cache_dir(path, "cache", 02771, uid, cacheGid) ||
362 prepare_app_cache_dir(path, "code_cache", 02771, uid, cacheGid)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700363 return error("Failed to prepare " + path);
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600364 }
365
366 // Consider restorecon over contents if label changed
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700367 if (restorecon_app_data_lazy(path, seInfo, uid, existing) ||
368 restorecon_app_data_lazy(path, "cache", seInfo, uid, existing) ||
369 restorecon_app_data_lazy(path, "code_cache", seInfo, uid, existing)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700370 return error("Failed to restorecon " + path);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700371 }
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600372
373 // Remember inode numbers of cache directories so that we can clear
374 // contents while CE storage is locked
375 if (write_path_inode(path, "cache", kXattrInodeCache) ||
376 write_path_inode(path, "code_cache", kXattrInodeCodeCache)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700377 return error("Failed to write_path_inode for " + path);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700378 }
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700379
380 // And return the CE inode of the top-level data directory so we can
381 // clear contents while CE storage is locked
382 if ((_aidl_return != nullptr)
383 && get_path_inode(path, reinterpret_cast<ino_t*>(_aidl_return)) != 0) {
384 return error("Failed to get_path_inode for " + path);
385 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700386 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700387 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey0274c972016-12-06 09:32:04 -0700388 auto path = create_data_user_de_package_path(uuid_, userId, pkgname);
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700389 bool existing = (access(path.c_str(), F_OK) == 0);
390
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -0700391 if (prepare_app_dir(path, targetMode, uid) ||
392 prepare_app_cache_dir(path, "cache", 02771, uid, cacheGid) ||
393 prepare_app_cache_dir(path, "code_cache", 02771, uid, cacheGid)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700394 return error("Failed to prepare " + path);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700395 }
Calin Juravle6a1648e2016-02-01 12:12:16 +0000396
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600397 // Consider restorecon over contents if label changed
Jeff Sharkey35b83df2016-12-21 09:33:55 -0700398 if (restorecon_app_data_lazy(path, seInfo, uid, existing)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700399 return error("Failed to restorecon " + path);
Jeff Sharkey22f6fd52016-09-20 18:21:42 -0600400 }
401
Jeff Sharkeye59c85c2017-04-02 21:53:14 -0600402 if (prepare_app_quota(uuid, findQuotaDeviceForUuid(uuid), uid)) {
403 return error("Failed to set hard quota " + path);
404 }
405
Jeff Sharkey90aff262016-12-12 14:28:24 -0700406 if (property_get_bool("dalvik.vm.usejitprofiles", false)) {
Calin Juravle114f0812017-03-08 19:05:07 -0800407 const std::string profile_dir =
408 create_primary_current_profile_package_dir_path(userId, pkgname);
Calin Juravle6a1648e2016-02-01 12:12:16 +0000409 // read-write-execute only for the app user.
Calin Juravle114f0812017-03-08 19:05:07 -0800410 if (fs_prepare_dir_strict(profile_dir.c_str(), 0700, uid, uid) != 0) {
411 return error("Failed to prepare " + profile_dir);
Calin Juravle6a1648e2016-02-01 12:12:16 +0000412 }
Calin Juravle114f0812017-03-08 19:05:07 -0800413 const std::string profile_file = create_current_profile_path(userId, pkgname,
414 /*is_secondary_dex*/false);
Calin Juravlebc56e7d2016-05-24 15:33:12 +0100415 // read-write only for the app user.
416 if (fs_prepare_file_strict(profile_file.c_str(), 0600, uid, uid) != 0) {
Calin Juravle114f0812017-03-08 19:05:07 -0800417 return error("Failed to prepare " + profile_file);
Calin Juravlebc56e7d2016-05-24 15:33:12 +0100418 }
Calin Juravle114f0812017-03-08 19:05:07 -0800419 const std::string ref_profile_path =
420 create_primary_reference_profile_package_dir_path(pkgname);
Calin Juravle6a1648e2016-02-01 12:12:16 +0000421 // dex2oat/profman runs under the shared app gid and it needs to read/write reference
422 // profiles.
Jeff Sharkeyadddd982017-01-03 14:33:50 -0700423 int shared_app_gid = multiuser_get_shared_gid(0, appId);
Jeff Sharkey2e6dc9b2016-12-15 14:50:11 -0700424 if ((shared_app_gid != -1) && fs_prepare_dir_strict(
Calin Juravle6a1648e2016-02-01 12:12:16 +0000425 ref_profile_path.c_str(), 0700, shared_app_gid, shared_app_gid) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700426 return error("Failed to prepare " + ref_profile_path);
Calin Juravle6a1648e2016-02-01 12:12:16 +0000427 }
428 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700429 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700430 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -0700431}
432
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700433binder::Status InstalldNativeService::migrateAppData(const std::unique_ptr<std::string>& uuid,
434 const std::string& packageName, int32_t userId, int32_t flags) {
435 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700436 CHECK_ARGUMENT_UUID(uuid);
437 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700438 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700439
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700440 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
441 const char* pkgname = packageName.c_str();
442
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700443 // This method only exists to upgrade system apps that have requested
444 // forceDeviceEncrypted, so their default storage always lives in a
445 // consistent location. This only works on non-FBE devices, since we
446 // never want to risk exposing data on a device with real CE/DE storage.
447
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700448 auto ce_path = create_data_user_ce_package_path(uuid_, userId, pkgname);
449 auto de_path = create_data_user_de_package_path(uuid_, userId, pkgname);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700450
451 // If neither directory is marked as default, assume CE is default
452 if (getxattr(ce_path.c_str(), kXattrDefault, nullptr, 0) == -1
453 && getxattr(de_path.c_str(), kXattrDefault, nullptr, 0) == -1) {
454 if (setxattr(ce_path.c_str(), kXattrDefault, nullptr, 0, 0) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700455 return error("Failed to mark default storage " + ce_path);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700456 }
457 }
458
459 // Migrate default data location if needed
460 auto target = (flags & FLAG_STORAGE_DE) ? de_path : ce_path;
461 auto source = (flags & FLAG_STORAGE_DE) ? ce_path : de_path;
462
463 if (getxattr(target.c_str(), kXattrDefault, nullptr, 0) == -1) {
464 LOG(WARNING) << "Requested default storage " << target
465 << " is not active; migrating from " << source;
466 if (delete_dir_contents_and_dir(target) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700467 return error("Failed to delete " + target);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700468 }
469 if (rename(source.c_str(), target.c_str()) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700470 return error("Failed to rename " + source + " to " + target);
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700471 }
472 }
473
Jeff Sharkey423e7462016-12-09 18:18:43 -0700474 return ok();
Jeff Sharkeycc6281c2016-02-06 19:46:09 -0700475}
476
Calin Juravle6a1648e2016-02-01 12:12:16 +0000477
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700478binder::Status InstalldNativeService::clearAppProfiles(const std::string& packageName) {
479 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700480 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700481 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700482
Jeff Sharkey423e7462016-12-09 18:18:43 -0700483 binder::Status res = ok();
Calin Juravle114f0812017-03-08 19:05:07 -0800484 if (!clear_primary_reference_profile(packageName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700485 res = error("Failed to clear reference profile for " + packageName);
486 }
Calin Juravle114f0812017-03-08 19:05:07 -0800487 if (!clear_primary_current_profiles(packageName)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700488 res = error("Failed to clear current profiles for " + packageName);
489 }
490 return res;
Calin Juravle6a1648e2016-02-01 12:12:16 +0000491}
492
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700493binder::Status InstalldNativeService::clearAppData(const std::unique_ptr<std::string>& uuid,
494 const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {
495 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700496 CHECK_ARGUMENT_UUID(uuid);
497 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700498 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700499
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700500 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
501 const char* pkgname = packageName.c_str();
502
Jeff Sharkey423e7462016-12-09 18:18:43 -0700503 binder::Status res = ok();
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700504 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700505 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInode);
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600506 if (flags & FLAG_CLEAR_CACHE_ONLY) {
507 path = read_path_inode(path, "cache", kXattrInodeCache);
508 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
509 path = read_path_inode(path, "code_cache", kXattrInodeCodeCache);
510 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700511 if (access(path.c_str(), F_OK) == 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700512 if (delete_dir_contents(path) != 0) {
513 res = error("Failed to delete contents of " + path);
514 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700515 }
516 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700517 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey1f6a7f12016-07-14 18:16:22 -0600518 std::string suffix = "";
519 bool only_cache = false;
520 if (flags & FLAG_CLEAR_CACHE_ONLY) {
521 suffix = CACHE_DIR_POSTFIX;
522 only_cache = true;
523 } else if (flags & FLAG_CLEAR_CODE_CACHE_ONLY) {
524 suffix = CODE_CACHE_DIR_POSTFIX;
525 only_cache = true;
526 }
527
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700528 auto path = create_data_user_de_package_path(uuid_, userId, pkgname) + suffix;
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700529 if (access(path.c_str(), F_OK) == 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700530 if (delete_dir_contents(path) != 0) {
531 res = error("Failed to delete contents of " + path);
532 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700533 }
Calin Juravleedae6692016-03-23 13:55:31 +0000534 if (!only_cache) {
Calin Juravle114f0812017-03-08 19:05:07 -0800535 if (!clear_primary_current_profile(packageName, userId)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700536 res = error("Failed to clear current profile for " + packageName);
Calin Juravleedae6692016-03-23 13:55:31 +0000537 }
538 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700539 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700540 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700541}
542
Calin Juravle76268c52017-03-09 13:19:42 -0800543static int destroy_app_reference_profile(const std::string& pkgname) {
Calin Juravle7535e8e2016-03-29 16:05:40 +0100544 return delete_dir_contents_and_dir(
Calin Juravle114f0812017-03-08 19:05:07 -0800545 create_primary_reference_profile_package_dir_path(pkgname),
Calin Juravle7535e8e2016-03-29 16:05:40 +0100546 /*ignore_if_missing*/ true);
547}
548
Calin Juravle76268c52017-03-09 13:19:42 -0800549static int destroy_app_current_profiles(const std::string& pkgname, userid_t userid) {
Calin Juravleb06f98a2016-03-28 15:11:01 +0100550 return delete_dir_contents_and_dir(
Calin Juravle114f0812017-03-08 19:05:07 -0800551 create_primary_current_profile_package_dir_path(userid, pkgname),
Calin Juravleb06f98a2016-03-28 15:11:01 +0100552 /*ignore_if_missing*/ true);
Calin Juravleedae6692016-03-23 13:55:31 +0000553}
554
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700555binder::Status InstalldNativeService::destroyAppProfiles(const std::string& packageName) {
556 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700557 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700558 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700559
Jeff Sharkey423e7462016-12-09 18:18:43 -0700560 binder::Status res = ok();
Calin Juravleedae6692016-03-23 13:55:31 +0000561 std::vector<userid_t> users = get_known_users(/*volume_uuid*/ nullptr);
562 for (auto user : users) {
Calin Juravle76268c52017-03-09 13:19:42 -0800563 if (destroy_app_current_profiles(packageName, user) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700564 res = error("Failed to destroy current profiles for " + packageName);
565 }
Calin Juravleedae6692016-03-23 13:55:31 +0000566 }
Calin Juravle76268c52017-03-09 13:19:42 -0800567 if (destroy_app_reference_profile(packageName) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700568 res = error("Failed to destroy reference profile for " + packageName);
569 }
570 return res;
Calin Juravlecaa6b802016-03-22 14:15:52 +0000571}
572
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700573binder::Status InstalldNativeService::destroyAppData(const std::unique_ptr<std::string>& uuid,
574 const std::string& packageName, int32_t userId, int32_t flags, int64_t ceDataInode) {
575 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700576 CHECK_ARGUMENT_UUID(uuid);
577 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700578 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700579
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700580 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
581 const char* pkgname = packageName.c_str();
582
Jeff Sharkey423e7462016-12-09 18:18:43 -0700583 binder::Status res = ok();
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700584 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700585 auto path = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInode);
586 if (delete_dir_contents_and_dir(path) != 0) {
587 res = error("Failed to delete " + path);
588 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700589 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -0700590 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700591 auto path = create_data_user_de_package_path(uuid_, userId, pkgname);
592 if (delete_dir_contents_and_dir(path) != 0) {
593 res = error("Failed to delete " + path);
594 }
Calin Juravle76268c52017-03-09 13:19:42 -0800595 destroy_app_current_profiles(packageName, userId);
Calin Juravle7535e8e2016-03-29 16:05:40 +0100596 // TODO(calin): If the package is still installed by other users it's probably
597 // beneficial to keep the reference profile around.
598 // Verify if it's ok to do that.
Calin Juravle76268c52017-03-09 13:19:42 -0800599 destroy_app_reference_profile(packageName);
Mike Lockwood94afecf2012-10-24 10:45:23 -0700600 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700601 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -0700602}
603
Jeff Sharkeye12d5962017-04-03 16:41:02 -0600604static gid_t get_cache_gid(uid_t uid) {
605 int32_t gid = multiuser_get_cache_gid(multiuser_get_user_id(uid), multiuser_get_app_id(uid));
606 return (gid != -1) ? gid : uid;
607}
608
609binder::Status InstalldNativeService::fixupAppData(const std::unique_ptr<std::string>& uuid,
610 int32_t flags) {
611 ENFORCE_UID(AID_SYSTEM);
612 CHECK_ARGUMENT_UUID(uuid);
613 std::lock_guard<std::recursive_mutex> lock(mLock);
614
615 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
616 for (auto user : get_known_users(uuid_)) {
617 ATRACE_BEGIN("fixup user");
618 FTS* fts;
619 FTSENT* p;
Jeff Sharkeyd9ff77f2017-04-14 18:54:49 -0600620 auto ce_path = create_data_user_ce_path(uuid_, user);
621 auto de_path = create_data_user_de_path(uuid_, user);
622 char *argv[] = { (char*) ce_path.c_str(), (char*) de_path.c_str(), nullptr };
Jeff Sharkeye12d5962017-04-03 16:41:02 -0600623 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, NULL))) {
624 return error("Failed to fts_open");
625 }
626 while ((p = fts_read(fts)) != nullptr) {
627 if (p->fts_info == FTS_D && p->fts_level == 1) {
628 // Track down inodes of cache directories
629 uint64_t raw = 0;
630 ino_t inode_cache = 0;
631 ino_t inode_code_cache = 0;
632 if (getxattr(p->fts_path, kXattrInodeCache, &raw, sizeof(raw)) == sizeof(raw)) {
633 inode_cache = raw;
634 }
635 if (getxattr(p->fts_path, kXattrInodeCodeCache, &raw, sizeof(raw)) == sizeof(raw)) {
636 inode_code_cache = raw;
637 }
638
639 // Figure out expected GID of each child
640 FTSENT* child = fts_children(fts, 0);
641 while (child != nullptr) {
642 if ((child->fts_statp->st_ino == inode_cache)
643 || (child->fts_statp->st_ino == inode_code_cache)
644 || !strcmp(child->fts_name, "cache")
645 || !strcmp(child->fts_name, "code_cache")) {
646 child->fts_number = get_cache_gid(p->fts_statp->st_uid);
647 } else {
648 child->fts_number = p->fts_statp->st_uid;
649 }
650 child = child->fts_link;
651 }
652 } else if (p->fts_level >= 2) {
653 if (p->fts_level > 2) {
654 // Inherit GID from parent once we're deeper into tree
655 p->fts_number = p->fts_parent->fts_number;
656 }
657
658 uid_t uid = p->fts_parent->fts_statp->st_uid;
659 gid_t cache_gid = get_cache_gid(uid);
660 gid_t expected = p->fts_number;
661 gid_t actual = p->fts_statp->st_gid;
662 if (actual == expected) {
663#if FIXUP_DEBUG
664 LOG(DEBUG) << "Ignoring " << p->fts_path << " with expected GID " << expected;
665#endif
666 if (!(flags & FLAG_FORCE)) {
667 fts_set(fts, p, FTS_SKIP);
668 }
669 } else if ((actual == uid) || (actual == cache_gid)) {
670 // Only consider fixing up when current GID belongs to app
671 if (p->fts_info != FTS_D) {
672 LOG(INFO) << "Fixing " << p->fts_path << " with unexpected GID " << actual
673 << " instead of " << expected;
674 }
675 switch (p->fts_info) {
676 case FTS_DP:
677 // If we're moving towards cache GID, we need to set S_ISGID
678 if (expected == cache_gid) {
679 if (chmod(p->fts_path, 02771) != 0) {
680 PLOG(WARNING) << "Failed to chmod " << p->fts_path;
681 }
682 }
683 // Intentional fall through to also set GID
684 case FTS_F:
685 if (chown(p->fts_path, -1, expected) != 0) {
686 PLOG(WARNING) << "Failed to chown " << p->fts_path;
687 }
688 break;
689 case FTS_SL:
690 case FTS_SLNONE:
691 if (lchown(p->fts_path, -1, expected) != 0) {
692 PLOG(WARNING) << "Failed to chown " << p->fts_path;
693 }
694 break;
695 }
696 } else {
697 // Ignore all other GID transitions, since they're kinda shady
698 LOG(WARNING) << "Ignoring " << p->fts_path << " with unexpected GID " << actual
699 << " instead of " << expected;
700 }
701 }
702 }
703 fts_close(fts);
704 ATRACE_END();
705 }
706 return ok();
707}
708
Jeff Sharkey0274c972016-12-06 09:32:04 -0700709binder::Status InstalldNativeService::moveCompleteApp(const std::unique_ptr<std::string>& fromUuid,
710 const std::unique_ptr<std::string>& toUuid, const std::string& packageName,
711 const std::string& dataAppName, int32_t appId, const std::string& seInfo,
712 int32_t targetSdkVersion) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700713 ENFORCE_UID(AID_SYSTEM);
714 CHECK_ARGUMENT_UUID(fromUuid);
715 CHECK_ARGUMENT_UUID(toUuid);
716 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700717 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey0274c972016-12-06 09:32:04 -0700718
719 const char* from_uuid = fromUuid ? fromUuid->c_str() : nullptr;
720 const char* to_uuid = toUuid ? toUuid->c_str() : nullptr;
721 const char* package_name = packageName.c_str();
722 const char* data_app_name = dataAppName.c_str();
Jeff Sharkey0274c972016-12-06 09:32:04 -0700723
Jeff Sharkey423e7462016-12-09 18:18:43 -0700724 binder::Status res = ok();
Jeff Sharkeye3637242015-04-08 20:56:42 -0700725 std::vector<userid_t> users = get_known_users(from_uuid);
726
Jeff Sharkeyd7921182015-04-30 15:58:19 -0700727 // Copy app
728 {
Jeff Sharkey51c94492016-05-10 17:46:39 -0600729 auto from = create_data_app_package_path(from_uuid, data_app_name);
730 auto to = create_data_app_package_path(to_uuid, data_app_name);
731 auto to_parent = create_data_app_path(to_uuid);
Jeff Sharkeyd7921182015-04-30 15:58:19 -0700732
733 char *argv[] = {
734 (char*) kCpPath,
735 (char*) "-F", /* delete any existing destination file first (--remove-destination) */
736 (char*) "-p", /* preserve timestamps, ownership, and permissions */
737 (char*) "-R", /* recurse into subdirectories (DEST must be a directory) */
738 (char*) "-P", /* Do not follow symlinks [default] */
739 (char*) "-d", /* don't dereference symlinks */
740 (char*) from.c_str(),
741 (char*) to_parent.c_str()
742 };
743
744 LOG(DEBUG) << "Copying " << from << " to " << to;
745 int rc = android_fork_execvp(ARRAY_SIZE(argv), argv, NULL, false, true);
Jeff Sharkeyd7921182015-04-30 15:58:19 -0700746 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700747 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkeyd7921182015-04-30 15:58:19 -0700748 goto fail;
749 }
750
751 if (selinux_android_restorecon(to.c_str(), SELINUX_ANDROID_RESTORECON_RECURSE) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700752 res = error("Failed to restorecon " + to);
Jeff Sharkeyd7921182015-04-30 15:58:19 -0700753 goto fail;
754 }
755 }
756
757 // Copy private data for all known users
Jeff Sharkeye3637242015-04-08 20:56:42 -0700758 for (auto user : users) {
Jeff Sharkeye3637242015-04-08 20:56:42 -0700759
760 // Data source may not exist for all users; that's okay
Jeff Sharkey51c94492016-05-10 17:46:39 -0600761 auto from_ce = create_data_user_ce_package_path(from_uuid, user, package_name);
762 if (access(from_ce.c_str(), F_OK) != 0) {
763 LOG(INFO) << "Missing source " << from_ce;
Jeff Sharkeye3637242015-04-08 20:56:42 -0700764 continue;
765 }
766
Jeff Sharkey0274c972016-12-06 09:32:04 -0700767 if (!createAppData(toUuid, packageName, user, FLAG_STORAGE_CE | FLAG_STORAGE_DE, appId,
Jeff Sharkey36a900a2016-12-19 16:39:18 -0700768 seInfo, targetSdkVersion, nullptr).isOk()) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700769 res = error("Failed to create package target");
Jeff Sharkeye3637242015-04-08 20:56:42 -0700770 goto fail;
771 }
772
773 char *argv[] = {
774 (char*) kCpPath,
775 (char*) "-F", /* delete any existing destination file first (--remove-destination) */
776 (char*) "-p", /* preserve timestamps, ownership, and permissions */
777 (char*) "-R", /* recurse into subdirectories (DEST must be a directory) */
778 (char*) "-P", /* Do not follow symlinks [default] */
779 (char*) "-d", /* don't dereference symlinks */
Jeff Sharkey51c94492016-05-10 17:46:39 -0600780 nullptr,
781 nullptr
Jeff Sharkeye3637242015-04-08 20:56:42 -0700782 };
783
Jeff Sharkey51c94492016-05-10 17:46:39 -0600784 {
785 auto from = create_data_user_de_package_path(from_uuid, user, package_name);
786 auto to = create_data_user_de_path(to_uuid, user);
787 argv[6] = (char*) from.c_str();
788 argv[7] = (char*) to.c_str();
Jeff Sharkeye3637242015-04-08 20:56:42 -0700789
Jeff Sharkey51c94492016-05-10 17:46:39 -0600790 LOG(DEBUG) << "Copying " << from << " to " << to;
791 int rc = android_fork_execvp(ARRAY_SIZE(argv), argv, NULL, false, true);
792 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700793 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkey51c94492016-05-10 17:46:39 -0600794 goto fail;
795 }
796 }
797 {
798 auto from = create_data_user_ce_package_path(from_uuid, user, package_name);
799 auto to = create_data_user_ce_path(to_uuid, user);
800 argv[6] = (char*) from.c_str();
801 argv[7] = (char*) to.c_str();
802
803 LOG(DEBUG) << "Copying " << from << " to " << to;
804 int rc = android_fork_execvp(ARRAY_SIZE(argv), argv, NULL, false, true);
805 if (rc != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700806 res = error(rc, "Failed copying " + from + " to " + to);
Jeff Sharkey51c94492016-05-10 17:46:39 -0600807 goto fail;
808 }
Jeff Sharkeye3637242015-04-08 20:56:42 -0700809 }
810
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700811 if (!restoreconAppData(toUuid, packageName, user, FLAG_STORAGE_CE | FLAG_STORAGE_DE,
812 appId, seInfo).isOk()) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700813 res = error("Failed to restorecon");
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -0700814 goto fail;
815 }
Jeff Sharkeye3637242015-04-08 20:56:42 -0700816 }
817
Jeff Sharkey31f08982015-07-07 13:31:37 -0700818 // We let the framework scan the new location and persist that before
819 // deleting the data in the old location; this ordering ensures that
820 // we can recover from things like battery pulls.
Jeff Sharkey423e7462016-12-09 18:18:43 -0700821 return ok();
Jeff Sharkeye3637242015-04-08 20:56:42 -0700822
823fail:
824 // Nuke everything we might have already copied
Jeff Sharkeyd7921182015-04-30 15:58:19 -0700825 {
Jeff Sharkey51c94492016-05-10 17:46:39 -0600826 auto to = create_data_app_package_path(to_uuid, data_app_name);
Jeff Sharkeyd7921182015-04-30 15:58:19 -0700827 if (delete_dir_contents(to.c_str(), 1, NULL) != 0) {
828 LOG(WARNING) << "Failed to rollback " << to;
829 }
830 }
Jeff Sharkeye3637242015-04-08 20:56:42 -0700831 for (auto user : users) {
Jeff Sharkey51c94492016-05-10 17:46:39 -0600832 {
833 auto to = create_data_user_de_package_path(to_uuid, user, package_name);
834 if (delete_dir_contents(to.c_str(), 1, NULL) != 0) {
835 LOG(WARNING) << "Failed to rollback " << to;
836 }
837 }
838 {
839 auto to = create_data_user_ce_package_path(to_uuid, user, package_name);
840 if (delete_dir_contents(to.c_str(), 1, NULL) != 0) {
841 LOG(WARNING) << "Failed to rollback " << to;
842 }
Jeff Sharkeye3637242015-04-08 20:56:42 -0700843 }
844 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700845 return res;
Jeff Sharkeye3637242015-04-08 20:56:42 -0700846}
847
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700848binder::Status InstalldNativeService::createUserData(const std::unique_ptr<std::string>& uuid,
849 int32_t userId, int32_t userSerial ATTRIBUTE_UNUSED, int32_t flags) {
850 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700851 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700852 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700853
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700854 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey379a12b2016-04-14 20:45:06 -0600855 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700856 if (uuid_ == nullptr) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700857 if (ensure_config_user_dirs(userId) != 0) {
Jeff Sharkey7be5ead2016-12-12 13:18:46 -0700858 return error(StringPrintf("Failed to ensure dirs for %d", userId));
Jeff Sharkey423e7462016-12-09 18:18:43 -0700859 }
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700860 }
861 }
Jeff Sharkeye59c85c2017-04-02 21:53:14 -0600862
863 // Data under /data/media doesn't have an app, but we still want
864 // to limit it to prevent abuse.
865 if (prepare_app_quota(uuid, findQuotaDeviceForUuid(uuid),
866 multiuser_get_uid(userId, AID_MEDIA_RW))) {
867 return error("Failed to set hard quota for media_rw");
868 }
869
Jeff Sharkey7be5ead2016-12-12 13:18:46 -0700870 return ok();
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700871}
872
873binder::Status InstalldNativeService::destroyUserData(const std::unique_ptr<std::string>& uuid,
874 int32_t userId, int32_t flags) {
875 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700876 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700877 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700878
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700879 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey423e7462016-12-09 18:18:43 -0700880 binder::Status res = ok();
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700881 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700882 auto path = create_data_user_de_path(uuid_, userId);
883 if (delete_dir_contents_and_dir(path, true) != 0) {
884 res = error("Failed to delete " + path);
885 }
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -0700886 if (uuid_ == nullptr) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700887 path = create_data_misc_legacy_path(userId);
888 if (delete_dir_contents_and_dir(path, true) != 0) {
889 res = error("Failed to delete " + path);
890 }
Calin Juravle114f0812017-03-08 19:05:07 -0800891 path = create_primary_cur_profile_dir_path(userId);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700892 if (delete_dir_contents_and_dir(path, true) != 0) {
893 res = error("Failed to delete " + path);
894 }
Jeff Sharkey41ea4242015-04-09 11:34:03 -0700895 }
Robin Lee095c7632014-04-25 15:05:19 +0100896 }
Jeff Sharkey379a12b2016-04-14 20:45:06 -0600897 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700898 auto path = create_data_user_ce_path(uuid_, userId);
899 if (delete_dir_contents_and_dir(path, true) != 0) {
900 res = error("Failed to delete " + path);
901 }
902 path = create_data_media_path(uuid_, userId);
903 if (delete_dir_contents_and_dir(path, true) != 0) {
904 res = error("Failed to delete " + path);
905 }
Jeff Sharkey379a12b2016-04-14 20:45:06 -0600906 }
Jeff Sharkey423e7462016-12-09 18:18:43 -0700907 return res;
Robin Lee095c7632014-04-25 15:05:19 +0100908}
909
Mike Lockwood94afecf2012-10-24 10:45:23 -0700910/* Try to ensure free_size bytes of storage are available.
911 * Returns 0 on success.
912 * This is rather simple-minded because doing a full LRU would
913 * be potentially memory-intensive, and without atime it would
914 * also require that apps constantly modify file metadata even
915 * when just reading from the cache, which is pretty awful.
916 */
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700917binder::Status InstalldNativeService::freeCache(const std::unique_ptr<std::string>& uuid,
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700918 int64_t freeStorageSize, int32_t flags) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700919 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700920 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -0700921 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -0700922
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700923 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700924 auto data_path = create_data_path(uuid_);
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700925 auto device = findQuotaDeviceForUuid(uuid);
926 auto noop = (flags & FLAG_FREE_CACHE_NOOP);
Jeff Sharkey41ea4242015-04-09 11:34:03 -0700927
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700928 int64_t free = data_disk_free(data_path);
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700929 if (free < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -0700930 return error("Failed to determine free space for " + data_path);
Jeff Sharkey475c6f92016-12-07 10:37:27 -0700931 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700932
Jeff Sharkeyed909ae2017-03-22 21:27:40 -0600933 int64_t needed = freeStorageSize - free;
934 LOG(DEBUG) << "Device " << data_path << " has " << free << " free; requested "
935 << freeStorageSize << "; needed " << needed;
936
937 if (free >= freeStorageSize) {
938 return ok();
939 }
Mike Lockwood94afecf2012-10-24 10:45:23 -0700940
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700941 if (flags & FLAG_FREE_CACHE_V2) {
942 // This new cache strategy fairly removes files from UIDs by deleting
943 // files from the UIDs which are most over their allocated quota
944
945 // 1. Create trackers for every known UID
946 ATRACE_BEGIN("create");
947 std::unordered_map<uid_t, std::shared_ptr<CacheTracker>> trackers;
948 for (auto user : get_known_users(uuid_)) {
949 FTS *fts;
950 FTSENT *p;
Jeff Sharkeyd9ff77f2017-04-14 18:54:49 -0600951 auto ce_path = create_data_user_ce_path(uuid_, user);
952 auto de_path = create_data_user_de_path(uuid_, user);
953 char *argv[] = { (char*) ce_path.c_str(), (char*) de_path.c_str(), nullptr };
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700954 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, NULL))) {
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700955 return error("Failed to fts_open");
956 }
957 while ((p = fts_read(fts)) != NULL) {
958 if (p->fts_info == FTS_D && p->fts_level == 1) {
959 uid_t uid = p->fts_statp->st_uid;
960 auto search = trackers.find(uid);
961 if (search != trackers.end()) {
962 search->second->addDataPath(p->fts_path);
963 } else {
964 auto tracker = std::shared_ptr<CacheTracker>(new CacheTracker(
965 multiuser_get_user_id(uid), multiuser_get_app_id(uid), device));
966 tracker->addDataPath(p->fts_path);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -0700967 {
968 std::lock_guard<std::recursive_mutex> lock(mCacheQuotasLock);
969 tracker->cacheQuota = mCacheQuotas[uid];
970 }
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700971 if (tracker->cacheQuota == 0) {
Jeff Sharkeyed909ae2017-03-22 21:27:40 -0600972#if MEASURE_DEBUG
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700973 LOG(WARNING) << "UID " << uid << " has no cache quota; assuming 64MB";
Jeff Sharkeyed909ae2017-03-22 21:27:40 -0600974#endif
Jeff Sharkey88ddd942017-01-17 18:05:54 -0700975 tracker->cacheQuota = 67108864;
976 }
977 trackers[uid] = tracker;
978 }
979 fts_set(fts, p, FTS_SKIP);
980 }
981 }
982 fts_close(fts);
983 }
984 ATRACE_END();
985
986 // 2. Populate tracker stats and insert into priority queue
987 ATRACE_BEGIN("populate");
988 auto cmp = [](std::shared_ptr<CacheTracker> left, std::shared_ptr<CacheTracker> right) {
989 return (left->getCacheRatio() < right->getCacheRatio());
990 };
991 std::priority_queue<std::shared_ptr<CacheTracker>,
992 std::vector<std::shared_ptr<CacheTracker>>, decltype(cmp)> queue(cmp);
993 for (const auto& it : trackers) {
994 it.second->loadStats();
995 queue.push(it.second);
996 }
997 ATRACE_END();
998
999 // 3. Bounce across the queue, freeing items from whichever tracker is
1000 // the most over their assigned quota
1001 ATRACE_BEGIN("bounce");
1002 std::shared_ptr<CacheTracker> active;
1003 while (active || !queue.empty()) {
Jeff Sharkey871a8f22017-02-21 18:30:28 -07001004 // Only look at apps under quota when explicitly requested
1005 if (active && (active->getCacheRatio() < 10000)
1006 && !(flags & FLAG_FREE_CACHE_V2_DEFY_QUOTA)) {
1007 LOG(DEBUG) << "Active ratio " << active->getCacheRatio()
1008 << " isn't over quota, and defy not requested";
1009 break;
1010 }
1011
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001012 // Find the best tracker to work with; this might involve swapping
1013 // if the active tracker is no longer the most over quota
1014 bool nextBetter = active && !queue.empty()
1015 && active->getCacheRatio() < queue.top()->getCacheRatio();
1016 if (!active || nextBetter) {
1017 if (active) {
1018 // Current tracker still has items, so we'll consider it
1019 // again later once it bubbles up to surface
1020 queue.push(active);
1021 }
1022 active = queue.top(); queue.pop();
1023 active->ensureItems();
1024 continue;
1025 }
1026
1027 // If no items remain, go find another tracker
1028 if (active->items.empty()) {
1029 active = nullptr;
1030 continue;
1031 } else {
1032 auto item = active->items.back();
1033 active->items.pop_back();
1034
1035 LOG(DEBUG) << "Purging " << item->toString() << " from " << active->toString();
1036 if (!noop) {
1037 item->purge();
1038 }
1039 active->cacheUsed -= item->size;
1040 needed -= item->size;
1041 }
1042
1043 // Verify that we're actually done before bailing, since sneaky
1044 // apps might be using hardlinks
1045 if (needed <= 0) {
1046 free = data_disk_free(data_path);
1047 needed = freeStorageSize - free;
1048 if (needed <= 0) {
1049 break;
1050 } else {
1051 LOG(WARNING) << "Expected to be done but still need " << needed;
1052 }
1053 }
1054 }
1055 ATRACE_END();
1056
1057 } else {
Jeff Sharkey1cb4aaf2017-03-27 16:41:06 -06001058 return error("Legacy cache logic no longer supported");
Mike Lockwood94afecf2012-10-24 10:45:23 -07001059 }
1060
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001061 free = data_disk_free(data_path);
1062 if (free >= freeStorageSize) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001063 return ok();
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001064 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001065 return error(StringPrintf("Failed to free up %" PRId64 " on %s; final free space %" PRId64,
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001066 freeStorageSize, data_path.c_str(), free));
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001067 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001068}
1069
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001070binder::Status InstalldNativeService::rmdex(const std::string& codePath,
1071 const std::string& instructionSet) {
1072 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001073 std::lock_guard<std::recursive_mutex> lock(mLock);
1074
Mike Lockwood94afecf2012-10-24 10:45:23 -07001075 char dex_path[PKG_PATH_MAX];
1076
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001077 const char* path = codePath.c_str();
1078 const char* instruction_set = instructionSet.c_str();
1079
Jeff Sharkey770180a2014-09-08 17:14:26 -07001080 if (validate_apk_path(path) && validate_system_app_path(path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001081 return error("Invalid path " + codePath);
Jeff Sharkey770180a2014-09-08 17:14:26 -07001082 }
1083
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001084 if (!create_cache_path(dex_path, path, instruction_set)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001085 return error("Failed to create cache path for " + codePath);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001086 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001087
1088 ALOGV("unlink %s\n", dex_path);
1089 if (unlink(dex_path) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001090 return error(StringPrintf("Failed to unlink %s", dex_path));
Mike Lockwood94afecf2012-10-24 10:45:23 -07001091 } else {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001092 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001093 }
1094}
1095
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001096struct stats {
1097 int64_t codeSize;
1098 int64_t dataSize;
1099 int64_t cacheSize;
1100};
1101
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001102#if MEASURE_DEBUG
1103static std::string toString(std::vector<int64_t> values) {
1104 std::stringstream res;
1105 res << "[";
1106 for (size_t i = 0; i < values.size(); i++) {
1107 res << values[i];
1108 if (i < values.size() - 1) {
1109 res << ",";
1110 }
1111 }
1112 res << "]";
1113 return res.str();
1114}
1115#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001116
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001117static void collectQuotaStats(const std::string& device, int32_t userId,
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001118 int32_t appId, struct stats* stats, struct stats* extStats) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001119 if (device.empty()) return;
1120
1121 struct dqblk dq;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001122
1123 uid_t uid = multiuser_get_uid(userId, appId);
1124 if (quotactl(QCMD(Q_GETQUOTA, USRQUOTA), device.c_str(), uid,
1125 reinterpret_cast<char*>(&dq)) != 0) {
1126 if (errno != ESRCH) {
1127 PLOG(ERROR) << "Failed to quotactl " << device << " for UID " << uid;
1128 }
1129 } else {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001130#if MEASURE_DEBUG
1131 LOG(DEBUG) << "quotactl() for UID " << uid << " " << dq.dqb_curspace;
1132#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001133 stats->dataSize += dq.dqb_curspace;
1134 }
1135
1136 int cacheGid = multiuser_get_cache_gid(userId, appId);
1137 if (cacheGid != -1) {
1138 if (quotactl(QCMD(Q_GETQUOTA, GRPQUOTA), device.c_str(), cacheGid,
1139 reinterpret_cast<char*>(&dq)) != 0) {
1140 if (errno != ESRCH) {
1141 PLOG(ERROR) << "Failed to quotactl " << device << " for GID " << cacheGid;
1142 }
1143 } else {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001144#if MEASURE_DEBUG
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001145 LOG(DEBUG) << "quotactl() for GID " << cacheGid << " " << dq.dqb_curspace;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001146#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001147 stats->cacheSize += dq.dqb_curspace;
1148 }
1149 }
1150
Jeff Sharkeyec1be622017-04-10 00:19:46 -06001151#if HACK_FOR_37193650
1152 extStats->dataSize = extStats->dataSize;
1153#else
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001154 int extGid = multiuser_get_ext_gid(userId, appId);
1155 if (extGid != -1) {
1156 if (quotactl(QCMD(Q_GETQUOTA, GRPQUOTA), device.c_str(), extGid,
1157 reinterpret_cast<char*>(&dq)) != 0) {
1158 if (errno != ESRCH) {
1159 PLOG(ERROR) << "Failed to quotactl " << device << " for GID " << extGid;
1160 }
1161 } else {
1162#if MEASURE_DEBUG
1163 LOG(DEBUG) << "quotactl() for GID " << extGid << " " << dq.dqb_curspace;
1164#endif
1165 extStats->dataSize += dq.dqb_curspace;
1166 }
1167 }
Jeff Sharkeyec1be622017-04-10 00:19:46 -06001168#endif
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001169
1170 int sharedGid = multiuser_get_shared_gid(userId, appId);
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001171 if (sharedGid != -1) {
1172 if (quotactl(QCMD(Q_GETQUOTA, GRPQUOTA), device.c_str(), sharedGid,
1173 reinterpret_cast<char*>(&dq)) != 0) {
1174 if (errno != ESRCH) {
1175 PLOG(ERROR) << "Failed to quotactl " << device << " for GID " << sharedGid;
1176 }
1177 } else {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001178#if MEASURE_DEBUG
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001179 LOG(DEBUG) << "quotactl() for GID " << sharedGid << " " << dq.dqb_curspace;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001180#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001181 stats->codeSize += dq.dqb_curspace;
1182 }
1183 }
1184}
1185
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001186static void collectManualStats(const std::string& path, struct stats* stats) {
Mike Lockwood94afecf2012-10-24 10:45:23 -07001187 DIR *d;
1188 int dfd;
1189 struct dirent *de;
1190 struct stat s;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001191
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001192 d = opendir(path.c_str());
1193 if (d == nullptr) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001194 if (errno != ENOENT) {
1195 PLOG(WARNING) << "Failed to open " << path;
1196 }
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001197 return;
1198 }
1199 dfd = dirfd(d);
1200 while ((de = readdir(d))) {
1201 const char *name = de->d_name;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001202
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001203 int64_t size = 0;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001204 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) == 0) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001205 size = s.st_blocks * 512;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001206 }
1207
1208 if (de->d_type == DT_DIR) {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001209 if (!strcmp(name, ".")) {
1210 // Don't recurse, but still count node size
1211 } else if (!strcmp(name, "..")) {
1212 // Don't recurse or count node size
1213 continue;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001214 } else {
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001215 // Measure all children nodes
1216 size = 0;
1217 calculate_tree_size(StringPrintf("%s/%s", path.c_str(), name), &size);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001218 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001219
1220 if (!strcmp(name, "cache") || !strcmp(name, "code_cache")) {
1221 stats->cacheSize += size;
1222 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001223 }
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001224
1225 // Legacy symlink isn't owned by app
1226 if (de->d_type == DT_LNK && !strcmp(name, "lib")) {
1227 continue;
1228 }
1229
1230 // Everything found inside is considered data
1231 stats->dataSize += size;
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001232 }
1233 closedir(d);
1234}
1235
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001236static void collectManualStatsForUser(const std::string& path, struct stats* stats,
1237 bool exclude_apps = false) {
1238 DIR *d;
1239 int dfd;
1240 struct dirent *de;
1241 struct stat s;
1242
1243 d = opendir(path.c_str());
1244 if (d == nullptr) {
1245 if (errno != ENOENT) {
1246 PLOG(WARNING) << "Failed to open " << path;
1247 }
1248 return;
1249 }
1250 dfd = dirfd(d);
1251 while ((de = readdir(d))) {
1252 if (de->d_type == DT_DIR) {
1253 const char *name = de->d_name;
1254 if (fstatat(dfd, name, &s, AT_SYMLINK_NOFOLLOW) != 0) {
1255 continue;
1256 }
1257 if (!strcmp(name, ".") || !strcmp(name, "..")) {
1258 continue;
1259 } else if (exclude_apps && (s.st_uid >= AID_APP_START && s.st_uid <= AID_APP_END)) {
1260 continue;
1261 } else {
1262 collectManualStats(StringPrintf("%s/%s", path.c_str(), name), stats);
1263 }
1264 }
1265 }
1266 closedir(d);
1267}
1268
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001269static void collectManualExternalStatsForUser(const std::string& path, struct stats* stats) {
1270 FTS *fts;
1271 FTSENT *p;
1272 char *argv[] = { (char*) path.c_str(), nullptr };
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001273 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, NULL))) {
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001274 PLOG(ERROR) << "Failed to fts_open " << path;
1275 return;
1276 }
1277 while ((p = fts_read(fts)) != NULL) {
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07001278 p->fts_number = p->fts_parent->fts_number;
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001279 switch (p->fts_info) {
1280 case FTS_D:
1281 if (p->fts_level == 4
1282 && !strcmp(p->fts_name, "cache")
1283 && !strcmp(p->fts_parent->fts_parent->fts_name, "data")
1284 && !strcmp(p->fts_parent->fts_parent->fts_parent->fts_name, "Android")) {
1285 p->fts_number = 1;
1286 }
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001287 // Fall through to count the directory
1288 case FTS_DEFAULT:
1289 case FTS_F:
1290 case FTS_SL:
1291 case FTS_SLNONE:
1292 int64_t size = (p->fts_statp->st_blocks * 512);
1293 if (p->fts_number == 1) {
1294 stats->cacheSize += size;
1295 }
1296 stats->dataSize += size;
1297 break;
1298 }
1299 }
1300 fts_close(fts);
1301}
1302
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001303binder::Status InstalldNativeService::getAppSize(const std::unique_ptr<std::string>& uuid,
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001304 const std::vector<std::string>& packageNames, int32_t userId, int32_t flags,
1305 int32_t appId, const std::vector<int64_t>& ceDataInodes,
1306 const std::vector<std::string>& codePaths, std::vector<int64_t>* _aidl_return) {
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001307 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001308 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001309 for (auto packageName : packageNames) {
1310 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
1311 }
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001312 // NOTE: Locking is relaxed on this method, since it's limited to
1313 // read-only measurements without mutation.
Jeff Sharkey423e7462016-12-09 18:18:43 -07001314
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001315 // When modifying this logic, always verify using tests:
1316 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetAppSize
1317
1318#if MEASURE_DEBUG
1319 LOG(INFO) << "Measuring user " << userId << " app " << appId;
1320#endif
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001321
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001322 // Here's a summary of the common storage locations across the platform,
1323 // and how they're each tagged:
1324 //
1325 // /data/app/com.example UID system
1326 // /data/app/com.example/oat UID system
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001327 // /data/user/0/com.example UID u0_a10 GID u0_a10
1328 // /data/user/0/com.example/cache UID u0_a10 GID u0_a10_cache
1329 // /data/media/0/foo.txt UID u0_media_rw
1330 // /data/media/0/bar.jpg UID u0_media_rw GID u0_media_image
1331 // /data/media/0/Android/data/com.example UID u0_media_rw GID u0_a10_ext
1332 // /data/media/0/Android/data/com.example/cache UID u0_media_rw GID u0_a10_ext_cache
1333 // /data/media/obb/com.example UID system
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001334
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001335 struct stats stats;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001336 struct stats extStats;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001337 memset(&stats, 0, sizeof(stats));
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001338 memset(&extStats, 0, sizeof(extStats));
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001339
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001340 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001341
Jeff Sharkey66b1a122017-01-16 20:57:45 -07001342 auto device = findQuotaDeviceForUuid(uuid);
1343 if (device.empty()) {
1344 flags &= ~FLAG_USE_QUOTA;
1345 }
1346
Jeff Sharkey466459b2017-01-17 15:25:01 -07001347 ATRACE_BEGIN("obb");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001348 for (auto packageName : packageNames) {
1349 auto obbCodePath = create_data_media_obb_path(uuid_, packageName.c_str());
1350 calculate_tree_size(obbCodePath, &extStats.codeSize);
1351 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001352 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001353
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001354 if (flags & FLAG_USE_QUOTA && appId >= AID_APP_START) {
Jeff Sharkey466459b2017-01-17 15:25:01 -07001355 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001356 for (auto codePath : codePaths) {
1357 calculate_tree_size(codePath, &stats.codeSize, -1,
1358 multiuser_get_shared_gid(userId, appId));
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001359 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001360 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001361
Jeff Sharkey466459b2017-01-17 15:25:01 -07001362 ATRACE_BEGIN("quota");
Jeff Sharkey66b1a122017-01-16 20:57:45 -07001363 collectQuotaStats(device, userId, appId, &stats, &extStats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001364 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001365
Jeff Sharkeyec1be622017-04-10 00:19:46 -06001366#if HACK_FOR_37193650
1367 ATRACE_BEGIN("external");
1368 for (size_t i = 0; i < packageNames.size(); i++) {
1369 const char* pkgname = packageNames[i].c_str();
1370 auto extPath = create_data_media_package_path(uuid_, userId, "data", pkgname);
1371 calculate_tree_size(extPath, &extStats.dataSize);
1372 auto mediaPath = create_data_media_package_path(uuid_, userId, "media", pkgname);
1373 calculate_tree_size(mediaPath, &extStats.dataSize);
1374 }
1375 ATRACE_END();
1376#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001377 } else {
Jeff Sharkey466459b2017-01-17 15:25:01 -07001378 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001379 for (auto codePath : codePaths) {
1380 calculate_tree_size(codePath, &stats.codeSize);
1381 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001382 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001383
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001384 for (size_t i = 0; i < packageNames.size(); i++) {
1385 const char* pkgname = packageNames[i].c_str();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001386
Jeff Sharkey466459b2017-01-17 15:25:01 -07001387 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001388 auto cePath = create_data_user_ce_package_path(uuid_, userId, pkgname, ceDataInodes[i]);
1389 collectManualStats(cePath, &stats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001390 auto dePath = create_data_user_de_package_path(uuid_, userId, pkgname);
1391 collectManualStats(dePath, &stats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001392 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001393
Jeff Sharkey466459b2017-01-17 15:25:01 -07001394 ATRACE_BEGIN("profiles");
Calin Juravle114f0812017-03-08 19:05:07 -08001395 auto userProfilePath = create_primary_current_profile_package_dir_path(userId, pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001396 calculate_tree_size(userProfilePath, &stats.dataSize);
Calin Juravle114f0812017-03-08 19:05:07 -08001397 auto refProfilePath = create_primary_reference_profile_package_dir_path(pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001398 calculate_tree_size(refProfilePath, &stats.codeSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001399 ATRACE_END();
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001400
Jeff Sharkey466459b2017-01-17 15:25:01 -07001401 ATRACE_BEGIN("external");
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07001402 auto extPath = create_data_media_package_path(uuid_, userId, "data", pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001403 collectManualStats(extPath, &extStats);
Jeff Sharkey76ddaeb2017-01-25 22:15:42 -07001404 auto mediaPath = create_data_media_package_path(uuid_, userId, "media", pkgname);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001405 calculate_tree_size(mediaPath, &extStats.dataSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001406 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001407 }
1408
Jeff Sharkey466459b2017-01-17 15:25:01 -07001409 ATRACE_BEGIN("dalvik");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001410 int32_t sharedGid = multiuser_get_shared_gid(userId, appId);
1411 if (sharedGid != -1) {
1412 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
1413 sharedGid, -1);
1414 }
Calin Juravle114f0812017-03-08 19:05:07 -08001415 calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize,
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001416 multiuser_get_uid(userId, appId), -1);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001417 ATRACE_END();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001418 }
Jeff Sharkey2f720f72016-04-10 20:51:40 -06001419
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001420 std::vector<int64_t> ret;
1421 ret.push_back(stats.codeSize);
1422 ret.push_back(stats.dataSize);
1423 ret.push_back(stats.cacheSize);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001424 ret.push_back(extStats.codeSize);
1425 ret.push_back(extStats.dataSize);
1426 ret.push_back(extStats.cacheSize);
1427#if MEASURE_DEBUG
1428 LOG(DEBUG) << "Final result " << toString(ret);
1429#endif
1430 *_aidl_return = ret;
1431 return ok();
1432}
1433
1434binder::Status InstalldNativeService::getUserSize(const std::unique_ptr<std::string>& uuid,
1435 int32_t userId, int32_t flags, const std::vector<int32_t>& appIds,
1436 std::vector<int64_t>* _aidl_return) {
1437 ENFORCE_UID(AID_SYSTEM);
1438 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001439 // NOTE: Locking is relaxed on this method, since it's limited to
1440 // read-only measurements without mutation.
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001441
1442 // When modifying this logic, always verify using tests:
1443 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetUserSize
1444
1445#if MEASURE_DEBUG
1446 LOG(INFO) << "Measuring user " << userId;
1447#endif
1448
1449 struct stats stats;
1450 struct stats extStats;
1451 memset(&stats, 0, sizeof(stats));
1452 memset(&extStats, 0, sizeof(extStats));
1453
1454 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
1455
Jeff Sharkey66b1a122017-01-16 20:57:45 -07001456 auto device = findQuotaDeviceForUuid(uuid);
1457 if (device.empty()) {
1458 flags &= ~FLAG_USE_QUOTA;
1459 }
1460
Jeff Sharkeyec1be622017-04-10 00:19:46 -06001461#if HACK_FOR_37193650
1462 if (userId != 0) {
1463 flags &= ~FLAG_USE_QUOTA;
1464 }
1465#endif
1466
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001467 if (flags & FLAG_USE_QUOTA) {
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001468 struct dqblk dq;
1469
1470 ATRACE_BEGIN("obb");
1471 if (quotactl(QCMD(Q_GETQUOTA, GRPQUOTA), device.c_str(), AID_MEDIA_OBB,
1472 reinterpret_cast<char*>(&dq)) != 0) {
1473 if (errno != ESRCH) {
1474 PLOG(ERROR) << "Failed to quotactl " << device << " for GID " << AID_MEDIA_OBB;
1475 }
1476 } else {
1477#if MEASURE_DEBUG
1478 LOG(DEBUG) << "quotactl() for GID " << AID_MEDIA_OBB << " " << dq.dqb_curspace;
1479#endif
1480 extStats.codeSize += dq.dqb_curspace;
1481 }
1482 ATRACE_END();
1483
Jeff Sharkey466459b2017-01-17 15:25:01 -07001484 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001485 calculate_tree_size(create_data_app_path(uuid_), &stats.codeSize, -1, -1, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001486 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001487
Jeff Sharkey466459b2017-01-17 15:25:01 -07001488 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001489 auto cePath = create_data_user_ce_path(uuid_, userId);
1490 collectManualStatsForUser(cePath, &stats, true);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001491 auto dePath = create_data_user_de_path(uuid_, userId);
1492 collectManualStatsForUser(dePath, &stats, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001493 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001494
Jeff Sharkey466459b2017-01-17 15:25:01 -07001495 ATRACE_BEGIN("profile");
Calin Juravle114f0812017-03-08 19:05:07 -08001496 auto userProfilePath = create_primary_cur_profile_dir_path(userId);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001497 calculate_tree_size(userProfilePath, &stats.dataSize, -1, -1, true);
Calin Juravle114f0812017-03-08 19:05:07 -08001498 auto refProfilePath = create_primary_ref_profile_dir_path();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001499 calculate_tree_size(refProfilePath, &stats.codeSize, -1, -1, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001500 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001501
Jeff Sharkey466459b2017-01-17 15:25:01 -07001502 ATRACE_BEGIN("external");
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001503 uid_t uid = multiuser_get_uid(userId, AID_MEDIA_RW);
1504 if (quotactl(QCMD(Q_GETQUOTA, USRQUOTA), device.c_str(), uid,
1505 reinterpret_cast<char*>(&dq)) != 0) {
1506 if (errno != ESRCH) {
1507 PLOG(ERROR) << "Failed to quotactl " << device << " for UID " << uid;
1508 }
1509 } else {
1510#if MEASURE_DEBUG
1511 LOG(DEBUG) << "quotactl() for UID " << uid << " " << dq.dqb_curspace;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001512#endif
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001513 extStats.dataSize += dq.dqb_curspace;
1514 }
1515 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001516
Jeff Sharkey466459b2017-01-17 15:25:01 -07001517 ATRACE_BEGIN("dalvik");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001518 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize,
1519 -1, -1, true);
Calin Juravle114f0812017-03-08 19:05:07 -08001520 calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize,
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001521 -1, -1, true);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001522 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001523
Jeff Sharkey466459b2017-01-17 15:25:01 -07001524 ATRACE_BEGIN("quota");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001525 for (auto appId : appIds) {
1526 if (appId >= AID_APP_START) {
1527 collectQuotaStats(device, userId, appId, &stats, &extStats);
Jeff Sharkeyec1be622017-04-10 00:19:46 -06001528
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001529#if MEASURE_DEBUG
1530 // Sleep to make sure we don't lose logs
1531 usleep(1);
1532#endif
1533 }
1534 }
Jeff Sharkey466459b2017-01-17 15:25:01 -07001535 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001536 } else {
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001537 ATRACE_BEGIN("obb");
1538 auto obbPath = create_data_path(uuid_) + "/media/obb";
1539 calculate_tree_size(obbPath, &extStats.codeSize);
1540 ATRACE_END();
1541
Jeff Sharkey466459b2017-01-17 15:25:01 -07001542 ATRACE_BEGIN("code");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001543 calculate_tree_size(create_data_app_path(uuid_), &stats.codeSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001544 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001545
Jeff Sharkey466459b2017-01-17 15:25:01 -07001546 ATRACE_BEGIN("data");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001547 auto cePath = create_data_user_ce_path(uuid_, userId);
1548 collectManualStatsForUser(cePath, &stats);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001549 auto dePath = create_data_user_de_path(uuid_, userId);
1550 collectManualStatsForUser(dePath, &stats);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001551 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001552
Jeff Sharkey466459b2017-01-17 15:25:01 -07001553 ATRACE_BEGIN("profile");
Calin Juravle114f0812017-03-08 19:05:07 -08001554 auto userProfilePath = create_primary_cur_profile_dir_path(userId);
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001555 calculate_tree_size(userProfilePath, &stats.dataSize);
Calin Juravle114f0812017-03-08 19:05:07 -08001556 auto refProfilePath = create_primary_ref_profile_dir_path();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001557 calculate_tree_size(refProfilePath, &stats.codeSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001558 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001559
Jeff Sharkey466459b2017-01-17 15:25:01 -07001560 ATRACE_BEGIN("external");
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001561 auto dataMediaPath = create_data_media_path(uuid_, userId);
1562 collectManualExternalStatsForUser(dataMediaPath, &extStats);
1563#if MEASURE_DEBUG
1564 LOG(DEBUG) << "Measured external data " << extStats.dataSize << " cache "
1565 << extStats.cacheSize;
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001566#endif
Jeff Sharkey7bf5b952017-01-19 09:21:36 -07001567 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001568
Jeff Sharkey466459b2017-01-17 15:25:01 -07001569 ATRACE_BEGIN("dalvik");
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001570 calculate_tree_size(create_data_dalvik_cache_path(), &stats.codeSize);
Calin Juravle114f0812017-03-08 19:05:07 -08001571 calculate_tree_size(create_primary_cur_profile_dir_path(userId), &stats.dataSize);
Jeff Sharkey466459b2017-01-17 15:25:01 -07001572 ATRACE_END();
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001573 }
1574
1575 std::vector<int64_t> ret;
1576 ret.push_back(stats.codeSize);
1577 ret.push_back(stats.dataSize);
1578 ret.push_back(stats.cacheSize);
1579 ret.push_back(extStats.codeSize);
1580 ret.push_back(extStats.dataSize);
1581 ret.push_back(extStats.cacheSize);
1582#if MEASURE_DEBUG
1583 LOG(DEBUG) << "Final result " << toString(ret);
1584#endif
1585 *_aidl_return = ret;
1586 return ok();
1587}
1588
1589binder::Status InstalldNativeService::getExternalSize(const std::unique_ptr<std::string>& uuid,
1590 int32_t userId, int32_t flags, std::vector<int64_t>* _aidl_return) {
1591 ENFORCE_UID(AID_SYSTEM);
1592 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001593 // NOTE: Locking is relaxed on this method, since it's limited to
1594 // read-only measurements without mutation.
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001595
1596 // When modifying this logic, always verify using tests:
1597 // runtest -x frameworks/base/services/tests/servicestests/src/com/android/server/pm/InstallerTest.java -m testGetExternalSize
1598
1599#if MEASURE_DEBUG
1600 LOG(INFO) << "Measuring external " << userId;
1601#endif
1602
1603 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
1604
1605 int64_t totalSize = 0;
1606 int64_t audioSize = 0;
1607 int64_t videoSize = 0;
1608 int64_t imageSize = 0;
1609
Jeff Sharkey66b1a122017-01-16 20:57:45 -07001610 auto device = findQuotaDeviceForUuid(uuid);
1611 if (device.empty()) {
1612 flags &= ~FLAG_USE_QUOTA;
1613 }
1614
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001615 if (flags & FLAG_USE_QUOTA) {
1616 struct dqblk dq;
1617
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001618 uid_t uid = multiuser_get_uid(userId, AID_MEDIA_RW);
1619 if (quotactl(QCMD(Q_GETQUOTA, USRQUOTA), device.c_str(), uid,
1620 reinterpret_cast<char*>(&dq)) != 0) {
1621 if (errno != ESRCH) {
1622 PLOG(ERROR) << "Failed to quotactl " << device << " for UID " << uid;
1623 }
1624 } else {
1625#if MEASURE_DEBUG
1626 LOG(DEBUG) << "quotactl() for UID " << uid << " " << dq.dqb_curspace;
1627#endif
1628 totalSize = dq.dqb_curspace;
1629 }
1630
1631 gid_t audioGid = multiuser_get_uid(userId, AID_MEDIA_AUDIO);
1632 if (quotactl(QCMD(Q_GETQUOTA, GRPQUOTA), device.c_str(), audioGid,
1633 reinterpret_cast<char*>(&dq)) == 0) {
1634#if MEASURE_DEBUG
1635 LOG(DEBUG) << "quotactl() for GID " << audioGid << " " << dq.dqb_curspace;
1636#endif
1637 audioSize = dq.dqb_curspace;
1638 }
1639 gid_t videoGid = multiuser_get_uid(userId, AID_MEDIA_VIDEO);
1640 if (quotactl(QCMD(Q_GETQUOTA, GRPQUOTA), device.c_str(), videoGid,
1641 reinterpret_cast<char*>(&dq)) == 0) {
1642#if MEASURE_DEBUG
1643 LOG(DEBUG) << "quotactl() for GID " << videoGid << " " << dq.dqb_curspace;
1644#endif
1645 videoSize = dq.dqb_curspace;
1646 }
1647 gid_t imageGid = multiuser_get_uid(userId, AID_MEDIA_IMAGE);
1648 if (quotactl(QCMD(Q_GETQUOTA, GRPQUOTA), device.c_str(), imageGid,
1649 reinterpret_cast<char*>(&dq)) == 0) {
1650#if MEASURE_DEBUG
1651 LOG(DEBUG) << "quotactl() for GID " << imageGid << " " << dq.dqb_curspace;
1652#endif
1653 imageSize = dq.dqb_curspace;
1654 }
1655 } else {
1656 FTS *fts;
1657 FTSENT *p;
1658 auto path = create_data_media_path(uuid_, userId);
1659 char *argv[] = { (char*) path.c_str(), nullptr };
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001660 if (!(fts = fts_open(argv, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, NULL))) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001661 return error("Failed to fts_open " + path);
1662 }
1663 while ((p = fts_read(fts)) != NULL) {
1664 char* ext;
1665 int64_t size = (p->fts_statp->st_blocks * 512);
1666 switch (p->fts_info) {
1667 case FTS_F:
1668 // Only categorize files not belonging to apps
Jeff Sharkey444ad1e2017-03-12 16:25:36 -06001669 if (p->fts_parent->fts_number == 0) {
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001670 ext = strrchr(p->fts_name, '.');
1671 if (ext != nullptr) {
1672 switch (MatchExtension(++ext)) {
1673 case AID_MEDIA_AUDIO: audioSize += size; break;
1674 case AID_MEDIA_VIDEO: videoSize += size; break;
1675 case AID_MEDIA_IMAGE: imageSize += size; break;
1676 }
1677 }
1678 }
1679 // Fall through to always count against total
1680 case FTS_D:
Jeff Sharkey444ad1e2017-03-12 16:25:36 -06001681 // Ignore data belonging to specific apps
1682 p->fts_number = p->fts_parent->fts_number;
1683 if (p->fts_level == 1 && !strcmp(p->fts_name, "Android")) {
1684 p->fts_number = 1;
1685 }
Jeff Sharkeydf2d7542017-01-07 09:19:35 -07001686 case FTS_DEFAULT:
1687 case FTS_SL:
1688 case FTS_SLNONE:
1689 totalSize += size;
1690 break;
1691 }
1692 }
1693 fts_close(fts);
1694 }
1695
1696 std::vector<int64_t> ret;
1697 ret.push_back(totalSize);
1698 ret.push_back(audioSize);
1699 ret.push_back(videoSize);
1700 ret.push_back(imageSize);
1701#if MEASURE_DEBUG
1702 LOG(DEBUG) << "Final result " << toString(ret);
1703#endif
Jeff Sharkey3dfae0c2016-12-12 17:32:56 -07001704 *_aidl_return = ret;
Jeff Sharkey423e7462016-12-09 18:18:43 -07001705 return ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001706}
1707
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001708binder::Status InstalldNativeService::setAppQuota(const std::unique_ptr<std::string>& uuid,
1709 int32_t userId, int32_t appId, int64_t cacheQuota) {
1710 ENFORCE_UID(AID_SYSTEM);
1711 CHECK_ARGUMENT_UUID(uuid);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07001712 std::lock_guard<std::recursive_mutex> lock(mCacheQuotasLock);
Jeff Sharkey88ddd942017-01-17 18:05:54 -07001713
1714 int32_t uid = multiuser_get_uid(userId, appId);
1715 mCacheQuotas[uid] = cacheQuota;
1716
1717 return ok();
1718}
1719
David Sehr6727c2d2016-05-17 16:06:22 -07001720// Dumps the contents of a profile file, using pkgname's dex files for pretty
1721// printing the result.
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001722binder::Status InstalldNativeService::dumpProfiles(int32_t uid, const std::string& packageName,
1723 const std::string& codePaths, bool* _aidl_return) {
1724 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001725 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001726 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001727
1728 const char* pkgname = packageName.c_str();
Jeff Sharkey90aff262016-12-12 14:28:24 -07001729 const char* code_paths = codePaths.c_str();
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001730
Jeff Sharkey90aff262016-12-12 14:28:24 -07001731 *_aidl_return = dump_profiles(uid, pkgname, code_paths);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001732 return ok();
David Sehr6727c2d2016-05-17 16:06:22 -07001733}
1734
Andreas Gampe4d0f8252016-03-20 11:30:28 -07001735// TODO: Consider returning error codes.
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001736binder::Status InstalldNativeService::mergeProfiles(int32_t uid, const std::string& packageName,
Jeff Sharkey423e7462016-12-09 18:18:43 -07001737 bool* _aidl_return) {
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001738 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001739 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001740 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001741
Calin Juravle114f0812017-03-08 19:05:07 -08001742 *_aidl_return = analyze_primary_profiles(uid, packageName);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001743 return ok();
Andreas Gampe4d0f8252016-03-20 11:30:28 -07001744}
1745
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001746binder::Status InstalldNativeService::dexopt(const std::string& apkPath, int32_t uid,
1747 const std::unique_ptr<std::string>& packageName, const std::string& instructionSet,
1748 int32_t dexoptNeeded, const std::unique_ptr<std::string>& outputPath, int32_t dexFlags,
1749 const std::string& compilerFilter, const std::unique_ptr<std::string>& uuid,
Calin Juravlecb556e32017-04-04 20:22:50 -07001750 const std::unique_ptr<std::string>& sharedLibraries,
1751 const std::unique_ptr<std::string>& seInfo) {
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001752 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001753 CHECK_ARGUMENT_UUID(uuid);
1754 if (packageName && *packageName != "*") {
1755 CHECK_ARGUMENT_PACKAGE_NAME(*packageName);
1756 }
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001757 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001758
1759 const char* apk_path = apkPath.c_str();
1760 const char* pkgname = packageName ? packageName->c_str() : "*";
1761 const char* instruction_set = instructionSet.c_str();
1762 const char* oat_dir = outputPath ? outputPath->c_str() : nullptr;
1763 const char* compiler_filter = compilerFilter.c_str();
1764 const char* volume_uuid = uuid ? uuid->c_str() : nullptr;
1765 const char* shared_libraries = sharedLibraries ? sharedLibraries->c_str() : nullptr;
Calin Juravlecb556e32017-04-04 20:22:50 -07001766 const char* se_info = seInfo ? seInfo->c_str() : nullptr;
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001767 int res = android::installd::dexopt(apk_path, uid, pkgname, instruction_set, dexoptNeeded,
Calin Juravlecb556e32017-04-04 20:22:50 -07001768 oat_dir, dexFlags, compiler_filter, volume_uuid, shared_libraries, se_info);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001769 return res ? error(res, "Failed to dexopt") : ok();
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001770}
1771
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001772binder::Status InstalldNativeService::markBootComplete(const std::string& instructionSet) {
1773 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001774 std::lock_guard<std::recursive_mutex> lock(mLock);
1775
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001776 const char* instruction_set = instructionSet.c_str();
1777
1778 char boot_marker_path[PKG_PATH_MAX];
1779 sprintf(boot_marker_path,
Andreas Gampe02d0de52015-11-11 20:43:16 -08001780 "%s/%s/%s/.booting",
1781 android_data_dir.path,
1782 DALVIK_CACHE,
1783 instruction_set);
Narayan Kamath091ea772014-11-10 15:03:46 +00001784
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001785 ALOGV("mark_boot_complete : %s", boot_marker_path);
1786 if (unlink(boot_marker_path) != 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001787 return error(StringPrintf("Failed to unlink %s", boot_marker_path));
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001788 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07001789 return ok();
Narayan Kamath091ea772014-11-10 15:03:46 +00001790}
1791
Mike Lockwood94afecf2012-10-24 10:45:23 -07001792void mkinnerdirs(char* path, int basepos, mode_t mode, int uid, int gid,
1793 struct stat* statbuf)
1794{
1795 while (path[basepos] != 0) {
1796 if (path[basepos] == '/') {
1797 path[basepos] = 0;
1798 if (lstat(path, statbuf) < 0) {
1799 ALOGV("Making directory: %s\n", path);
1800 if (mkdir(path, mode) == 0) {
1801 chown(path, uid, gid);
1802 } else {
1803 ALOGW("Unable to make directory %s: %s\n", path, strerror(errno));
1804 }
1805 }
1806 path[basepos] = '/';
1807 basepos++;
1808 }
1809 basepos++;
1810 }
1811}
1812
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001813binder::Status InstalldNativeService::linkNativeLibraryDirectory(
1814 const std::unique_ptr<std::string>& uuid, const std::string& packageName,
1815 const std::string& nativeLibPath32, int32_t userId) {
1816 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001817 CHECK_ARGUMENT_UUID(uuid);
1818 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001819 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07001820
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001821 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
1822 const char* pkgname = packageName.c_str();
1823 const char* asecLibDir = nativeLibPath32.c_str();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001824 struct stat s, libStat;
Jeff Sharkey423e7462016-12-09 18:18:43 -07001825 binder::Status res = ok();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001826
Jeff Sharkey423e7462016-12-09 18:18:43 -07001827 auto _pkgdir = create_data_user_ce_package_path(uuid_, userId, pkgname);
1828 auto _libsymlink = _pkgdir + PKG_LIB_POSTFIX;
Jeff Sharkeyc03de092015-04-07 18:14:05 -07001829
1830 const char* pkgdir = _pkgdir.c_str();
1831 const char* libsymlink = _libsymlink.c_str();
Mike Lockwood94afecf2012-10-24 10:45:23 -07001832
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001833 if (stat(pkgdir, &s) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001834 return error("Failed to stat " + _pkgdir);
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001835 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001836
1837 if (chown(pkgdir, AID_INSTALL, AID_INSTALL) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001838 return error("Failed to chown " + _pkgdir);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001839 }
1840
1841 if (chmod(pkgdir, 0700) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001842 res = error("Failed to chmod " + _pkgdir);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001843 goto out;
1844 }
1845
1846 if (lstat(libsymlink, &libStat) < 0) {
1847 if (errno != ENOENT) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001848 res = error("Failed to stat " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001849 goto out;
1850 }
1851 } else {
1852 if (S_ISDIR(libStat.st_mode)) {
Narayan Kamath3aee2c52014-06-10 13:16:47 +01001853 if (delete_dir_contents(libsymlink, 1, NULL) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001854 res = error("Failed to delete " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001855 goto out;
1856 }
1857 } else if (S_ISLNK(libStat.st_mode)) {
1858 if (unlink(libsymlink) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001859 res = error("Failed to unlink " + _libsymlink);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001860 goto out;
1861 }
1862 }
1863 }
1864
1865 if (symlink(asecLibDir, libsymlink) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001866 res = error("Failed to symlink " + _libsymlink + " to " + nativeLibPath32);
Mike Lockwood94afecf2012-10-24 10:45:23 -07001867 goto out;
1868 }
1869
1870out:
1871 if (chmod(pkgdir, s.st_mode) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001872 auto msg = "Failed to cleanup chmod " + _pkgdir;
1873 if (res.isOk()) {
1874 res = error(msg);
1875 } else {
1876 PLOG(ERROR) << msg;
1877 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001878 }
1879
1880 if (chown(pkgdir, s.st_uid, s.st_gid) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07001881 auto msg = "Failed to cleanup chown " + _pkgdir;
1882 if (res.isOk()) {
1883 res = error(msg);
1884 } else {
1885 PLOG(ERROR) << msg;
1886 }
Mike Lockwood94afecf2012-10-24 10:45:23 -07001887 }
1888
Jeff Sharkey423e7462016-12-09 18:18:43 -07001889 return res;
Mike Lockwood94afecf2012-10-24 10:45:23 -07001890}
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01001891
1892static void run_idmap(const char *target_apk, const char *overlay_apk, int idmap_fd)
1893{
1894 static const char *IDMAP_BIN = "/system/bin/idmap";
1895 static const size_t MAX_INT_LEN = 32;
1896 char idmap_str[MAX_INT_LEN];
1897
1898 snprintf(idmap_str, sizeof(idmap_str), "%d", idmap_fd);
1899
1900 execl(IDMAP_BIN, IDMAP_BIN, "--fd", target_apk, overlay_apk, idmap_str, (char*)NULL);
1901 ALOGE("execl(%s) failed: %s\n", IDMAP_BIN, strerror(errno));
1902}
1903
1904// Transform string /a/b/c.apk to (prefix)/a@b@c.apk@(suffix)
1905// eg /a/b/c.apk to /data/resource-cache/a@b@c.apk@idmap
1906static int flatten_path(const char *prefix, const char *suffix,
1907 const char *overlay_path, char *idmap_path, size_t N)
1908{
1909 if (overlay_path == NULL || idmap_path == NULL) {
1910 return -1;
1911 }
1912 const size_t len_overlay_path = strlen(overlay_path);
1913 // will access overlay_path + 1 further below; requires absolute path
1914 if (len_overlay_path < 2 || *overlay_path != '/') {
1915 return -1;
1916 }
1917 const size_t len_idmap_root = strlen(prefix);
1918 const size_t len_suffix = strlen(suffix);
1919 if (SIZE_MAX - len_idmap_root < len_overlay_path ||
1920 SIZE_MAX - (len_idmap_root + len_overlay_path) < len_suffix) {
1921 // additions below would cause overflow
1922 return -1;
1923 }
1924 if (N < len_idmap_root + len_overlay_path + len_suffix) {
1925 return -1;
1926 }
1927 memset(idmap_path, 0, N);
1928 snprintf(idmap_path, N, "%s%s%s", prefix, overlay_path + 1, suffix);
1929 char *ch = idmap_path + len_idmap_root;
1930 while (*ch != '\0') {
1931 if (*ch == '/') {
1932 *ch = '@';
1933 }
1934 ++ch;
1935 }
1936 return 0;
1937}
1938
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001939binder::Status InstalldNativeService::idmap(const std::string& targetApkPath,
1940 const std::string& overlayApkPath, int32_t uid) {
1941 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07001942 std::lock_guard<std::recursive_mutex> lock(mLock);
1943
Jeff Sharkey475c6f92016-12-07 10:37:27 -07001944 const char* target_apk = targetApkPath.c_str();
1945 const char* overlay_apk = overlayApkPath.c_str();
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01001946 ALOGV("idmap target_apk=%s overlay_apk=%s uid=%d\n", target_apk, overlay_apk, uid);
1947
1948 int idmap_fd = -1;
1949 char idmap_path[PATH_MAX];
1950
1951 if (flatten_path(IDMAP_PREFIX, IDMAP_SUFFIX, overlay_apk,
1952 idmap_path, sizeof(idmap_path)) == -1) {
1953 ALOGE("idmap cannot generate idmap path for overlay %s\n", overlay_apk);
1954 goto fail;
1955 }
1956
1957 unlink(idmap_path);
1958 idmap_fd = open(idmap_path, O_RDWR | O_CREAT | O_EXCL, 0644);
1959 if (idmap_fd < 0) {
1960 ALOGE("idmap cannot open '%s' for output: %s\n", idmap_path, strerror(errno));
1961 goto fail;
1962 }
1963 if (fchown(idmap_fd, AID_SYSTEM, uid) < 0) {
1964 ALOGE("idmap cannot chown '%s'\n", idmap_path);
1965 goto fail;
1966 }
1967 if (fchmod(idmap_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
1968 ALOGE("idmap cannot chmod '%s'\n", idmap_path);
1969 goto fail;
1970 }
1971
1972 pid_t pid;
1973 pid = fork();
1974 if (pid == 0) {
1975 /* child -- drop privileges before continuing */
1976 if (setgid(uid) != 0) {
1977 ALOGE("setgid(%d) failed during idmap\n", uid);
1978 exit(1);
1979 }
1980 if (setuid(uid) != 0) {
1981 ALOGE("setuid(%d) failed during idmap\n", uid);
1982 exit(1);
1983 }
1984 if (flock(idmap_fd, LOCK_EX | LOCK_NB) != 0) {
1985 ALOGE("flock(%s) failed during idmap: %s\n", idmap_path, strerror(errno));
1986 exit(1);
1987 }
1988
1989 run_idmap(target_apk, overlay_apk, idmap_fd);
1990 exit(1); /* only if exec call to idmap failed */
1991 } else {
1992 int status = wait_child(pid);
1993 if (status != 0) {
1994 ALOGE("idmap failed, status=0x%04x\n", status);
1995 goto fail;
1996 }
1997 }
1998
1999 close(idmap_fd);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002000 return ok();
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002001fail:
2002 if (idmap_fd >= 0) {
2003 close(idmap_fd);
2004 unlink(idmap_path);
2005 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002006 return error();
MÃ¥rten Kongstad63568b12014-01-31 14:42:59 +01002007}
Robert Craige9887e42014-02-20 10:25:56 -05002008
MÃ¥rten Kongstad5c6944c2015-12-15 14:02:30 +01002009binder::Status InstalldNativeService::removeIdmap(const std::string& overlayApkPath) {
2010 const char* overlay_apk = overlayApkPath.c_str();
2011 char idmap_path[PATH_MAX];
2012
2013 if (flatten_path(IDMAP_PREFIX, IDMAP_SUFFIX, overlay_apk,
2014 idmap_path, sizeof(idmap_path)) == -1) {
2015 ALOGE("idmap cannot generate idmap path for overlay %s\n", overlay_apk);
2016 return error();
2017 }
2018 if (unlink(idmap_path) < 0) {
2019 ALOGE("couldn't unlink idmap file %s\n", idmap_path);
2020 return error();
2021 }
2022 return ok();
2023}
2024
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002025binder::Status InstalldNativeService::restoreconAppData(const std::unique_ptr<std::string>& uuid,
2026 const std::string& packageName, int32_t userId, int32_t flags, int32_t appId,
2027 const std::string& seInfo) {
2028 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002029 CHECK_ARGUMENT_UUID(uuid);
2030 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002031 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002032
2033 binder::Status res = ok();
Robert Craige9887e42014-02-20 10:25:56 -05002034
Robert Craigda30dc72014-03-27 10:21:12 -04002035 // SELINUX_ANDROID_RESTORECON_DATADATA flag is set by libselinux. Not needed here.
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002036 unsigned int seflags = SELINUX_ANDROID_RESTORECON_RECURSE;
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002037 const char* uuid_ = uuid ? uuid->c_str() : nullptr;
2038 const char* pkgName = packageName.c_str();
2039 const char* seinfo = seInfo.c_str();
Robert Craigda30dc72014-03-27 10:21:12 -04002040
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002041 uid_t uid = multiuser_get_uid(userId, appId);
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07002042 if (flags & FLAG_STORAGE_CE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002043 auto path = create_data_user_ce_package_path(uuid_, userId, pkgName);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002044 if (selinux_android_restorecon_pkgdir(path.c_str(), seinfo, uid, seflags) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002045 res = error("restorecon failed for " + path);
Jeff Sharkeyebf728f2015-11-18 14:15:17 -07002046 }
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002047 }
Jeff Sharkeyaa7ddfd2016-02-03 14:03:16 -07002048 if (flags & FLAG_STORAGE_DE) {
Jeff Sharkeyc1e93e72016-12-05 23:39:32 -07002049 auto path = create_data_user_de_package_path(uuid_, userId, pkgName);
Jeff Sharkeyc7d1b222016-01-11 13:07:09 -07002050 if (selinux_android_restorecon_pkgdir(path.c_str(), seinfo, uid, seflags) < 0) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002051 res = error("restorecon failed for " + path);
Jeff Sharkey41ea4242015-04-09 11:34:03 -07002052 }
Robert Craige9887e42014-02-20 10:25:56 -05002053 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002054 return res;
Robert Craige9887e42014-02-20 10:25:56 -05002055}
Narayan Kamath3aee2c52014-06-10 13:16:47 +01002056
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002057binder::Status InstalldNativeService::createOatDir(const std::string& oatDir,
2058 const std::string& instructionSet) {
2059 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002060 std::lock_guard<std::recursive_mutex> lock(mLock);
2061
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002062 const char* oat_dir = oatDir.c_str();
2063 const char* instruction_set = instructionSet.c_str();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002064 char oat_instr_dir[PKG_PATH_MAX];
2065
2066 if (validate_apk_path(oat_dir)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002067 return error("Invalid path " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002068 }
Fyodor Kupolov8eed7e62015-04-06 19:09:02 -07002069 if (fs_prepare_dir(oat_dir, S_IRWXU | S_IRWXG | S_IXOTH, AID_SYSTEM, AID_INSTALL)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002070 return error("Failed to prepare " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002071 }
2072 if (selinux_android_restorecon(oat_dir, 0)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002073 return error("Failed to restorecon " + oatDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002074 }
2075 snprintf(oat_instr_dir, PKG_PATH_MAX, "%s/%s", oat_dir, instruction_set);
Fyodor Kupolov8eed7e62015-04-06 19:09:02 -07002076 if (fs_prepare_dir(oat_instr_dir, S_IRWXU | S_IRWXG | S_IXOTH, AID_SYSTEM, AID_INSTALL)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002077 return error(StringPrintf("Failed to prepare %s", oat_instr_dir));
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002078 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002079 return ok();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002080}
2081
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002082binder::Status InstalldNativeService::rmPackageDir(const std::string& packageDir) {
2083 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002084 std::lock_guard<std::recursive_mutex> lock(mLock);
2085
Jeff Sharkey423e7462016-12-09 18:18:43 -07002086 if (validate_apk_path(packageDir.c_str())) {
2087 return error("Invalid path " + packageDir);
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002088 }
Jeff Sharkey423e7462016-12-09 18:18:43 -07002089 if (delete_dir_contents_and_dir(packageDir) != 0) {
2090 return error("Failed to delete " + packageDir);
2091 }
2092 return ok();
Fyodor Kupolov88ce4ff2015-03-03 12:25:29 -08002093}
2094
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002095binder::Status InstalldNativeService::linkFile(const std::string& relativePath,
2096 const std::string& fromBase, const std::string& toBase) {
2097 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002098 std::lock_guard<std::recursive_mutex> lock(mLock);
2099
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002100 const char* relative_path = relativePath.c_str();
2101 const char* from_base = fromBase.c_str();
2102 const char* to_base = toBase.c_str();
Narayan Kamathd845c962015-06-04 13:20:27 +01002103 char from_path[PKG_PATH_MAX];
2104 char to_path[PKG_PATH_MAX];
2105 snprintf(from_path, PKG_PATH_MAX, "%s/%s", from_base, relative_path);
2106 snprintf(to_path, PKG_PATH_MAX, "%s/%s", to_base, relative_path);
2107
2108 if (validate_apk_path_subdirs(from_path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002109 return error(StringPrintf("Invalid from path %s", from_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002110 }
2111
2112 if (validate_apk_path_subdirs(to_path)) {
Jeff Sharkey423e7462016-12-09 18:18:43 -07002113 return error(StringPrintf("Invalid to path %s", to_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002114 }
2115
Jeff Sharkey423e7462016-12-09 18:18:43 -07002116 if (link(from_path, to_path) < 0) {
2117 return error(StringPrintf("Failed to link from %s to %s", from_path, to_path));
Narayan Kamathd845c962015-06-04 13:20:27 +01002118 }
2119
Jeff Sharkey423e7462016-12-09 18:18:43 -07002120 return ok();
Narayan Kamathd845c962015-06-04 13:20:27 +01002121}
2122
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002123binder::Status InstalldNativeService::moveAb(const std::string& apkPath,
2124 const std::string& instructionSet, const std::string& outputPath) {
2125 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002126 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey90aff262016-12-12 14:28:24 -07002127
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002128 const char* apk_path = apkPath.c_str();
2129 const char* instruction_set = instructionSet.c_str();
2130 const char* oat_dir = outputPath.c_str();
Andreas Gampe0354bd02016-06-27 14:25:30 -07002131
Jeff Sharkey90aff262016-12-12 14:28:24 -07002132 bool success = move_ab(apk_path, instruction_set, oat_dir);
Jeff Sharkey423e7462016-12-09 18:18:43 -07002133 return success ? ok() : error();
Andreas Gampee65b4fa2016-03-01 11:46:45 -08002134}
2135
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002136binder::Status InstalldNativeService::deleteOdex(const std::string& apkPath,
2137 const std::string& instructionSet, const std::string& outputPath) {
2138 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkey7a9059e2017-01-16 19:07:18 -07002139 std::lock_guard<std::recursive_mutex> lock(mLock);
Jeff Sharkey90aff262016-12-12 14:28:24 -07002140
Jeff Sharkey475c6f92016-12-07 10:37:27 -07002141 const char* apk_path = apkPath.c_str();
2142 const char* instruction_set = instructionSet.c_str();
2143 const char* oat_dir = outputPath.c_str();
2144
Jeff Sharkey90aff262016-12-12 14:28:24 -07002145 bool res = delete_odex(apk_path, instruction_set, oat_dir);
2146 return res ? ok() : error();
Andreas Gampe3964da02016-09-09 17:07:04 -07002147}
2148
Calin Juravlebd968362017-01-25 01:17:17 -08002149binder::Status InstalldNativeService::reconcileSecondaryDexFile(
2150 const std::string& dexPath, const std::string& packageName, int32_t uid,
2151 const std::vector<std::string>& isas, const std::unique_ptr<std::string>& volumeUuid,
2152 int32_t storage_flag, bool* _aidl_return) {
2153 ENFORCE_UID(AID_SYSTEM);
2154 CHECK_ARGUMENT_UUID(volumeUuid);
2155 CHECK_ARGUMENT_PACKAGE_NAME(packageName);
2156
2157 std::lock_guard<std::recursive_mutex> lock(mLock);
2158 bool result = android::installd::reconcile_secondary_dex_file(
2159 dexPath, packageName, uid, isas, volumeUuid, storage_flag, _aidl_return);
2160 return result ? ok() : error();
2161}
2162
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002163binder::Status InstalldNativeService::invalidateMounts() {
2164 ENFORCE_UID(AID_SYSTEM);
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07002165 std::lock_guard<std::recursive_mutex> lock(mQuotaDevicesLock);
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002166
2167 mQuotaDevices.clear();
2168
2169 std::ifstream in("/proc/mounts");
2170 if (!in.is_open()) {
2171 return error("Failed to read mounts");
2172 }
2173
2174 std::string source;
2175 std::string target;
2176 std::string ignored;
2177 struct dqblk dq;
2178 while (!in.eof()) {
2179 std::getline(in, source, ' ');
2180 std::getline(in, target, ' ');
2181 std::getline(in, ignored);
2182
2183 if (source.compare(0, 11, "/dev/block/") == 0) {
2184 if (quotactl(QCMD(Q_GETQUOTA, USRQUOTA), source.c_str(), 0,
2185 reinterpret_cast<char*>(&dq)) == 0) {
2186 LOG(DEBUG) << "Found " << source << " with quota";
2187 mQuotaDevices[target] = source;
Jeff Sharkeye59c85c2017-04-02 21:53:14 -06002188
2189 // ext4 only enables DQUOT_USAGE_ENABLED by default, so we
2190 // need to kick it again to enable DQUOT_LIMITS_ENABLED.
2191 if (quotactl(QCMD(Q_QUOTAON, USRQUOTA), source.c_str(), QFMT_VFS_V1, nullptr) != 0
2192 && errno != EBUSY) {
2193 PLOG(ERROR) << "Failed to enable USRQUOTA on " << source;
2194 }
2195 if (quotactl(QCMD(Q_QUOTAON, GRPQUOTA), source.c_str(), QFMT_VFS_V1, nullptr) != 0
2196 && errno != EBUSY) {
2197 PLOG(ERROR) << "Failed to enable GRPQUOTA on " << source;
2198 }
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002199 }
2200 }
2201 }
2202 return ok();
2203}
2204
2205std::string InstalldNativeService::findQuotaDeviceForUuid(
2206 const std::unique_ptr<std::string>& uuid) {
Jeff Sharkeyb26786d2017-03-11 19:40:29 -07002207 std::lock_guard<std::recursive_mutex> lock(mQuotaDevicesLock);
Jeff Sharkey66b1a122017-01-16 20:57:45 -07002208 auto path = create_data_path(uuid ? uuid->c_str() : nullptr);
2209 return mQuotaDevices[path];
2210}
2211
Jeff Sharkey325b8c92017-02-21 10:00:53 -07002212binder::Status InstalldNativeService::isQuotaSupported(
2213 const std::unique_ptr<std::string>& volumeUuid, bool* _aidl_return) {
2214 *_aidl_return = !findQuotaDeviceForUuid(volumeUuid).empty();
2215 return ok();
2216}
2217
Andreas Gampe02d0de52015-11-11 20:43:16 -08002218} // namespace installd
2219} // namespace android