blob: 25b6f64b4ea9bbd3ae91352669e274d82d810e35 [file] [log] [blame]
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Mark Salyzyna5e161b2016-09-29 08:08:05 -070016#define LOG_TAG "installed"
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070017
Jeff Sharkey90aff262016-12-12 14:28:24 -070018#include <fcntl.h>
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070019#include <stdlib.h>
20#include <string.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070021#include <sys/capability.h>
22#include <sys/file.h>
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070023#include <sys/stat.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070024#include <sys/time.h>
25#include <sys/types.h>
26#include <sys/resource.h>
27#include <sys/wait.h>
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070028#include <unistd.h>
29
30#include <android-base/logging.h>
Andreas Gampe6a9cf722017-07-24 16:49:10 -070031#include <android-base/properties.h>
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070032#include <android-base/stringprintf.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070033#include <android-base/strings.h>
34#include <android-base/unique_fd.h>
Calin Juravle80a21252017-01-17 14:43:25 -080035#include <cutils/fs.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070036#include <cutils/properties.h>
37#include <cutils/sched_policy.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070038#include <log/log.h> // TODO: Move everything to base/logging.
Jeff Sharkey90aff262016-12-12 14:28:24 -070039#include <private/android_filesystem_config.h>
Calin Juravlecb556e32017-04-04 20:22:50 -070040#include <selinux/android.h>
Jeff Sharkey90aff262016-12-12 14:28:24 -070041#include <system/thread_defs.h>
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070042
43#include "dexopt.h"
Jeff Sharkeyc1149c92017-09-21 14:51:09 -060044#include "globals.h"
Jeff Sharkey90aff262016-12-12 14:28:24 -070045#include "installd_deps.h"
46#include "otapreopt_utils.h"
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070047#include "utils.h"
48
49using android::base::StringPrintf;
Jeff Sharkey90aff262016-12-12 14:28:24 -070050using android::base::EndsWith;
Calin Juravle1a0af3b2017-03-09 14:33:33 -080051using android::base::unique_fd;
Jeff Sharkey6c2c0562016-12-07 12:12:00 -070052
53namespace android {
54namespace installd {
55
Andreas Gampe2a2d7ba2017-11-02 19:39:29 -070056// Should minidebug info be included in compiled artifacts? Even if this value is
57// "true," usage might still be conditional to other constraints, e.g., system
58// property overrides.
59static constexpr bool kEnableMinidebugInfo = true;
60
61static constexpr const char* kMinidebugInfoSystemProperty = "dalvik.vm.dex2oat-minidebuginfo";
62static constexpr bool kMinidebugInfoSystemPropertyDefault = false;
63static constexpr const char* kMinidebugDex2oatFlag = "--generate-mini-debug-info";
Mathieu Chartierb41ffcc2018-01-09 00:02:17 -080064static constexpr const char* kDisableCompactDexFlag = "--compact-dex-level=none";
Andreas Gampe2a2d7ba2017-11-02 19:39:29 -070065
Calin Juravle114f0812017-03-08 19:05:07 -080066// Deleter using free() for use with std::unique_ptr<>. See also UniqueCPtr<> below.
67struct FreeDelete {
68 // NOTE: Deleting a const object is valid but free() takes a non-const pointer.
69 void operator()(const void* ptr) const {
70 free(const_cast<void*>(ptr));
71 }
72};
73
74// Alias for std::unique_ptr<> that uses the C function free() to delete objects.
75template <typename T>
76using UniqueCPtr = std::unique_ptr<T, FreeDelete>;
77
Calin Juravle1a0af3b2017-03-09 14:33:33 -080078static unique_fd invalid_unique_fd() {
79 return unique_fd(-1);
80}
81
Andreas Gampe6a9cf722017-07-24 16:49:10 -070082static bool is_debug_runtime() {
83 return android::base::GetProperty("persist.sys.dalvik.vm.lib.2", "") == "libartd.so";
84}
85
David Sehra3b5ab62017-10-25 14:27:29 -070086static bool is_debuggable_build() {
87 return android::base::GetBoolProperty("ro.debuggable", false);
88}
89
Jeff Sharkey90aff262016-12-12 14:28:24 -070090static bool clear_profile(const std::string& profile) {
Calin Juravle1a0af3b2017-03-09 14:33:33 -080091 unique_fd ufd(open(profile.c_str(), O_WRONLY | O_NOFOLLOW | O_CLOEXEC));
Jeff Sharkey90aff262016-12-12 14:28:24 -070092 if (ufd.get() < 0) {
93 if (errno != ENOENT) {
94 PLOG(WARNING) << "Could not open profile " << profile;
95 return false;
96 } else {
97 // Nothing to clear. That's ok.
98 return true;
99 }
100 }
101
102 if (flock(ufd.get(), LOCK_EX | LOCK_NB) != 0) {
103 if (errno != EWOULDBLOCK) {
104 PLOG(WARNING) << "Error locking profile " << profile;
105 }
106 // This implies that the app owning this profile is running
107 // (and has acquired the lock).
108 //
109 // If we can't acquire the lock bail out since clearing is useless anyway
110 // (the app will write again to the profile).
111 //
112 // Note:
113 // This does not impact the this is not an issue for the profiling correctness.
114 // In case this is needed because of an app upgrade, profiles will still be
115 // eventually cleared by the app itself due to checksum mismatch.
116 // If this is needed because profman advised, then keeping the data around
117 // until the next run is again not an issue.
118 //
119 // If the app attempts to acquire a lock while we've held one here,
120 // it will simply skip the current write cycle.
121 return false;
122 }
123
124 bool truncated = ftruncate(ufd.get(), 0) == 0;
125 if (!truncated) {
126 PLOG(WARNING) << "Could not truncate " << profile;
127 }
128 if (flock(ufd.get(), LOCK_UN) != 0) {
129 PLOG(WARNING) << "Error unlocking profile " << profile;
130 }
131 return truncated;
132}
133
Calin Juravle114f0812017-03-08 19:05:07 -0800134// Clear the reference profile for the given location.
135// The location is the package name for primary apks or the dex path for secondary dex files.
136static bool clear_reference_profile(const std::string& location, bool is_secondary_dex) {
137 return clear_profile(create_reference_profile_path(location, is_secondary_dex));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700138}
139
Calin Juravle114f0812017-03-08 19:05:07 -0800140// Clear the reference profile for the given location.
141// The location is the package name for primary apks or the dex path for secondary dex files.
142static bool clear_current_profile(const std::string& pkgname, userid_t user,
143 bool is_secondary_dex) {
144 return clear_profile(create_current_profile_path(user, pkgname, is_secondary_dex));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700145}
146
Calin Juravle114f0812017-03-08 19:05:07 -0800147// Clear the reference profile for the primary apk of the given package.
148bool clear_primary_reference_profile(const std::string& pkgname) {
149 return clear_reference_profile(pkgname, /*is_secondary_dex*/false);
150}
151
152// Clear all current profile for the primary apk of the given package.
153bool clear_primary_current_profiles(const std::string& pkgname) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700154 bool success = true;
Calin Juravle114f0812017-03-08 19:05:07 -0800155 // For secondary dex files, we don't really need the user but we use it for sanity checks.
Jeff Sharkey90aff262016-12-12 14:28:24 -0700156 std::vector<userid_t> users = get_known_users(/*volume_uuid*/ nullptr);
157 for (auto user : users) {
Calin Juravle114f0812017-03-08 19:05:07 -0800158 success &= clear_current_profile(pkgname, user, /*is_secondary_dex*/false);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700159 }
160 return success;
161}
162
Calin Juravle114f0812017-03-08 19:05:07 -0800163// Clear the current profile for the primary apk of the given package and user.
164bool clear_primary_current_profile(const std::string& pkgname, userid_t user) {
165 return clear_current_profile(pkgname, user, /*is_secondary_dex*/false);
166}
167
Jeff Sharkey90aff262016-12-12 14:28:24 -0700168static int split_count(const char *str)
169{
170 char *ctx;
171 int count = 0;
172 char buf[kPropertyValueMax];
173
Jeff Sharkeyc1149c92017-09-21 14:51:09 -0600174 strlcpy(buf, str, sizeof(buf));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700175 char *pBuf = buf;
176
177 while(strtok_r(pBuf, " ", &ctx) != NULL) {
178 count++;
179 pBuf = NULL;
180 }
181
182 return count;
183}
184
185static int split(char *buf, const char **argv)
186{
187 char *ctx;
188 int count = 0;
189 char *tok;
190 char *pBuf = buf;
191
192 while((tok = strtok_r(pBuf, " ", &ctx)) != NULL) {
193 argv[count++] = tok;
194 pBuf = NULL;
195 }
196
197 return count;
198}
199
Jeff Hao10b8a6e2017-04-05 17:11:39 -0700200static const char* get_location_from_path(const char* path) {
201 static constexpr char kLocationSeparator = '/';
202 const char *location = strrchr(path, kLocationSeparator);
203 if (location == NULL) {
204 return path;
205 } else {
206 // Skip the separator character.
207 return location + 1;
208 }
209}
210
Jeff Sharkey90aff262016-12-12 14:28:24 -0700211static void run_dex2oat(int zip_fd, int oat_fd, int input_vdex_fd, int output_vdex_fd, int image_fd,
212 const char* input_file_name, const char* output_file_name, int swap_fd,
Nicolas Geoffraybe6ecd62017-05-03 13:21:37 +0100213 const char* instruction_set, const char* compiler_filter,
Andreas Gampea73a0cb2017-11-02 18:14:42 -0700214 bool debuggable, bool post_bootcomplete, bool background_job_compile, int profile_fd,
David Brazdil570d3982018-01-16 20:15:43 +0000215 const char* class_loader_context, int target_sdk_version) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700216 static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
217
218 if (strlen(instruction_set) >= MAX_INSTRUCTION_SET_LEN) {
219 ALOGE("Instruction set %s longer than max length of %d",
220 instruction_set, MAX_INSTRUCTION_SET_LEN);
221 return;
222 }
223
Jeff Hao10b8a6e2017-04-05 17:11:39 -0700224 // Get the relative path to the input file.
225 const char* relative_input_file_name = get_location_from_path(input_file_name);
226
Jeff Sharkey90aff262016-12-12 14:28:24 -0700227 char dex2oat_Xms_flag[kPropertyValueMax];
228 bool have_dex2oat_Xms_flag = get_property("dalvik.vm.dex2oat-Xms", dex2oat_Xms_flag, NULL) > 0;
229
230 char dex2oat_Xmx_flag[kPropertyValueMax];
231 bool have_dex2oat_Xmx_flag = get_property("dalvik.vm.dex2oat-Xmx", dex2oat_Xmx_flag, NULL) > 0;
232
233 char dex2oat_threads_buf[kPropertyValueMax];
234 bool have_dex2oat_threads_flag = get_property(post_bootcomplete
235 ? "dalvik.vm.dex2oat-threads"
236 : "dalvik.vm.boot-dex2oat-threads",
237 dex2oat_threads_buf,
238 NULL) > 0;
239 char dex2oat_threads_arg[kPropertyValueMax + 2];
240 if (have_dex2oat_threads_flag) {
241 sprintf(dex2oat_threads_arg, "-j%s", dex2oat_threads_buf);
242 }
243
244 char dex2oat_isa_features_key[kPropertyKeyMax];
245 sprintf(dex2oat_isa_features_key, "dalvik.vm.isa.%s.features", instruction_set);
246 char dex2oat_isa_features[kPropertyValueMax];
247 bool have_dex2oat_isa_features = get_property(dex2oat_isa_features_key,
248 dex2oat_isa_features, NULL) > 0;
249
250 char dex2oat_isa_variant_key[kPropertyKeyMax];
251 sprintf(dex2oat_isa_variant_key, "dalvik.vm.isa.%s.variant", instruction_set);
252 char dex2oat_isa_variant[kPropertyValueMax];
253 bool have_dex2oat_isa_variant = get_property(dex2oat_isa_variant_key,
254 dex2oat_isa_variant, NULL) > 0;
255
256 const char *dex2oat_norelocation = "-Xnorelocate";
257 bool have_dex2oat_relocation_skip_flag = false;
258
259 char dex2oat_flags[kPropertyValueMax];
260 int dex2oat_flags_count = get_property("dalvik.vm.dex2oat-flags",
261 dex2oat_flags, NULL) <= 0 ? 0 : split_count(dex2oat_flags);
262 ALOGV("dalvik.vm.dex2oat-flags=%s\n", dex2oat_flags);
263
Nicolas Geoffraybe6ecd62017-05-03 13:21:37 +0100264 // If we are booting without the real /data, don't spend time compiling.
Jeff Sharkey90aff262016-12-12 14:28:24 -0700265 char vold_decrypt[kPropertyValueMax];
266 bool have_vold_decrypt = get_property("vold.decrypt", vold_decrypt, "") > 0;
267 bool skip_compilation = (have_vold_decrypt &&
268 (strcmp(vold_decrypt, "trigger_restart_min_framework") == 0 ||
269 (strcmp(vold_decrypt, "1") == 0)));
270
271 bool generate_debug_info = property_get_bool("debug.generate-debug-info", false);
272
273 char app_image_format[kPropertyValueMax];
274 char image_format_arg[strlen("--image-format=") + kPropertyValueMax];
275 bool have_app_image_format =
276 image_fd >= 0 && get_property("dalvik.vm.appimageformat", app_image_format, NULL) > 0;
277 if (have_app_image_format) {
278 sprintf(image_format_arg, "--image-format=%s", app_image_format);
279 }
280
281 char dex2oat_large_app_threshold[kPropertyValueMax];
282 bool have_dex2oat_large_app_threshold =
283 get_property("dalvik.vm.dex2oat-very-large", dex2oat_large_app_threshold, NULL) > 0;
284 char dex2oat_large_app_threshold_arg[strlen("--very-large-app-threshold=") + kPropertyValueMax];
285 if (have_dex2oat_large_app_threshold) {
286 sprintf(dex2oat_large_app_threshold_arg,
287 "--very-large-app-threshold=%s",
288 dex2oat_large_app_threshold);
289 }
290
Andreas Gampe6a9cf722017-07-24 16:49:10 -0700291 // If the runtime was requested to use libartd.so, we'll run dex2oatd, otherwise dex2oat.
David Sehra3b5ab62017-10-25 14:27:29 -0700292 const char* dex2oat_bin = "/system/bin/dex2oat";
293 static const char* kDex2oatDebugPath = "/system/bin/dex2oatd";
Andreas Gampea73a0cb2017-11-02 18:14:42 -0700294 if (is_debug_runtime() || (background_job_compile && is_debuggable_build())) {
David Sehra3b5ab62017-10-25 14:27:29 -0700295 DCHECK(access(kDex2oatDebugPath, X_OK) == 0);
296 dex2oat_bin = kDex2oatDebugPath;
297 }
Jeff Sharkey90aff262016-12-12 14:28:24 -0700298
Andreas Gampe2a2d7ba2017-11-02 19:39:29 -0700299 bool generate_minidebug_info = kEnableMinidebugInfo &&
300 android::base::GetBoolProperty(kMinidebugInfoSystemProperty,
301 kMinidebugInfoSystemPropertyDefault);
302
Jeff Sharkey90aff262016-12-12 14:28:24 -0700303 static const char* RUNTIME_ARG = "--runtime-arg";
304
305 static const int MAX_INT_LEN = 12; // '-'+10dig+'\0' -OR- 0x+8dig
306
George Burgess IV36cebe772017-01-25 11:52:01 -0800307 // clang FORTIFY doesn't let us use strlen in constant array bounds, so we
308 // use arraysize instead.
309 char zip_fd_arg[arraysize("--zip-fd=") + MAX_INT_LEN];
310 char zip_location_arg[arraysize("--zip-location=") + PKG_PATH_MAX];
311 char input_vdex_fd_arg[arraysize("--input-vdex-fd=") + MAX_INT_LEN];
312 char output_vdex_fd_arg[arraysize("--output-vdex-fd=") + MAX_INT_LEN];
313 char oat_fd_arg[arraysize("--oat-fd=") + MAX_INT_LEN];
314 char oat_location_arg[arraysize("--oat-location=") + PKG_PATH_MAX];
315 char instruction_set_arg[arraysize("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
316 char instruction_set_variant_arg[arraysize("--instruction-set-variant=") + kPropertyValueMax];
317 char instruction_set_features_arg[arraysize("--instruction-set-features=") + kPropertyValueMax];
318 char dex2oat_Xms_arg[arraysize("-Xms") + kPropertyValueMax];
319 char dex2oat_Xmx_arg[arraysize("-Xmx") + kPropertyValueMax];
320 char dex2oat_compiler_filter_arg[arraysize("--compiler-filter=") + kPropertyValueMax];
Jeff Sharkey90aff262016-12-12 14:28:24 -0700321 bool have_dex2oat_swap_fd = false;
George Burgess IV36cebe772017-01-25 11:52:01 -0800322 char dex2oat_swap_fd[arraysize("--swap-fd=") + MAX_INT_LEN];
Jeff Sharkey90aff262016-12-12 14:28:24 -0700323 bool have_dex2oat_image_fd = false;
George Burgess IV36cebe772017-01-25 11:52:01 -0800324 char dex2oat_image_fd[arraysize("--app-image-fd=") + MAX_INT_LEN];
Calin Juravle52c45822017-07-13 22:50:21 -0700325 size_t class_loader_context_size = arraysize("--class-loader-context=") + PKG_PATH_MAX;
David Brazdil570d3982018-01-16 20:15:43 +0000326 char target_sdk_version_arg[arraysize("-Xtarget-sdk-version:") + MAX_INT_LEN];
Calin Juravle52c45822017-07-13 22:50:21 -0700327 char class_loader_context_arg[class_loader_context_size];
328 if (class_loader_context != nullptr) {
329 snprintf(class_loader_context_arg, class_loader_context_size, "--class-loader-context=%s",
330 class_loader_context);
331 }
Jeff Sharkey90aff262016-12-12 14:28:24 -0700332
333 sprintf(zip_fd_arg, "--zip-fd=%d", zip_fd);
Jeff Hao10b8a6e2017-04-05 17:11:39 -0700334 sprintf(zip_location_arg, "--zip-location=%s", relative_input_file_name);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700335 sprintf(input_vdex_fd_arg, "--input-vdex-fd=%d", input_vdex_fd);
336 sprintf(output_vdex_fd_arg, "--output-vdex-fd=%d", output_vdex_fd);
337 sprintf(oat_fd_arg, "--oat-fd=%d", oat_fd);
338 sprintf(oat_location_arg, "--oat-location=%s", output_file_name);
339 sprintf(instruction_set_arg, "--instruction-set=%s", instruction_set);
340 sprintf(instruction_set_variant_arg, "--instruction-set-variant=%s", dex2oat_isa_variant);
341 sprintf(instruction_set_features_arg, "--instruction-set-features=%s", dex2oat_isa_features);
342 if (swap_fd >= 0) {
343 have_dex2oat_swap_fd = true;
344 sprintf(dex2oat_swap_fd, "--swap-fd=%d", swap_fd);
345 }
346 if (image_fd >= 0) {
347 have_dex2oat_image_fd = true;
348 sprintf(dex2oat_image_fd, "--app-image-fd=%d", image_fd);
349 }
350
351 if (have_dex2oat_Xms_flag) {
352 sprintf(dex2oat_Xms_arg, "-Xms%s", dex2oat_Xms_flag);
353 }
354 if (have_dex2oat_Xmx_flag) {
355 sprintf(dex2oat_Xmx_arg, "-Xmx%s", dex2oat_Xmx_flag);
356 }
David Brazdil570d3982018-01-16 20:15:43 +0000357 sprintf(target_sdk_version_arg, "-Xtarget-sdk-version:%d", target_sdk_version);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700358
359 // Compute compiler filter.
360
Nicolas Geoffraybe6ecd62017-05-03 13:21:37 +0100361 bool have_dex2oat_compiler_filter_flag = false;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700362 if (skip_compilation) {
Jeff Sharkeyc1149c92017-09-21 14:51:09 -0600363 strlcpy(dex2oat_compiler_filter_arg, "--compiler-filter=extract",
364 sizeof(dex2oat_compiler_filter_arg));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700365 have_dex2oat_compiler_filter_flag = true;
366 have_dex2oat_relocation_skip_flag = true;
Nicolas Geoffraybe6ecd62017-05-03 13:21:37 +0100367 } else if (compiler_filter != nullptr) {
368 if (strlen(compiler_filter) + strlen("--compiler-filter=") <
Jeff Sharkey90aff262016-12-12 14:28:24 -0700369 arraysize(dex2oat_compiler_filter_arg)) {
Nicolas Geoffraybe6ecd62017-05-03 13:21:37 +0100370 sprintf(dex2oat_compiler_filter_arg, "--compiler-filter=%s", compiler_filter);
371 have_dex2oat_compiler_filter_flag = true;
372 } else {
373 ALOGW("Compiler filter name '%s' is too large (max characters is %zu)",
374 compiler_filter,
375 kPropertyValueMax);
376 }
377 }
378
379 if (!have_dex2oat_compiler_filter_flag) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700380 char dex2oat_compiler_filter_flag[kPropertyValueMax];
381 have_dex2oat_compiler_filter_flag = get_property("dalvik.vm.dex2oat-filter",
382 dex2oat_compiler_filter_flag, NULL) > 0;
383 if (have_dex2oat_compiler_filter_flag) {
384 sprintf(dex2oat_compiler_filter_arg,
385 "--compiler-filter=%s",
386 dex2oat_compiler_filter_flag);
387 }
388 }
389
390 // Check whether all apps should be compiled debuggable.
391 if (!debuggable) {
392 char prop_buf[kPropertyValueMax];
393 debuggable =
394 (get_property("dalvik.vm.always_debuggable", prop_buf, "0") > 0) &&
395 (prop_buf[0] == '1');
396 }
397 char profile_arg[strlen("--profile-file-fd=") + MAX_INT_LEN];
398 if (profile_fd != -1) {
399 sprintf(profile_arg, "--profile-file-fd=%d", profile_fd);
400 }
401
Jeff Hao10b8a6e2017-04-05 17:11:39 -0700402 // Get the directory of the apk to pass as a base classpath directory.
403 char base_dir[arraysize("--classpath-dir=") + PKG_PATH_MAX];
404 std::string apk_dir(input_file_name);
405 unsigned long dir_index = apk_dir.rfind('/');
406 bool has_base_dir = dir_index != std::string::npos;
407 if (has_base_dir) {
408 apk_dir = apk_dir.substr(0, dir_index);
409 sprintf(base_dir, "--classpath-dir=%s", apk_dir.c_str());
410 }
Jeff Sharkey90aff262016-12-12 14:28:24 -0700411
Jeff Hao10b8a6e2017-04-05 17:11:39 -0700412
Andreas Gampe6a9cf722017-07-24 16:49:10 -0700413 ALOGV("Running %s in=%s out=%s\n", dex2oat_bin, relative_input_file_name, output_file_name);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700414
Mathieu Chartierb41ffcc2018-01-09 00:02:17 -0800415 // Disable cdex if update input vdex is true since this combination of options is not
416 // supported.
Mathieu Chartier1fb463e2018-01-09 15:16:10 -0800417 // Disable cdex for non-background compiles since we don't want to regress app install until
418 // there are enough benefits to justify the tradeoff.
419 const bool disable_cdex = !background_job_compile || (input_vdex_fd == output_vdex_fd);
Mathieu Chartierb41ffcc2018-01-09 00:02:17 -0800420
Jeff Sharkey90aff262016-12-12 14:28:24 -0700421 const char* argv[9 // program name, mandatory arguments and the final NULL
422 + (have_dex2oat_isa_variant ? 1 : 0)
423 + (have_dex2oat_isa_features ? 1 : 0)
424 + (have_dex2oat_Xms_flag ? 2 : 0)
425 + (have_dex2oat_Xmx_flag ? 2 : 0)
426 + (have_dex2oat_compiler_filter_flag ? 1 : 0)
427 + (have_dex2oat_threads_flag ? 1 : 0)
428 + (have_dex2oat_swap_fd ? 1 : 0)
429 + (have_dex2oat_image_fd ? 1 : 0)
430 + (have_dex2oat_relocation_skip_flag ? 2 : 0)
431 + (generate_debug_info ? 1 : 0)
432 + (debuggable ? 1 : 0)
433 + (have_app_image_format ? 1 : 0)
434 + dex2oat_flags_count
435 + (profile_fd == -1 ? 0 : 1)
Calin Juravle52c45822017-07-13 22:50:21 -0700436 + (class_loader_context != nullptr ? 1 : 0)
Jeff Hao10b8a6e2017-04-05 17:11:39 -0700437 + (has_base_dir ? 1 : 0)
Andreas Gampe2a2d7ba2017-11-02 19:39:29 -0700438 + (have_dex2oat_large_app_threshold ? 1 : 0)
Mathieu Chartierb41ffcc2018-01-09 00:02:17 -0800439 + (disable_cdex ? 1 : 0)
David Brazdil570d3982018-01-16 20:15:43 +0000440 + (generate_minidebug_info ? 1 : 0)
441 + (target_sdk_version != 0 ? 2 : 0)];
Jeff Sharkey90aff262016-12-12 14:28:24 -0700442 int i = 0;
Andreas Gampe6a9cf722017-07-24 16:49:10 -0700443 argv[i++] = dex2oat_bin;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700444 argv[i++] = zip_fd_arg;
445 argv[i++] = zip_location_arg;
446 argv[i++] = input_vdex_fd_arg;
447 argv[i++] = output_vdex_fd_arg;
448 argv[i++] = oat_fd_arg;
449 argv[i++] = oat_location_arg;
450 argv[i++] = instruction_set_arg;
451 if (have_dex2oat_isa_variant) {
452 argv[i++] = instruction_set_variant_arg;
453 }
454 if (have_dex2oat_isa_features) {
455 argv[i++] = instruction_set_features_arg;
456 }
457 if (have_dex2oat_Xms_flag) {
458 argv[i++] = RUNTIME_ARG;
459 argv[i++] = dex2oat_Xms_arg;
460 }
461 if (have_dex2oat_Xmx_flag) {
462 argv[i++] = RUNTIME_ARG;
463 argv[i++] = dex2oat_Xmx_arg;
464 }
465 if (have_dex2oat_compiler_filter_flag) {
466 argv[i++] = dex2oat_compiler_filter_arg;
467 }
468 if (have_dex2oat_threads_flag) {
469 argv[i++] = dex2oat_threads_arg;
470 }
471 if (have_dex2oat_swap_fd) {
472 argv[i++] = dex2oat_swap_fd;
473 }
474 if (have_dex2oat_image_fd) {
475 argv[i++] = dex2oat_image_fd;
476 }
477 if (generate_debug_info) {
478 argv[i++] = "--generate-debug-info";
479 }
480 if (debuggable) {
481 argv[i++] = "--debuggable";
482 }
483 if (have_app_image_format) {
484 argv[i++] = image_format_arg;
485 }
486 if (have_dex2oat_large_app_threshold) {
487 argv[i++] = dex2oat_large_app_threshold_arg;
488 }
489 if (dex2oat_flags_count) {
490 i += split(dex2oat_flags, argv + i);
491 }
492 if (have_dex2oat_relocation_skip_flag) {
493 argv[i++] = RUNTIME_ARG;
494 argv[i++] = dex2oat_norelocation;
495 }
496 if (profile_fd != -1) {
497 argv[i++] = profile_arg;
498 }
Jeff Hao10b8a6e2017-04-05 17:11:39 -0700499 if (has_base_dir) {
500 argv[i++] = base_dir;
501 }
Calin Juravle52c45822017-07-13 22:50:21 -0700502 if (class_loader_context != nullptr) {
503 argv[i++] = class_loader_context_arg;
504 }
Andreas Gampe2a2d7ba2017-11-02 19:39:29 -0700505 if (generate_minidebug_info) {
506 argv[i++] = kMinidebugDex2oatFlag;
507 }
Mathieu Chartierb41ffcc2018-01-09 00:02:17 -0800508 if (disable_cdex) {
509 argv[i++] = kDisableCompactDexFlag;
510 }
David Brazdil570d3982018-01-16 20:15:43 +0000511 if (target_sdk_version != 0) {
512 argv[i++] = RUNTIME_ARG;
513 argv[i++] = target_sdk_version_arg;
514 }
Calin Juravle52c45822017-07-13 22:50:21 -0700515
Jeff Sharkey90aff262016-12-12 14:28:24 -0700516 // Do not add after dex2oat_flags, they should override others for debugging.
517 argv[i] = NULL;
518
Andreas Gampe6a9cf722017-07-24 16:49:10 -0700519 execv(dex2oat_bin, (char * const *)argv);
520 ALOGE("execv(%s) failed: %s\n", dex2oat_bin, strerror(errno));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700521}
522
523/*
524 * Whether dexopt should use a swap file when compiling an APK.
525 *
526 * If kAlwaysProvideSwapFile, do this on all devices (dex2oat will make a more informed decision
527 * itself, anyways).
528 *
529 * Otherwise, read "dalvik.vm.dex2oat-swap". If the property exists, return whether it is "true".
530 *
531 * Otherwise, return true if this is a low-mem device.
532 *
533 * Otherwise, return default value.
534 */
535static bool kAlwaysProvideSwapFile = false;
536static bool kDefaultProvideSwapFile = true;
537
538static bool ShouldUseSwapFileForDexopt() {
539 if (kAlwaysProvideSwapFile) {
540 return true;
541 }
542
543 // Check the "override" property. If it exists, return value == "true".
544 char dex2oat_prop_buf[kPropertyValueMax];
545 if (get_property("dalvik.vm.dex2oat-swap", dex2oat_prop_buf, "") > 0) {
546 if (strcmp(dex2oat_prop_buf, "true") == 0) {
547 return true;
548 } else {
549 return false;
550 }
551 }
552
553 // Shortcut for default value. This is an implementation optimization for the process sketched
554 // above. If the default value is true, we can avoid to check whether this is a low-mem device,
555 // as low-mem is never returning false. The compiler will optimize this away if it can.
556 if (kDefaultProvideSwapFile) {
557 return true;
558 }
559
560 bool is_low_mem = property_get_bool("ro.config.low_ram", false);
561 if (is_low_mem) {
562 return true;
563 }
564
565 // Default value must be false here.
566 return kDefaultProvideSwapFile;
567}
568
Richard Uhler76cc0272016-12-08 10:46:35 +0000569static void SetDex2OatScheduling(bool set_to_bg) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700570 if (set_to_bg) {
571 if (set_sched_policy(0, SP_BACKGROUND) < 0) {
572 ALOGE("set_sched_policy failed: %s\n", strerror(errno));
573 exit(70);
574 }
575 if (setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_BACKGROUND) < 0) {
576 ALOGE("setpriority failed: %s\n", strerror(errno));
577 exit(71);
578 }
579 }
580}
581
Calin Juravle29591732017-11-20 17:46:19 -0800582static unique_fd create_profile(uid_t uid, const std::string& profile, int32_t flags) {
583 unique_fd fd(TEMP_FAILURE_RETRY(open(profile.c_str(), flags, 0600)));
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800584 if (fd.get() < 0) {
Calin Juravle29591732017-11-20 17:46:19 -0800585 if (errno != EEXIST) {
Calin Juravle114f0812017-03-08 19:05:07 -0800586 PLOG(ERROR) << "Failed to create profile " << profile;
Calin Juravle29591732017-11-20 17:46:19 -0800587 return invalid_unique_fd();
Calin Juravle114f0812017-03-08 19:05:07 -0800588 }
Jeff Sharkey90aff262016-12-12 14:28:24 -0700589 }
Calin Juravle114f0812017-03-08 19:05:07 -0800590 // Profiles should belong to the app; make sure of that by giving ownership to
591 // the app uid. If we cannot do that, there's no point in returning the fd
592 // since dex2oat/profman will fail with SElinux denials.
593 if (fchown(fd.get(), uid, uid) < 0) {
594 PLOG(ERROR) << "Could not chwon profile " << profile;
Calin Juravle29591732017-11-20 17:46:19 -0800595 return invalid_unique_fd();
Calin Juravle114f0812017-03-08 19:05:07 -0800596 }
Calin Juravle29591732017-11-20 17:46:19 -0800597 return fd;
Calin Juravle114f0812017-03-08 19:05:07 -0800598}
599
Calin Juravle29591732017-11-20 17:46:19 -0800600static unique_fd open_profile(uid_t uid, const std::string& profile, int32_t flags) {
Calin Juravle114f0812017-03-08 19:05:07 -0800601 // Do not follow symlinks when opening a profile:
602 // - primary profiles should not contain symlinks in their paths
603 // - secondary dex paths should have been already resolved and validated
604 flags |= O_NOFOLLOW;
605
Calin Juravle29591732017-11-20 17:46:19 -0800606 // Check if we need to create the profile
607 // Reference profiles and snapshots are created on the fly; so they might not exist beforehand.
608 unique_fd fd;
609 if ((flags & O_CREAT) != 0) {
610 fd = create_profile(uid, profile, flags);
611 } else {
612 fd.reset(TEMP_FAILURE_RETRY(open(profile.c_str(), flags)));
613 }
614
Calin Juravle114f0812017-03-08 19:05:07 -0800615 if (fd.get() < 0) {
616 if (errno != ENOENT) {
617 // Profiles might be missing for various reasons. For example, in a
618 // multi-user environment, the profile directory for one user can be created
619 // after we start a merge. In this case the current profile for that user
620 // will not be found.
621 // Also, the secondary dex profiles might be deleted by the app at any time,
622 // so we can't we need to prepare if they are missing.
623 PLOG(ERROR) << "Failed to open profile " << profile;
624 }
625 return invalid_unique_fd();
626 }
627
Jeff Sharkey90aff262016-12-12 14:28:24 -0700628 return fd;
629}
630
Calin Juravle114f0812017-03-08 19:05:07 -0800631static unique_fd open_current_profile(uid_t uid, userid_t user, const std::string& location,
632 bool is_secondary_dex) {
633 std::string profile = create_current_profile_path(user, location, is_secondary_dex);
Calin Juravle29591732017-11-20 17:46:19 -0800634 return open_profile(uid, profile, O_RDONLY);
Calin Juravle114f0812017-03-08 19:05:07 -0800635}
636
637static unique_fd open_reference_profile(uid_t uid, const std::string& location, bool read_write,
638 bool is_secondary_dex) {
639 std::string profile = create_reference_profile_path(location, is_secondary_dex);
Calin Juravle29591732017-11-20 17:46:19 -0800640 return open_profile(uid, profile, read_write ? (O_CREAT | O_RDWR) : O_RDONLY);
641}
642
643static unique_fd open_spnashot_profile(uid_t uid, const std::string& package_name,
644 const std::string& code_path) {
645 std::string profile = create_snapshot_profile_path(package_name, code_path);
646 return open_profile(uid, profile, O_CREAT | O_RDWR | O_TRUNC);
Calin Juravle114f0812017-03-08 19:05:07 -0800647}
648
649static void open_profile_files(uid_t uid, const std::string& location, bool is_secondary_dex,
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800650 /*out*/ std::vector<unique_fd>* profiles_fd, /*out*/ unique_fd* reference_profile_fd) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700651 // Open the reference profile in read-write mode as profman might need to save the merge.
Calin Juravle114f0812017-03-08 19:05:07 -0800652 *reference_profile_fd = open_reference_profile(uid, location, /*read_write*/ true,
653 is_secondary_dex);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700654
Calin Juravle114f0812017-03-08 19:05:07 -0800655 // For secondary dex files, we don't really need the user but we use it for sanity checks.
656 // Note: the user owning the dex file should be the current user.
657 std::vector<userid_t> users;
658 if (is_secondary_dex){
659 users.push_back(multiuser_get_user_id(uid));
660 } else {
661 users = get_known_users(/*volume_uuid*/ nullptr);
662 }
Jeff Sharkey90aff262016-12-12 14:28:24 -0700663 for (auto user : users) {
Calin Juravle114f0812017-03-08 19:05:07 -0800664 unique_fd profile_fd = open_current_profile(uid, user, location, is_secondary_dex);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700665 // Add to the lists only if both fds are valid.
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800666 if (profile_fd.get() >= 0) {
667 profiles_fd->push_back(std::move(profile_fd));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700668 }
669 }
670}
671
672static void drop_capabilities(uid_t uid) {
673 if (setgid(uid) != 0) {
674 ALOGE("setgid(%d) failed in installd during dexopt\n", uid);
675 exit(64);
676 }
677 if (setuid(uid) != 0) {
678 ALOGE("setuid(%d) failed in installd during dexopt\n", uid);
679 exit(65);
680 }
681 // drop capabilities
682 struct __user_cap_header_struct capheader;
683 struct __user_cap_data_struct capdata[2];
684 memset(&capheader, 0, sizeof(capheader));
685 memset(&capdata, 0, sizeof(capdata));
686 capheader.version = _LINUX_CAPABILITY_VERSION_3;
687 if (capset(&capheader, &capdata[0]) < 0) {
688 ALOGE("capset failed: %s\n", strerror(errno));
689 exit(66);
690 }
691}
692
693static constexpr int PROFMAN_BIN_RETURN_CODE_COMPILE = 0;
694static constexpr int PROFMAN_BIN_RETURN_CODE_SKIP_COMPILATION = 1;
695static constexpr int PROFMAN_BIN_RETURN_CODE_BAD_PROFILES = 2;
696static constexpr int PROFMAN_BIN_RETURN_CODE_ERROR_IO = 3;
697static constexpr int PROFMAN_BIN_RETURN_CODE_ERROR_LOCKING = 4;
698
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800699static void run_profman_merge(const std::vector<unique_fd>& profiles_fd,
700 const unique_fd& reference_profile_fd) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700701 static const size_t MAX_INT_LEN = 32;
Andreas Gampe6a9cf722017-07-24 16:49:10 -0700702 const char* profman_bin = is_debug_runtime() ? "/system/bin/profmand" : "/system/bin/profman";
Jeff Sharkey90aff262016-12-12 14:28:24 -0700703
704 std::vector<std::string> profile_args(profiles_fd.size());
705 char profile_buf[strlen("--profile-file-fd=") + MAX_INT_LEN];
706 for (size_t k = 0; k < profiles_fd.size(); k++) {
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800707 sprintf(profile_buf, "--profile-file-fd=%d", profiles_fd[k].get());
Jeff Sharkey90aff262016-12-12 14:28:24 -0700708 profile_args[k].assign(profile_buf);
709 }
710 char reference_profile_arg[strlen("--reference-profile-file-fd=") + MAX_INT_LEN];
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800711 sprintf(reference_profile_arg, "--reference-profile-file-fd=%d", reference_profile_fd.get());
Jeff Sharkey90aff262016-12-12 14:28:24 -0700712
713 // program name, reference profile fd, the final NULL and the profile fds
714 const char* argv[3 + profiles_fd.size()];
715 int i = 0;
Andreas Gampe6a9cf722017-07-24 16:49:10 -0700716 argv[i++] = profman_bin;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700717 argv[i++] = reference_profile_arg;
718 for (size_t k = 0; k < profile_args.size(); k++) {
719 argv[i++] = profile_args[k].c_str();
720 }
721 // Do not add after dex2oat_flags, they should override others for debugging.
722 argv[i] = NULL;
723
Andreas Gampe6a9cf722017-07-24 16:49:10 -0700724 execv(profman_bin, (char * const *)argv);
725 ALOGE("execv(%s) failed: %s\n", profman_bin, strerror(errno));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700726 exit(68); /* only get here on exec failure */
727}
728
729// Decides if profile guided compilation is needed or not based on existing profiles.
Calin Juravle114f0812017-03-08 19:05:07 -0800730// The location is the package name for primary apks or the dex path for secondary dex files.
731// Returns true if there is enough information in the current profiles that makes it
732// worth to recompile the given location.
Jeff Sharkey90aff262016-12-12 14:28:24 -0700733// If the return value is true all the current profiles would have been merged into
734// the reference profiles accessible with open_reference_profile().
Calin Juravle114f0812017-03-08 19:05:07 -0800735static bool analyze_profiles(uid_t uid, const std::string& location, bool is_secondary_dex) {
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800736 std::vector<unique_fd> profiles_fd;
737 unique_fd reference_profile_fd;
Calin Juravle114f0812017-03-08 19:05:07 -0800738 open_profile_files(uid, location, is_secondary_dex, &profiles_fd, &reference_profile_fd);
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800739 if (profiles_fd.empty() || (reference_profile_fd.get() < 0)) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700740 // Skip profile guided compilation because no profiles were found.
741 // Or if the reference profile info couldn't be opened.
Jeff Sharkey90aff262016-12-12 14:28:24 -0700742 return false;
743 }
744
Jeff Sharkey90aff262016-12-12 14:28:24 -0700745 pid_t pid = fork();
746 if (pid == 0) {
747 /* child -- drop privileges before continuing */
748 drop_capabilities(uid);
749 run_profman_merge(profiles_fd, reference_profile_fd);
750 exit(68); /* only get here on exec failure */
751 }
752 /* parent */
753 int return_code = wait_child(pid);
754 bool need_to_compile = false;
755 bool should_clear_current_profiles = false;
756 bool should_clear_reference_profile = false;
757 if (!WIFEXITED(return_code)) {
Calin Juravle114f0812017-03-08 19:05:07 -0800758 LOG(WARNING) << "profman failed for location " << location << ": " << return_code;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700759 } else {
760 return_code = WEXITSTATUS(return_code);
761 switch (return_code) {
762 case PROFMAN_BIN_RETURN_CODE_COMPILE:
763 need_to_compile = true;
764 should_clear_current_profiles = true;
765 should_clear_reference_profile = false;
766 break;
767 case PROFMAN_BIN_RETURN_CODE_SKIP_COMPILATION:
768 need_to_compile = false;
769 should_clear_current_profiles = false;
770 should_clear_reference_profile = false;
771 break;
772 case PROFMAN_BIN_RETURN_CODE_BAD_PROFILES:
Calin Juravle114f0812017-03-08 19:05:07 -0800773 LOG(WARNING) << "Bad profiles for location " << location;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700774 need_to_compile = false;
775 should_clear_current_profiles = true;
776 should_clear_reference_profile = true;
777 break;
778 case PROFMAN_BIN_RETURN_CODE_ERROR_IO: // fall-through
779 case PROFMAN_BIN_RETURN_CODE_ERROR_LOCKING:
780 // Temporary IO problem (e.g. locking). Ignore but log a warning.
Calin Juravle114f0812017-03-08 19:05:07 -0800781 LOG(WARNING) << "IO error while reading profiles for location " << location;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700782 need_to_compile = false;
783 should_clear_current_profiles = false;
784 should_clear_reference_profile = false;
785 break;
786 default:
787 // Unknown return code or error. Unlink profiles.
Calin Juravle114f0812017-03-08 19:05:07 -0800788 LOG(WARNING) << "Unknown error code while processing profiles for location "
789 << location << ": " << return_code;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700790 need_to_compile = false;
791 should_clear_current_profiles = true;
792 should_clear_reference_profile = true;
793 break;
794 }
795 }
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800796
Jeff Sharkey90aff262016-12-12 14:28:24 -0700797 if (should_clear_current_profiles) {
Calin Juravle114f0812017-03-08 19:05:07 -0800798 if (is_secondary_dex) {
799 // For secondary dex files, the owning user is the current user.
800 clear_current_profile(location, multiuser_get_user_id(uid), is_secondary_dex);
801 } else {
802 clear_primary_current_profiles(location);
803 }
Jeff Sharkey90aff262016-12-12 14:28:24 -0700804 }
805 if (should_clear_reference_profile) {
Calin Juravle114f0812017-03-08 19:05:07 -0800806 clear_reference_profile(location, is_secondary_dex);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700807 }
808 return need_to_compile;
809}
810
Calin Juravle114f0812017-03-08 19:05:07 -0800811// Decides if profile guided compilation is needed or not based on existing profiles.
812// The analysis is done for the primary apks of the given package.
813// Returns true if there is enough information in the current profiles that makes it
814// worth to recompile the package.
815// If the return value is true all the current profiles would have been merged into
816// the reference profiles accessible with open_reference_profile().
817bool analyze_primary_profiles(uid_t uid, const std::string& pkgname) {
818 return analyze_profiles(uid, pkgname, /*is_secondary_dex*/false);
819}
820
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800821static void run_profman_dump(const std::vector<unique_fd>& profile_fds,
822 const unique_fd& reference_profile_fd,
Jeff Sharkey90aff262016-12-12 14:28:24 -0700823 const std::vector<std::string>& dex_locations,
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800824 const std::vector<unique_fd>& apk_fds,
825 const unique_fd& output_fd) {
Jeff Sharkey90aff262016-12-12 14:28:24 -0700826 std::vector<std::string> profman_args;
827 static const char* PROFMAN_BIN = "/system/bin/profman";
828 profman_args.push_back(PROFMAN_BIN);
829 profman_args.push_back("--dump-only");
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800830 profman_args.push_back(StringPrintf("--dump-output-to-fd=%d", output_fd.get()));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700831 if (reference_profile_fd != -1) {
832 profman_args.push_back(StringPrintf("--reference-profile-file-fd=%d",
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800833 reference_profile_fd.get()));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700834 }
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800835 for (size_t i = 0; i < profile_fds.size(); i++) {
836 profman_args.push_back(StringPrintf("--profile-file-fd=%d", profile_fds[i].get()));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700837 }
838 for (const std::string& dex_location : dex_locations) {
839 profman_args.push_back(StringPrintf("--dex-location=%s", dex_location.c_str()));
840 }
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800841 for (size_t i = 0; i < apk_fds.size(); i++) {
842 profman_args.push_back(StringPrintf("--apk-fd=%d", apk_fds[i].get()));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700843 }
844 const char **argv = new const char*[profman_args.size() + 1];
845 size_t i = 0;
846 for (const std::string& profman_arg : profman_args) {
847 argv[i++] = profman_arg.c_str();
848 }
849 argv[i] = NULL;
850
851 execv(PROFMAN_BIN, (char * const *)argv);
852 ALOGE("execv(%s) failed: %s\n", PROFMAN_BIN, strerror(errno));
853 exit(68); /* only get here on exec failure */
854}
855
Calin Juravle76268c52017-03-09 13:19:42 -0800856bool dump_profiles(int32_t uid, const std::string& pkgname, const char* code_paths) {
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800857 std::vector<unique_fd> profile_fds;
858 unique_fd reference_profile_fd;
Calin Juravle76268c52017-03-09 13:19:42 -0800859 std::string out_file_name = StringPrintf("/data/misc/profman/%s.txt", pkgname.c_str());
Jeff Sharkey90aff262016-12-12 14:28:24 -0700860
Calin Juravle114f0812017-03-08 19:05:07 -0800861 open_profile_files(uid, pkgname, /*is_secondary_dex*/false,
862 &profile_fds, &reference_profile_fd);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700863
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800864 const bool has_reference_profile = (reference_profile_fd.get() != -1);
Jeff Sharkey90aff262016-12-12 14:28:24 -0700865 const bool has_profiles = !profile_fds.empty();
866
867 if (!has_reference_profile && !has_profiles) {
Calin Juravle76268c52017-03-09 13:19:42 -0800868 LOG(ERROR) << "profman dump: no profiles to dump for " << pkgname;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700869 return false;
870 }
871
Calin Juravle114f0812017-03-08 19:05:07 -0800872 unique_fd output_fd(open(out_file_name.c_str(),
873 O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0644));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700874 if (fchmod(output_fd, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) {
875 ALOGE("installd cannot chmod '%s' dump_profile\n", out_file_name.c_str());
876 return false;
877 }
878 std::vector<std::string> code_full_paths = base::Split(code_paths, ";");
879 std::vector<std::string> dex_locations;
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800880 std::vector<unique_fd> apk_fds;
Jeff Sharkey90aff262016-12-12 14:28:24 -0700881 for (const std::string& code_full_path : code_full_paths) {
882 const char* full_path = code_full_path.c_str();
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800883 unique_fd apk_fd(open(full_path, O_RDONLY | O_NOFOLLOW));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700884 if (apk_fd == -1) {
885 ALOGE("installd cannot open '%s'\n", full_path);
886 return false;
887 }
888 dex_locations.push_back(get_location_from_path(full_path));
Calin Juravle1a0af3b2017-03-09 14:33:33 -0800889 apk_fds.push_back(std::move(apk_fd));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700890 }
891
892 pid_t pid = fork();
893 if (pid == 0) {
894 /* child -- drop privileges before continuing */
895 drop_capabilities(uid);
896 run_profman_dump(profile_fds, reference_profile_fd, dex_locations,
897 apk_fds, output_fd);
898 exit(68); /* only get here on exec failure */
899 }
900 /* parent */
Jeff Sharkey90aff262016-12-12 14:28:24 -0700901 int return_code = wait_child(pid);
902 if (!WIFEXITED(return_code)) {
903 LOG(WARNING) << "profman failed for package " << pkgname << ": "
904 << return_code;
905 return false;
906 }
907 return true;
908}
909
Mathieu Chartierf966f2a2017-05-10 12:48:37 -0700910bool copy_system_profile(const std::string& system_profile,
911 uid_t packageUid, const std::string& data_profile_location) {
912 unique_fd in_fd(open(system_profile.c_str(), O_RDONLY | O_NOFOLLOW | O_CLOEXEC));
913 unique_fd out_fd(open_reference_profile(packageUid,
914 data_profile_location,
915 /*read_write*/ true,
916 /*secondary*/ false));
917 if (in_fd.get() < 0) {
918 PLOG(WARNING) << "Could not open profile " << system_profile;
919 return false;
920 }
921 if (out_fd.get() < 0) {
922 PLOG(WARNING) << "Could not open profile " << data_profile_location;
923 return false;
924 }
925
Mathieu Chartier78f71fe2017-06-14 13:02:26 -0700926 // As a security measure we want to write the profile information with the reduced capabilities
927 // of the package user id. So we fork and drop capabilities in the child.
Mathieu Chartierf966f2a2017-05-10 12:48:37 -0700928 pid_t pid = fork();
929 if (pid == 0) {
930 /* child -- drop privileges before continuing */
931 drop_capabilities(packageUid);
932
933 if (flock(out_fd.get(), LOCK_EX | LOCK_NB) != 0) {
934 if (errno != EWOULDBLOCK) {
935 PLOG(WARNING) << "Error locking profile " << data_profile_location;
936 }
937 // This implies that the app owning this profile is running
938 // (and has acquired the lock).
939 //
940 // The app never acquires the lock for the reference profiles of primary apks.
941 // Only dex2oat from installd will do that. Since installd is single threaded
942 // we should not see this case. Nevertheless be prepared for it.
943 PLOG(WARNING) << "Failed to flock " << data_profile_location;
944 return false;
945 }
946
947 bool truncated = ftruncate(out_fd.get(), 0) == 0;
948 if (!truncated) {
949 PLOG(WARNING) << "Could not truncate " << data_profile_location;
950 }
951
952 // Copy over data.
953 static constexpr size_t kBufferSize = 4 * 1024;
954 char buffer[kBufferSize];
955 while (true) {
956 ssize_t bytes = read(in_fd.get(), buffer, kBufferSize);
957 if (bytes == 0) {
958 break;
959 }
960 write(out_fd.get(), buffer, bytes);
961 }
962 if (flock(out_fd.get(), LOCK_UN) != 0) {
963 PLOG(WARNING) << "Error unlocking profile " << data_profile_location;
964 }
Mathieu Chartier78f71fe2017-06-14 13:02:26 -0700965 // Use _exit since we don't want to run the global destructors in the child.
966 // b/62597429
967 _exit(0);
Mathieu Chartierf966f2a2017-05-10 12:48:37 -0700968 }
969 /* parent */
970 int return_code = wait_child(pid);
971 return return_code == 0;
972}
973
Jeff Sharkey90aff262016-12-12 14:28:24 -0700974static std::string replace_file_extension(const std::string& oat_path, const std::string& new_ext) {
975 // A standard dalvik-cache entry. Replace ".dex" with `new_ext`.
976 if (EndsWith(oat_path, ".dex")) {
977 std::string new_path = oat_path;
978 new_path.replace(new_path.length() - strlen(".dex"), strlen(".dex"), new_ext);
Elliott Hughes969e4f82017-12-20 12:34:09 -0800979 CHECK(EndsWith(new_path, new_ext));
Jeff Sharkey90aff262016-12-12 14:28:24 -0700980 return new_path;
981 }
982
983 // An odex entry. Not that this may not be an extension, e.g., in the OTA
984 // case (where the base name will have an extension for the B artifact).
985 size_t odex_pos = oat_path.rfind(".odex");
986 if (odex_pos != std::string::npos) {
987 std::string new_path = oat_path;
988 new_path.replace(odex_pos, strlen(".odex"), new_ext);
989 CHECK_NE(new_path.find(new_ext), std::string::npos);
990 return new_path;
991 }
992
993 // Don't know how to handle this.
994 return "";
995}
996
997// Translate the given oat path to an art (app image) path. An empty string
998// denotes an error.
999static std::string create_image_filename(const std::string& oat_path) {
1000 return replace_file_extension(oat_path, ".art");
1001}
1002
1003// Translate the given oat path to a vdex path. An empty string denotes an error.
1004static std::string create_vdex_filename(const std::string& oat_path) {
1005 return replace_file_extension(oat_path, ".vdex");
1006}
1007
Jeff Sharkey90aff262016-12-12 14:28:24 -07001008static int open_output_file(const char* file_name, bool recreate, int permissions) {
1009 int flags = O_RDWR | O_CREAT;
1010 if (recreate) {
1011 if (unlink(file_name) < 0) {
1012 if (errno != ENOENT) {
1013 PLOG(ERROR) << "open_output_file: Couldn't unlink " << file_name;
1014 }
1015 }
1016 flags |= O_EXCL;
1017 }
1018 return open(file_name, flags, permissions);
1019}
1020
Calin Juravle2289c0a2017-02-15 12:44:14 -08001021static bool set_permissions_and_ownership(
1022 int fd, bool is_public, int uid, const char* path, bool is_secondary_dex) {
1023 // Primary apks are owned by the system. Secondary dex files are owned by the app.
1024 int owning_uid = is_secondary_dex ? uid : AID_SYSTEM;
Jeff Sharkey90aff262016-12-12 14:28:24 -07001025 if (fchmod(fd,
1026 S_IRUSR|S_IWUSR|S_IRGRP |
1027 (is_public ? S_IROTH : 0)) < 0) {
1028 ALOGE("installd cannot chmod '%s' during dexopt\n", path);
1029 return false;
Calin Juravle2289c0a2017-02-15 12:44:14 -08001030 } else if (fchown(fd, owning_uid, uid) < 0) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001031 ALOGE("installd cannot chown '%s' during dexopt\n", path);
1032 return false;
1033 }
1034 return true;
1035}
1036
1037static bool IsOutputDalvikCache(const char* oat_dir) {
1038 // InstallerConnection.java (which invokes installd) transforms Java null arguments
1039 // into '!'. Play it safe by handling it both.
1040 // TODO: ensure we never get null.
1041 // TODO: pass a flag instead of inferring if the output is dalvik cache.
1042 return oat_dir == nullptr || oat_dir[0] == '!';
1043}
1044
Calin Juravled23dee72017-07-06 16:29:11 -07001045// Best-effort check whether we can fit the the path into our buffers.
1046// Note: the cache path will require an additional 5 bytes for ".swap", but we'll try to run
1047// without a swap file, if necessary. Reference profiles file also add an extra ".prof"
1048// extension to the cache path (5 bytes).
1049// TODO(calin): move away from char* buffers and PKG_PATH_MAX.
1050static bool validate_dex_path_size(const std::string& dex_path) {
1051 if (dex_path.size() >= (PKG_PATH_MAX - 8)) {
1052 LOG(ERROR) << "dex_path too long: " << dex_path;
1053 return false;
1054 }
1055 return true;
1056}
1057
Jeff Sharkey90aff262016-12-12 14:28:24 -07001058static bool create_oat_out_path(const char* apk_path, const char* instruction_set,
Calin Juravle80a21252017-01-17 14:43:25 -08001059 const char* oat_dir, bool is_secondary_dex, /*out*/ char* out_oat_path) {
Calin Juravled23dee72017-07-06 16:29:11 -07001060 if (!validate_dex_path_size(apk_path)) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001061 return false;
1062 }
1063
1064 if (!IsOutputDalvikCache(oat_dir)) {
Calin Juravle80a21252017-01-17 14:43:25 -08001065 // Oat dirs for secondary dex files are already validated.
1066 if (!is_secondary_dex && validate_apk_path(oat_dir)) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001067 ALOGE("cannot validate apk path with oat_dir '%s'\n", oat_dir);
1068 return false;
1069 }
1070 if (!calculate_oat_file_path(out_oat_path, oat_dir, apk_path, instruction_set)) {
1071 return false;
1072 }
1073 } else {
1074 if (!create_cache_path(out_oat_path, apk_path, instruction_set)) {
1075 return false;
1076 }
1077 }
1078 return true;
1079}
1080
1081// Helper for fd management. This is similar to a unique_fd in that it closes the file descriptor
1082// on destruction. It will also run the given cleanup (unless told not to) after closing.
1083//
1084// Usage example:
1085//
Calin Juravle7a570e82017-01-14 16:23:30 -08001086// Dex2oatFileWrapper file(open(...),
Jeff Sharkey90aff262016-12-12 14:28:24 -07001087// [name]() {
1088// unlink(name.c_str());
1089// });
1090// // Note: care needs to be taken about name, as it needs to have a lifetime longer than the
1091// wrapper if captured as a reference.
1092//
1093// if (file.get() == -1) {
1094// // Error opening...
1095// }
1096//
1097// ...
1098// if (error) {
1099// // At this point, when the Dex2oatFileWrapper is destructed, the cleanup function will run
1100// // and delete the file (after the fd is closed).
1101// return -1;
1102// }
1103//
1104// (Success case)
1105// file.SetCleanup(false);
1106// // At this point, when the Dex2oatFileWrapper is destructed, the cleanup function will not run
1107// // (leaving the file around; after the fd is closed).
1108//
Jeff Sharkey90aff262016-12-12 14:28:24 -07001109class Dex2oatFileWrapper {
1110 public:
Calin Juravle7a570e82017-01-14 16:23:30 -08001111 Dex2oatFileWrapper() : value_(-1), cleanup_(), do_cleanup_(true), auto_close_(true) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001112 }
1113
Calin Juravle7a570e82017-01-14 16:23:30 -08001114 Dex2oatFileWrapper(int value, std::function<void ()> cleanup)
1115 : value_(value), cleanup_(cleanup), do_cleanup_(true), auto_close_(true) {}
1116
1117 Dex2oatFileWrapper(Dex2oatFileWrapper&& other) {
1118 value_ = other.value_;
1119 cleanup_ = other.cleanup_;
1120 do_cleanup_ = other.do_cleanup_;
1121 auto_close_ = other.auto_close_;
1122 other.release();
1123 }
1124
1125 Dex2oatFileWrapper& operator=(Dex2oatFileWrapper&& other) {
1126 value_ = other.value_;
1127 cleanup_ = other.cleanup_;
1128 do_cleanup_ = other.do_cleanup_;
1129 auto_close_ = other.auto_close_;
1130 other.release();
1131 return *this;
1132 }
Jeff Sharkey90aff262016-12-12 14:28:24 -07001133
1134 ~Dex2oatFileWrapper() {
1135 reset(-1);
1136 }
1137
1138 int get() {
1139 return value_;
1140 }
1141
1142 void SetCleanup(bool cleanup) {
1143 do_cleanup_ = cleanup;
1144 }
1145
1146 void reset(int new_value) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001147 if (auto_close_ && value_ >= 0) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001148 close(value_);
1149 }
1150 if (do_cleanup_ && cleanup_ != nullptr) {
1151 cleanup_();
1152 }
1153
1154 value_ = new_value;
1155 }
1156
Calin Juravle7a570e82017-01-14 16:23:30 -08001157 void reset(int new_value, std::function<void ()> new_cleanup) {
1158 if (auto_close_ && value_ >= 0) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001159 close(value_);
1160 }
1161 if (do_cleanup_ && cleanup_ != nullptr) {
1162 cleanup_();
1163 }
1164
1165 value_ = new_value;
1166 cleanup_ = new_cleanup;
1167 }
1168
Calin Juravle7a570e82017-01-14 16:23:30 -08001169 void DisableAutoClose() {
1170 auto_close_ = false;
1171 }
1172
Jeff Sharkey90aff262016-12-12 14:28:24 -07001173 private:
Calin Juravle7a570e82017-01-14 16:23:30 -08001174 void release() {
1175 value_ = -1;
1176 do_cleanup_ = false;
1177 cleanup_ = nullptr;
1178 }
Jeff Sharkey90aff262016-12-12 14:28:24 -07001179 int value_;
Calin Juravle7a570e82017-01-14 16:23:30 -08001180 std::function<void ()> cleanup_;
Jeff Sharkey90aff262016-12-12 14:28:24 -07001181 bool do_cleanup_;
Calin Juravle7a570e82017-01-14 16:23:30 -08001182 bool auto_close_;
Jeff Sharkey90aff262016-12-12 14:28:24 -07001183};
1184
Calin Juravle7a570e82017-01-14 16:23:30 -08001185// (re)Creates the app image if needed.
1186Dex2oatFileWrapper maybe_open_app_image(const char* out_oat_path, bool profile_guided,
Calin Juravle2289c0a2017-02-15 12:44:14 -08001187 bool is_public, int uid, bool is_secondary_dex) {
Nicolas Geoffrayaa17ab42017-08-15 14:51:05 +01001188
1189 // We don't create an image for secondary dex files.
1190 if (is_secondary_dex) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001191 return Dex2oatFileWrapper();
1192 }
Jeff Sharkey90aff262016-12-12 14:28:24 -07001193
Calin Juravle7a570e82017-01-14 16:23:30 -08001194 const std::string image_path = create_image_filename(out_oat_path);
1195 if (image_path.empty()) {
1196 // Happens when the out_oat_path has an unknown extension.
1197 return Dex2oatFileWrapper();
1198 }
Nicolas Geoffrayaa17ab42017-08-15 14:51:05 +01001199
1200 // Use app images only if it is enabled (by a set image format) and we are compiling
1201 // profile-guided (so the app image doesn't conservatively contain all classes).
1202 if (!profile_guided) {
1203 // In case there is a stale image, remove it now. Ignore any error.
1204 unlink(image_path.c_str());
1205 return Dex2oatFileWrapper();
1206 }
Calin Juravle7a570e82017-01-14 16:23:30 -08001207 char app_image_format[kPropertyValueMax];
1208 bool have_app_image_format =
1209 get_property("dalvik.vm.appimageformat", app_image_format, NULL) > 0;
1210 if (!have_app_image_format) {
1211 return Dex2oatFileWrapper();
1212 }
1213 // Recreate is true since we do not want to modify a mapped image. If the app is
1214 // already running and we modify the image file, it can cause crashes (b/27493510).
1215 Dex2oatFileWrapper wrapper_fd(
1216 open_output_file(image_path.c_str(), true /*recreate*/, 0600 /*permissions*/),
1217 [image_path]() { unlink(image_path.c_str()); });
1218 if (wrapper_fd.get() < 0) {
1219 // Could not create application image file. Go on since we can compile without it.
1220 LOG(ERROR) << "installd could not create '" << image_path
1221 << "' for image file during dexopt";
1222 // If we have a valid image file path but no image fd, explicitly erase the image file.
1223 if (unlink(image_path.c_str()) < 0) {
1224 if (errno != ENOENT) {
1225 PLOG(ERROR) << "Couldn't unlink image file " << image_path;
1226 }
1227 }
1228 } else if (!set_permissions_and_ownership(
Calin Juravle2289c0a2017-02-15 12:44:14 -08001229 wrapper_fd.get(), is_public, uid, image_path.c_str(), is_secondary_dex)) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001230 ALOGE("installd cannot set owner '%s' for image during dexopt\n", image_path.c_str());
1231 wrapper_fd.reset(-1);
1232 }
Jeff Sharkey90aff262016-12-12 14:28:24 -07001233
Calin Juravle7a570e82017-01-14 16:23:30 -08001234 return wrapper_fd;
1235}
1236
1237// Creates the dexopt swap file if necessary and return its fd.
1238// Returns -1 if there's no need for a swap or in case of errors.
Calin Juravle1a0af3b2017-03-09 14:33:33 -08001239unique_fd maybe_open_dexopt_swap_file(const char* out_oat_path) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001240 if (!ShouldUseSwapFileForDexopt()) {
Calin Juravle1a0af3b2017-03-09 14:33:33 -08001241 return invalid_unique_fd();
Calin Juravle7a570e82017-01-14 16:23:30 -08001242 }
Jeff Sharkeyc1149c92017-09-21 14:51:09 -06001243 auto swap_file_name = std::string(out_oat_path) + ".swap";
Calin Juravle1a0af3b2017-03-09 14:33:33 -08001244 unique_fd swap_fd(open_output_file(
Jeff Sharkeyc1149c92017-09-21 14:51:09 -06001245 swap_file_name.c_str(), /*recreate*/true, /*permissions*/0600));
Calin Juravle7a570e82017-01-14 16:23:30 -08001246 if (swap_fd.get() < 0) {
1247 // Could not create swap file. Optimistically go on and hope that we can compile
1248 // without it.
Jeff Sharkeyc1149c92017-09-21 14:51:09 -06001249 ALOGE("installd could not create '%s' for swap during dexopt\n", swap_file_name.c_str());
Calin Juravle7a570e82017-01-14 16:23:30 -08001250 } else {
1251 // Immediately unlink. We don't really want to hit flash.
Jeff Sharkeyc1149c92017-09-21 14:51:09 -06001252 if (unlink(swap_file_name.c_str()) < 0) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001253 PLOG(ERROR) << "Couldn't unlink swap file " << swap_file_name;
1254 }
1255 }
1256 return swap_fd;
1257}
1258
1259// Opens the reference profiles if needed.
1260// Note that the reference profile might not exist so it's OK if the fd will be -1.
Calin Juravle114f0812017-03-08 19:05:07 -08001261Dex2oatFileWrapper maybe_open_reference_profile(const std::string& pkgname,
1262 const std::string& dex_path, bool profile_guided, bool is_public, int uid,
1263 bool is_secondary_dex) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001264 // Public apps should not be compiled with profile information ever. Same goes for the special
1265 // package '*' used for the system server.
Calin Juravle114f0812017-03-08 19:05:07 -08001266 if (!profile_guided || is_public || (pkgname[0] == '*')) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001267 return Dex2oatFileWrapper();
Jeff Sharkey90aff262016-12-12 14:28:24 -07001268 }
Calin Juravle114f0812017-03-08 19:05:07 -08001269
1270 // Open reference profile in read only mode as dex2oat does not get write permissions.
1271 const std::string location = is_secondary_dex ? dex_path : pkgname;
1272 unique_fd ufd = open_reference_profile(uid, location, /*read_write*/false, is_secondary_dex);
1273 const auto& cleanup = [location, is_secondary_dex]() {
1274 clear_reference_profile(location.c_str(), is_secondary_dex);
1275 };
1276 return Dex2oatFileWrapper(ufd.release(), cleanup);
Calin Juravle7a570e82017-01-14 16:23:30 -08001277}
Jeff Sharkey90aff262016-12-12 14:28:24 -07001278
Calin Juravle7a570e82017-01-14 16:23:30 -08001279// Opens the vdex files and assigns the input fd to in_vdex_wrapper_fd and the output fd to
1280// out_vdex_wrapper_fd. Returns true for success or false in case of errors.
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001281bool open_vdex_files_for_dex2oat(const char* apk_path, const char* out_oat_path, int dexopt_needed,
Nicolas Geoffray3c95f2d2017-04-24 13:34:59 +00001282 const char* instruction_set, bool is_public, int uid, bool is_secondary_dex,
Nicolas Geoffrayb03814f2017-06-05 12:38:10 +00001283 bool profile_guided, Dex2oatFileWrapper* in_vdex_wrapper_fd,
Calin Juravle7a570e82017-01-14 16:23:30 -08001284 Dex2oatFileWrapper* out_vdex_wrapper_fd) {
1285 CHECK(in_vdex_wrapper_fd != nullptr);
1286 CHECK(out_vdex_wrapper_fd != nullptr);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001287 // Open the existing VDEX. We do this before creating the new output VDEX, which will
1288 // unlink the old one.
Richard Uhler76cc0272016-12-08 10:46:35 +00001289 char in_odex_path[PKG_PATH_MAX];
1290 int dexopt_action = abs(dexopt_needed);
1291 bool is_odex_location = dexopt_needed < 0;
Jeff Sharkey90aff262016-12-12 14:28:24 -07001292 std::string in_vdex_path_str;
Nicolas Geoffrayb03814f2017-06-05 12:38:10 +00001293
1294 // Infer the name of the output VDEX.
1295 const std::string out_vdex_path_str = create_vdex_filename(out_oat_path);
1296 if (out_vdex_path_str.empty()) {
1297 return false;
1298 }
1299
1300 bool update_vdex_in_place = false;
Nicolas Geoffray3c95f2d2017-04-24 13:34:59 +00001301 if (dexopt_action != DEX2OAT_FROM_SCRATCH) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001302 // Open the possibly existing vdex. If none exist, we pass -1 to dex2oat for input-vdex-fd.
1303 const char* path = nullptr;
1304 if (is_odex_location) {
1305 if (calculate_odex_file_path(in_odex_path, apk_path, instruction_set)) {
1306 path = in_odex_path;
1307 } else {
1308 ALOGE("installd cannot compute input vdex location for '%s'\n", apk_path);
Calin Juravle7a570e82017-01-14 16:23:30 -08001309 return false;
Jeff Sharkey90aff262016-12-12 14:28:24 -07001310 }
1311 } else {
1312 path = out_oat_path;
1313 }
1314 in_vdex_path_str = create_vdex_filename(path);
1315 if (in_vdex_path_str.empty()) {
1316 ALOGE("installd cannot compute input vdex location for '%s'\n", path);
Calin Juravle7a570e82017-01-14 16:23:30 -08001317 return false;
Jeff Sharkey90aff262016-12-12 14:28:24 -07001318 }
Nicolas Geoffrayb03814f2017-06-05 12:38:10 +00001319 // We can update in place when all these conditions are met:
1320 // 1) The vdex location to write to is the same as the vdex location to read (vdex files
1321 // on /system typically cannot be updated in place).
1322 // 2) We dex2oat due to boot image change, because we then know the existing vdex file
1323 // cannot be currently used by a running process.
1324 // 3) We are not doing a profile guided compilation, because dexlayout requires two
1325 // different vdex files to operate.
1326 update_vdex_in_place =
1327 (in_vdex_path_str == out_vdex_path_str) &&
1328 (dexopt_action == DEX2OAT_FOR_BOOT_IMAGE) &&
1329 !profile_guided;
1330 if (update_vdex_in_place) {
1331 // Open the file read-write to be able to update it.
1332 in_vdex_wrapper_fd->reset(open(in_vdex_path_str.c_str(), O_RDWR, 0));
1333 if (in_vdex_wrapper_fd->get() == -1) {
1334 // If we failed to open the file, we cannot update it in place.
1335 update_vdex_in_place = false;
1336 }
1337 } else {
1338 in_vdex_wrapper_fd->reset(open(in_vdex_path_str.c_str(), O_RDONLY, 0));
1339 }
Jeff Sharkey90aff262016-12-12 14:28:24 -07001340 }
1341
Nicolas Geoffrayb03814f2017-06-05 12:38:10 +00001342 // If we are updating the vdex in place, we do not need to recreate a vdex,
1343 // and can use the same existing one.
1344 if (update_vdex_in_place) {
1345 // We unlink the file in case the invocation of dex2oat fails, to ensure we don't
1346 // have bogus stale vdex files.
1347 out_vdex_wrapper_fd->reset(
1348 in_vdex_wrapper_fd->get(),
1349 [out_vdex_path_str]() { unlink(out_vdex_path_str.c_str()); });
1350 // Disable auto close for the in wrapper fd (it will be done when destructing the out
1351 // wrapper).
1352 in_vdex_wrapper_fd->DisableAutoClose();
1353 } else {
1354 out_vdex_wrapper_fd->reset(
1355 open_output_file(out_vdex_path_str.c_str(), /*recreate*/true, /*permissions*/0644),
1356 [out_vdex_path_str]() { unlink(out_vdex_path_str.c_str()); });
1357 if (out_vdex_wrapper_fd->get() < 0) {
1358 ALOGE("installd cannot open vdex'%s' during dexopt\n", out_vdex_path_str.c_str());
1359 return false;
1360 }
Jeff Sharkey90aff262016-12-12 14:28:24 -07001361 }
Calin Juravle7a570e82017-01-14 16:23:30 -08001362 if (!set_permissions_and_ownership(out_vdex_wrapper_fd->get(), is_public, uid,
Calin Juravle2289c0a2017-02-15 12:44:14 -08001363 out_vdex_path_str.c_str(), is_secondary_dex)) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001364 ALOGE("installd cannot set owner '%s' for vdex during dexopt\n", out_vdex_path_str.c_str());
1365 return false;
1366 }
1367
1368 // If we got here we successfully opened the vdex files.
1369 return true;
1370}
1371
1372// Opens the output oat file for the given apk.
1373// If successful it stores the output path into out_oat_path and returns true.
1374Dex2oatFileWrapper open_oat_out_file(const char* apk_path, const char* oat_dir,
Calin Juravle80a21252017-01-17 14:43:25 -08001375 bool is_public, int uid, const char* instruction_set, bool is_secondary_dex,
1376 char* out_oat_path) {
1377 if (!create_oat_out_path(apk_path, instruction_set, oat_dir, is_secondary_dex, out_oat_path)) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001378 return Dex2oatFileWrapper();
1379 }
1380 const std::string out_oat_path_str(out_oat_path);
1381 Dex2oatFileWrapper wrapper_fd(
1382 open_output_file(out_oat_path, /*recreate*/true, /*permissions*/0644),
1383 [out_oat_path_str]() { unlink(out_oat_path_str.c_str()); });
1384 if (wrapper_fd.get() < 0) {
Calin Juravle80a21252017-01-17 14:43:25 -08001385 PLOG(ERROR) << "installd cannot open output during dexopt" << out_oat_path;
Calin Juravle2289c0a2017-02-15 12:44:14 -08001386 } else if (!set_permissions_and_ownership(
1387 wrapper_fd.get(), is_public, uid, out_oat_path, is_secondary_dex)) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001388 ALOGE("installd cannot set owner '%s' for output during dexopt\n", out_oat_path);
1389 wrapper_fd.reset(-1);
1390 }
1391 return wrapper_fd;
1392}
1393
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001394// Creates RDONLY fds for oat and vdex files, if exist.
1395// Returns false if it fails to create oat out path for the given apk path.
1396// Note that the method returns true even if the files could not be opened.
1397bool maybe_open_oat_and_vdex_file(const std::string& apk_path,
1398 const std::string& oat_dir,
1399 const std::string& instruction_set,
1400 bool is_secondary_dex,
1401 unique_fd* oat_file_fd,
1402 unique_fd* vdex_file_fd) {
1403 char oat_path[PKG_PATH_MAX];
1404 if (!create_oat_out_path(apk_path.c_str(),
1405 instruction_set.c_str(),
1406 oat_dir.c_str(),
1407 is_secondary_dex,
1408 oat_path)) {
Calin Juravle7d765462017-09-04 15:57:10 -07001409 LOG(ERROR) << "Could not create oat out path for "
1410 << apk_path << " with oat dir " << oat_dir;
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001411 return false;
1412 }
1413 oat_file_fd->reset(open(oat_path, O_RDONLY));
1414 if (oat_file_fd->get() < 0) {
1415 PLOG(INFO) << "installd cannot open oat file during dexopt" << oat_path;
1416 }
1417
1418 std::string vdex_filename = create_vdex_filename(oat_path);
1419 vdex_file_fd->reset(open(vdex_filename.c_str(), O_RDONLY));
1420 if (vdex_file_fd->get() < 0) {
1421 PLOG(INFO) << "installd cannot open vdex file during dexopt" << vdex_filename;
1422 }
1423
1424 return true;
1425}
1426
Calin Juravle7a570e82017-01-14 16:23:30 -08001427// Updates the access times of out_oat_path based on those from apk_path.
1428void update_out_oat_access_times(const char* apk_path, const char* out_oat_path) {
1429 struct stat input_stat;
1430 memset(&input_stat, 0, sizeof(input_stat));
1431 if (stat(apk_path, &input_stat) != 0) {
1432 PLOG(ERROR) << "Could not stat " << apk_path << " during dexopt";
1433 return;
1434 }
1435
1436 struct utimbuf ut;
1437 ut.actime = input_stat.st_atime;
1438 ut.modtime = input_stat.st_mtime;
1439 if (utime(out_oat_path, &ut) != 0) {
1440 PLOG(WARNING) << "Could not update access times for " << apk_path << " during dexopt";
1441 }
1442}
1443
Calin Juravle80a21252017-01-17 14:43:25 -08001444// Runs (execv) dexoptanalyzer on the given arguments.
Calin Juravle114f0812017-03-08 19:05:07 -08001445// The analyzer will check if the dex_file needs to be (re)compiled to match the compiler_filter.
1446// If this is for a profile guided compilation, profile_was_updated will tell whether or not
1447// the profile has changed.
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001448static void exec_dexoptanalyzer(const std::string& dex_file, int vdex_fd, int oat_fd,
1449 int zip_fd, const std::string& instruction_set, const std::string& compiler_filter,
1450 bool profile_was_updated, bool downgrade,
Calin Juravle58cab072017-09-12 01:02:26 -07001451 const char* class_loader_context) {
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001452 CHECK_GE(zip_fd, 0);
Andreas Gampe6a9cf722017-07-24 16:49:10 -07001453 const char* dexoptanalyzer_bin =
1454 is_debug_runtime()
1455 ? "/system/bin/dexoptanalyzerd"
1456 : "/system/bin/dexoptanalyzer";
Calin Juravle80a21252017-01-17 14:43:25 -08001457 static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
1458
Calin Juravled23dee72017-07-06 16:29:11 -07001459 if (instruction_set.size() >= MAX_INSTRUCTION_SET_LEN) {
1460 LOG(ERROR) << "Instruction set " << instruction_set
1461 << " longer than max length of " << MAX_INSTRUCTION_SET_LEN;
Calin Juravle80a21252017-01-17 14:43:25 -08001462 return;
1463 }
1464
Calin Juravled23dee72017-07-06 16:29:11 -07001465 std::string dex_file_arg = "--dex-file=" + dex_file;
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001466 std::string oat_fd_arg = "--oat-fd=" + std::to_string(oat_fd);
1467 std::string vdex_fd_arg = "--vdex-fd=" + std::to_string(vdex_fd);
1468 std::string zip_fd_arg = "--zip-fd=" + std::to_string(zip_fd);
Calin Juravled23dee72017-07-06 16:29:11 -07001469 std::string isa_arg = "--isa=" + instruction_set;
1470 std::string compiler_filter_arg = "--compiler-filter=" + compiler_filter;
Calin Juravle114f0812017-03-08 19:05:07 -08001471 const char* assume_profile_changed = "--assume-profile-changed";
Shubham Ajmera54ef8622017-06-22 11:10:27 -07001472 const char* downgrade_flag = "--downgrade";
Calin Juravle58cab072017-09-12 01:02:26 -07001473 std::string class_loader_context_arg = "--class-loader-context=";
1474 if (class_loader_context != nullptr) {
1475 class_loader_context_arg += class_loader_context;
1476 }
Calin Juravle80a21252017-01-17 14:43:25 -08001477
Calin Juravle80a21252017-01-17 14:43:25 -08001478 // program name, dex file, isa, filter, the final NULL
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001479 const int argc = 6 +
Shubham Ajmera54ef8622017-06-22 11:10:27 -07001480 (profile_was_updated ? 1 : 0) +
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001481 (vdex_fd >= 0 ? 1 : 0) +
1482 (oat_fd >= 0 ? 1 : 0) +
Calin Juravle58cab072017-09-12 01:02:26 -07001483 (downgrade ? 1 : 0) +
1484 (class_loader_context != nullptr ? 1 : 0);
Shubham Ajmera54ef8622017-06-22 11:10:27 -07001485 const char* argv[argc];
Calin Juravle80a21252017-01-17 14:43:25 -08001486 int i = 0;
Andreas Gampe6a9cf722017-07-24 16:49:10 -07001487 argv[i++] = dexoptanalyzer_bin;
Calin Juravled23dee72017-07-06 16:29:11 -07001488 argv[i++] = dex_file_arg.c_str();
1489 argv[i++] = isa_arg.c_str();
1490 argv[i++] = compiler_filter_arg.c_str();
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001491 if (oat_fd >= 0) {
1492 argv[i++] = oat_fd_arg.c_str();
1493 }
1494 if (vdex_fd >= 0) {
1495 argv[i++] = vdex_fd_arg.c_str();
1496 }
1497 argv[i++] = zip_fd_arg.c_str();
Calin Juravle114f0812017-03-08 19:05:07 -08001498 if (profile_was_updated) {
1499 argv[i++] = assume_profile_changed;
1500 }
Shubham Ajmera54ef8622017-06-22 11:10:27 -07001501 if (downgrade) {
1502 argv[i++] = downgrade_flag;
1503 }
Calin Juravle58cab072017-09-12 01:02:26 -07001504 if (class_loader_context != nullptr) {
Calin Juravle91501072017-10-26 15:44:53 -07001505 argv[i++] = class_loader_context_arg.c_str();
Calin Juravle58cab072017-09-12 01:02:26 -07001506 }
Calin Juravle80a21252017-01-17 14:43:25 -08001507 argv[i] = NULL;
1508
Andreas Gampe6a9cf722017-07-24 16:49:10 -07001509 execv(dexoptanalyzer_bin, (char * const *)argv);
1510 ALOGE("execv(%s) failed: %s\n", dexoptanalyzer_bin, strerror(errno));
Calin Juravle80a21252017-01-17 14:43:25 -08001511}
1512
1513// Prepares the oat dir for the secondary dex files.
Calin Juravle114f0812017-03-08 19:05:07 -08001514static bool prepare_secondary_dex_oat_dir(const std::string& dex_path, int uid,
Calin Juravle7d765462017-09-04 15:57:10 -07001515 const char* instruction_set) {
Calin Juravle114f0812017-03-08 19:05:07 -08001516 unsigned long dirIndex = dex_path.rfind('/');
Calin Juravle80a21252017-01-17 14:43:25 -08001517 if (dirIndex == std::string::npos) {
Calin Juravlec9eab382017-01-25 01:17:17 -08001518 LOG(ERROR ) << "Unexpected dir structure for secondary dex " << dex_path;
Calin Juravle80a21252017-01-17 14:43:25 -08001519 return false;
1520 }
Calin Juravle114f0812017-03-08 19:05:07 -08001521 std::string dex_dir = dex_path.substr(0, dirIndex);
Calin Juravle80a21252017-01-17 14:43:25 -08001522
Calin Juravle80a21252017-01-17 14:43:25 -08001523 // Create oat file output directory.
Calin Juravleebc8a792017-04-04 20:21:05 -07001524 mode_t oat_dir_mode = S_IRWXU | S_IRWXG | S_IXOTH;
1525 if (prepare_app_cache_dir(dex_dir, "oat", oat_dir_mode, uid, uid) != 0) {
Calin Juravlec9eab382017-01-25 01:17:17 -08001526 LOG(ERROR) << "Could not prepare oat dir for secondary dex: " << dex_path;
Calin Juravle80a21252017-01-17 14:43:25 -08001527 return false;
1528 }
1529
1530 char oat_dir[PKG_PATH_MAX];
Calin Juravle114f0812017-03-08 19:05:07 -08001531 snprintf(oat_dir, PKG_PATH_MAX, "%s/oat", dex_dir.c_str());
Calin Juravle80a21252017-01-17 14:43:25 -08001532
Calin Juravle7d765462017-09-04 15:57:10 -07001533 if (prepare_app_cache_dir(oat_dir, instruction_set, oat_dir_mode, uid, uid) != 0) {
Calin Juravlec9eab382017-01-25 01:17:17 -08001534 LOG(ERROR) << "Could not prepare oat/isa dir for secondary dex: " << dex_path;
Calin Juravle80a21252017-01-17 14:43:25 -08001535 return false;
1536 }
1537
1538 return true;
1539}
1540
Calin Juravle7d765462017-09-04 15:57:10 -07001541// Return codes for identifying the reason why dexoptanalyzer was not invoked when processing
1542// secondary dex files. This return codes are returned by the child process created for
1543// analyzing secondary dex files in process_secondary_dex_dexopt.
Calin Juravle80a21252017-01-17 14:43:25 -08001544
Calin Juravle7d765462017-09-04 15:57:10 -07001545// The dexoptanalyzer was not invoked because of validation or IO errors.
1546static int constexpr SECONDARY_DEX_DEXOPTANALYZER_SKIPPED = 200;
1547// The dexoptanalyzer was not invoked because the dex file does not exist anymore.
1548static int constexpr SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE = 201;
1549
1550// Verifies the result of analyzing secondary dex files from process_secondary_dex_dexopt.
Calin Juravle80a21252017-01-17 14:43:25 -08001551// If the result is valid returns true and sets dexopt_needed_out to a valid value.
1552// Returns false for errors or unexpected result values.
Calin Juravle7d765462017-09-04 15:57:10 -07001553// The result is expected to be either one of SECONDARY_DEX_* codes or a valid exit code
1554// of dexoptanalyzer.
1555static bool process_secondary_dexoptanalyzer_result(const std::string& dex_path, int result,
Calin Juravle80a21252017-01-17 14:43:25 -08001556 int* dexopt_needed_out) {
1557 // The result values are defined in dexoptanalyzer.
1558 switch (result) {
Calin Juravle7d765462017-09-04 15:57:10 -07001559 case 0: // dexoptanalyzer: no_dexopt_needed
Calin Juravle80a21252017-01-17 14:43:25 -08001560 *dexopt_needed_out = NO_DEXOPT_NEEDED; return true;
Calin Juravle7d765462017-09-04 15:57:10 -07001561 case 1: // dexoptanalyzer: dex2oat_from_scratch
Calin Juravle80a21252017-01-17 14:43:25 -08001562 *dexopt_needed_out = DEX2OAT_FROM_SCRATCH; return true;
Calin Juravle7d765462017-09-04 15:57:10 -07001563 case 5: // dexoptanalyzer: dex2oat_for_bootimage_odex
Calin Juravle80a21252017-01-17 14:43:25 -08001564 *dexopt_needed_out = -DEX2OAT_FOR_BOOT_IMAGE; return true;
Calin Juravle7d765462017-09-04 15:57:10 -07001565 case 6: // dexoptanalyzer: dex2oat_for_filter_odex
Calin Juravle80a21252017-01-17 14:43:25 -08001566 *dexopt_needed_out = -DEX2OAT_FOR_FILTER; return true;
Calin Juravle7d765462017-09-04 15:57:10 -07001567 case 7: // dexoptanalyzer: dex2oat_for_relocation_odex
Calin Juravle80a21252017-01-17 14:43:25 -08001568 *dexopt_needed_out = -DEX2OAT_FOR_RELOCATION; return true;
Calin Juravle7d765462017-09-04 15:57:10 -07001569 case 2: // dexoptanalyzer: dex2oat_for_bootimage_oat
1570 case 3: // dexoptanalyzer: dex2oat_for_filter_oat
1571 case 4: // dexoptanalyzer: dex2oat_for_relocation_oat
Calin Juravlec9eab382017-01-25 01:17:17 -08001572 LOG(ERROR) << "Dexoptnalyzer return the status of an oat file."
1573 << " Expected odex file status for secondary dex " << dex_path
Calin Juravle80a21252017-01-17 14:43:25 -08001574 << " : dexoptanalyzer result=" << result;
1575 return false;
Calin Juravle7d765462017-09-04 15:57:10 -07001576 case SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE:
1577 // If the file does not exist there's no need for dexopt.
1578 *dexopt_needed_out = NO_DEXOPT_NEEDED;
1579 return true;
1580 case SECONDARY_DEX_DEXOPTANALYZER_SKIPPED:
1581 return false;
Calin Juravle80a21252017-01-17 14:43:25 -08001582 default:
Calin Juravle7d765462017-09-04 15:57:10 -07001583 LOG(ERROR) << "Unexpected result from analyzing secondary dex " << dex_path
1584 << " result=" << result;
Calin Juravle80a21252017-01-17 14:43:25 -08001585 return false;
1586 }
1587}
1588
Calin Juravle7d765462017-09-04 15:57:10 -07001589enum SecondaryDexAccess {
1590 kSecondaryDexAccessReadOk = 0,
1591 kSecondaryDexAccessDoesNotExist = 1,
1592 kSecondaryDexAccessPermissionError = 2,
1593 kSecondaryDexAccessIOError = 3
1594};
1595
1596static SecondaryDexAccess check_secondary_dex_access(const std::string& dex_path) {
1597 // Check if the path exists and can be read. If not, there's nothing to do.
1598 if (access(dex_path.c_str(), R_OK) == 0) {
1599 return kSecondaryDexAccessReadOk;
1600 } else {
1601 if (errno == ENOENT) {
1602 LOG(INFO) << "Secondary dex does not exist: " << dex_path;
1603 return kSecondaryDexAccessDoesNotExist;
1604 } else {
1605 PLOG(ERROR) << "Could not access secondary dex " << dex_path;
1606 return errno == EACCES
1607 ? kSecondaryDexAccessPermissionError
1608 : kSecondaryDexAccessIOError;
1609 }
1610 }
1611}
1612
1613static bool is_file_public(const std::string& filename) {
1614 struct stat file_stat;
1615 if (stat(filename.c_str(), &file_stat) == 0) {
1616 return (file_stat.st_mode & S_IROTH) != 0;
1617 }
1618 return false;
1619}
1620
1621// Create the oat file structure for the secondary dex 'dex_path' and assign
1622// the individual path component to the 'out_' parameters.
1623static bool create_secondary_dex_oat_layout(const std::string& dex_path, const std::string& isa,
1624 char* out_oat_dir, char* out_oat_isa_dir, char* out_oat_path) {
1625 size_t dirIndex = dex_path.rfind('/');
1626 if (dirIndex == std::string::npos) {
1627 LOG(ERROR) << "Unexpected dir structure for dex file " << dex_path;
1628 return false;
1629 }
1630 // TODO(calin): we have similar computations in at lest 3 other places
1631 // (InstalldNativeService, otapropt and dexopt). Unify them and get rid of snprintf by
1632 // using string append.
1633 std::string apk_dir = dex_path.substr(0, dirIndex);
1634 snprintf(out_oat_dir, PKG_PATH_MAX, "%s/oat", apk_dir.c_str());
1635 snprintf(out_oat_isa_dir, PKG_PATH_MAX, "%s/%s", out_oat_dir, isa.c_str());
1636
1637 if (!create_oat_out_path(dex_path.c_str(), isa.c_str(), out_oat_dir,
1638 /*is_secondary_dex*/true, out_oat_path)) {
1639 LOG(ERROR) << "Could not create oat path for secondary dex " << dex_path;
1640 return false;
1641 }
1642 return true;
1643}
1644
1645// Validate that the dexopt_flags contain a valid storage flag and convert that to an installd
1646// recognized storage flags (FLAG_STORAGE_CE or FLAG_STORAGE_DE).
1647static bool validate_dexopt_storage_flags(int dexopt_flags, int* out_storage_flag) {
1648 if ((dexopt_flags & DEXOPT_STORAGE_CE) != 0) {
1649 *out_storage_flag = FLAG_STORAGE_CE;
1650 if ((dexopt_flags & DEXOPT_STORAGE_DE) != 0) {
1651 LOG(ERROR) << "Ambiguous secondary dex storage flag. Both, CE and DE, flags are set";
1652 return false;
1653 }
1654 } else if ((dexopt_flags & DEXOPT_STORAGE_DE) != 0) {
1655 *out_storage_flag = FLAG_STORAGE_DE;
1656 } else {
1657 LOG(ERROR) << "Secondary dex storage flag must be set";
1658 return false;
1659 }
1660 return true;
1661}
1662
Calin Juravlec9eab382017-01-25 01:17:17 -08001663// Processes the dex_path as a secondary dex files and return true if the path dex file should
Calin Juravle80a21252017-01-17 14:43:25 -08001664// be compiled. Returns false for errors (logged) or true if the secondary dex path was process
1665// successfully.
Calin Juravleebc8a792017-04-04 20:21:05 -07001666// When returning true, the output parameters will be:
1667// - is_public_out: whether or not the oat file should not be made public
1668// - dexopt_needed_out: valid OatFileAsssitant::DexOptNeeded
1669// - oat_dir_out: the oat dir path where the oat file should be stored
Calin Juravle7d765462017-09-04 15:57:10 -07001670static bool process_secondary_dex_dexopt(const std::string& dex_path, const char* pkgname,
Calin Juravle80a21252017-01-17 14:43:25 -08001671 int dexopt_flags, const char* volume_uuid, int uid, const char* instruction_set,
Calin Juravleebc8a792017-04-04 20:21:05 -07001672 const char* compiler_filter, bool* is_public_out, int* dexopt_needed_out,
Calin Juravle7d765462017-09-04 15:57:10 -07001673 std::string* oat_dir_out, bool downgrade, const char* class_loader_context) {
1674 LOG(DEBUG) << "Processing secondary dex path " << dex_path;
Calin Juravle80a21252017-01-17 14:43:25 -08001675 int storage_flag;
Calin Juravle7d765462017-09-04 15:57:10 -07001676 if (!validate_dexopt_storage_flags(dexopt_flags, &storage_flag)) {
Calin Juravle80a21252017-01-17 14:43:25 -08001677 return false;
1678 }
Calin Juravle7d765462017-09-04 15:57:10 -07001679 // Compute the oat dir as it's not easy to extract it from the child computation.
1680 char oat_path[PKG_PATH_MAX];
1681 char oat_dir[PKG_PATH_MAX];
1682 char oat_isa_dir[PKG_PATH_MAX];
1683 if (!create_secondary_dex_oat_layout(
1684 dex_path, instruction_set, oat_dir, oat_isa_dir, oat_path)) {
1685 LOG(ERROR) << "Could not create secondary odex layout: " << dex_path;
Calin Juravled23dee72017-07-06 16:29:11 -07001686 return false;
1687 }
Calin Juravle7d765462017-09-04 15:57:10 -07001688 oat_dir_out->assign(oat_dir);
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001689
Calin Juravle80a21252017-01-17 14:43:25 -08001690 pid_t pid = fork();
1691 if (pid == 0) {
1692 // child -- drop privileges before continuing.
1693 drop_capabilities(uid);
Calin Juravle7d765462017-09-04 15:57:10 -07001694
1695 // Validate the path structure.
1696 if (!validate_secondary_dex_path(pkgname, dex_path, volume_uuid, uid, storage_flag)) {
1697 LOG(ERROR) << "Could not validate secondary dex path " << dex_path;
1698 _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
1699 }
1700
1701 // Open the dex file.
1702 unique_fd zip_fd;
1703 zip_fd.reset(open(dex_path.c_str(), O_RDONLY));
1704 if (zip_fd.get() < 0) {
1705 if (errno == ENOENT) {
1706 _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE);
1707 } else {
1708 _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
1709 }
1710 }
1711
1712 // Prepare the oat directories.
1713 if (!prepare_secondary_dex_oat_dir(dex_path, uid, instruction_set)) {
1714 _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
1715 }
1716
1717 // Open the vdex/oat files if any.
1718 unique_fd oat_file_fd;
1719 unique_fd vdex_file_fd;
1720 if (!maybe_open_oat_and_vdex_file(dex_path,
1721 *oat_dir_out,
1722 instruction_set,
1723 true /* is_secondary_dex */,
1724 &oat_file_fd,
1725 &vdex_file_fd)) {
1726 _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
1727 }
1728
1729 // Analyze profiles.
1730 bool profile_was_updated = analyze_profiles(uid, dex_path, /*is_secondary_dex*/true);
1731
1732 // Run dexoptanalyzer to get dexopt_needed code. This is not expected to return.
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001733 exec_dexoptanalyzer(dex_path,
1734 vdex_file_fd.get(),
1735 oat_file_fd.get(),
1736 zip_fd.get(),
1737 instruction_set,
Calin Juravle7d765462017-09-04 15:57:10 -07001738 compiler_filter, profile_was_updated,
1739 downgrade,
1740 class_loader_context);
1741 PLOG(ERROR) << "Failed to exec dexoptanalyzer";
1742 _exit(SECONDARY_DEX_DEXOPTANALYZER_SKIPPED);
Calin Juravle80a21252017-01-17 14:43:25 -08001743 }
1744
1745 /* parent */
Calin Juravle80a21252017-01-17 14:43:25 -08001746 int result = wait_child(pid);
1747 if (!WIFEXITED(result)) {
Calin Juravlec9eab382017-01-25 01:17:17 -08001748 LOG(ERROR) << "dexoptanalyzer failed for path " << dex_path << ": " << result;
Calin Juravle80a21252017-01-17 14:43:25 -08001749 return false;
1750 }
1751 result = WEXITSTATUS(result);
Calin Juravle7d765462017-09-04 15:57:10 -07001752 // Check that we successfully executed dexoptanalyzer.
1753 bool success = process_secondary_dexoptanalyzer_result(dex_path, result, dexopt_needed_out);
1754
1755 LOG(DEBUG) << "Processed secondary dex file " << dex_path << " result=" << result;
1756
Calin Juravle80a21252017-01-17 14:43:25 -08001757 // Run dexopt only if needed or forced.
Calin Juravle7d765462017-09-04 15:57:10 -07001758 // Note that dexoptanalyzer is executed even if force compilation is enabled (because it
1759 // makes the code simpler; force compilation is only needed during tests).
1760 if (success &&
1761 (result != SECONDARY_DEX_DEXOPTANALYZER_SKIPPED_NO_FILE) &&
1762 ((dexopt_flags & DEXOPT_FORCE) != 0)) {
Calin Juravle80a21252017-01-17 14:43:25 -08001763 *dexopt_needed_out = DEX2OAT_FROM_SCRATCH;
1764 }
1765
Calin Juravle7d765462017-09-04 15:57:10 -07001766 // Check if we should make the oat file public.
1767 // Note that if the dex file is not public the compiled code cannot be made public.
1768 // It is ok to check this flag outside in the parent process.
1769 *is_public_out = ((dexopt_flags & DEXOPT_PUBLIC) != 0) && is_file_public(dex_path);
1770
Calin Juravle80a21252017-01-17 14:43:25 -08001771 return success;
1772}
1773
Calin Juravlec9eab382017-01-25 01:17:17 -08001774int dexopt(const char* dex_path, uid_t uid, const char* pkgname, const char* instruction_set,
Calin Juravle80a21252017-01-17 14:43:25 -08001775 int dexopt_needed, const char* oat_dir, int dexopt_flags, const char* compiler_filter,
Calin Juravle52c45822017-07-13 22:50:21 -07001776 const char* volume_uuid, const char* class_loader_context, const char* se_info,
David Brazdil570d3982018-01-16 20:15:43 +00001777 bool downgrade, int target_sdk_version) {
Calin Juravle7a570e82017-01-14 16:23:30 -08001778 CHECK(pkgname != nullptr);
1779 CHECK(pkgname[0] != 0);
1780 if ((dexopt_flags & ~DEXOPT_MASK) != 0) {
1781 LOG_FATAL("dexopt flags contains unknown fields\n");
1782 }
1783
Calin Juravled23dee72017-07-06 16:29:11 -07001784 if (!validate_dex_path_size(dex_path)) {
Calin Juravle52c45822017-07-13 22:50:21 -07001785 return -1;
1786 }
1787
1788 if (class_loader_context != nullptr && strlen(class_loader_context) > PKG_PATH_MAX) {
1789 LOG(ERROR) << "Class loader context exceeds the allowed size: " << class_loader_context;
1790 return -1;
Calin Juravled23dee72017-07-06 16:29:11 -07001791 }
1792
Calin Juravleebc8a792017-04-04 20:21:05 -07001793 bool is_public = (dexopt_flags & DEXOPT_PUBLIC) != 0;
Calin Juravle7a570e82017-01-14 16:23:30 -08001794 bool debuggable = (dexopt_flags & DEXOPT_DEBUGGABLE) != 0;
1795 bool boot_complete = (dexopt_flags & DEXOPT_BOOTCOMPLETE) != 0;
1796 bool profile_guided = (dexopt_flags & DEXOPT_PROFILE_GUIDED) != 0;
Calin Juravle80a21252017-01-17 14:43:25 -08001797 bool is_secondary_dex = (dexopt_flags & DEXOPT_SECONDARY_DEX) != 0;
Andreas Gampea73a0cb2017-11-02 18:14:42 -07001798 bool background_job_compile = (dexopt_flags & DEXOPT_IDLE_BACKGROUND_JOB) != 0;
Calin Juravle80a21252017-01-17 14:43:25 -08001799
1800 // Check if we're dealing with a secondary dex file and if we need to compile it.
1801 std::string oat_dir_str;
1802 if (is_secondary_dex) {
Calin Juravlec9eab382017-01-25 01:17:17 -08001803 if (process_secondary_dex_dexopt(dex_path, pkgname, dexopt_flags, volume_uuid, uid,
Calin Juravleebc8a792017-04-04 20:21:05 -07001804 instruction_set, compiler_filter, &is_public, &dexopt_needed, &oat_dir_str,
Calin Juravle7d765462017-09-04 15:57:10 -07001805 downgrade, class_loader_context)) {
Calin Juravle80a21252017-01-17 14:43:25 -08001806 oat_dir = oat_dir_str.c_str();
1807 if (dexopt_needed == NO_DEXOPT_NEEDED) {
1808 return 0; // Nothing to do, report success.
1809 }
1810 } else {
1811 return -1; // We had an error, logged in the process method.
1812 }
1813 } else {
Calin Juravlec9eab382017-01-25 01:17:17 -08001814 // Currently these flags are only use for secondary dex files.
1815 // Verify that they are not set for primary apks.
Calin Juravle80a21252017-01-17 14:43:25 -08001816 CHECK((dexopt_flags & DEXOPT_STORAGE_CE) == 0);
1817 CHECK((dexopt_flags & DEXOPT_STORAGE_DE) == 0);
1818 }
Calin Juravle7a570e82017-01-14 16:23:30 -08001819
1820 // Open the input file.
Calin Juravle1a0af3b2017-03-09 14:33:33 -08001821 unique_fd input_fd(open(dex_path, O_RDONLY, 0));
Calin Juravle7a570e82017-01-14 16:23:30 -08001822 if (input_fd.get() < 0) {
Calin Juravlec9eab382017-01-25 01:17:17 -08001823 ALOGE("installd cannot open '%s' for input during dexopt\n", dex_path);
Calin Juravle7a570e82017-01-14 16:23:30 -08001824 return -1;
1825 }
1826
1827 // Create the output OAT file.
1828 char out_oat_path[PKG_PATH_MAX];
Calin Juravlec9eab382017-01-25 01:17:17 -08001829 Dex2oatFileWrapper out_oat_fd = open_oat_out_file(dex_path, oat_dir, is_public, uid,
Calin Juravle80a21252017-01-17 14:43:25 -08001830 instruction_set, is_secondary_dex, out_oat_path);
Calin Juravle7a570e82017-01-14 16:23:30 -08001831 if (out_oat_fd.get() < 0) {
1832 return -1;
1833 }
1834
1835 // Open vdex files.
1836 Dex2oatFileWrapper in_vdex_fd;
1837 Dex2oatFileWrapper out_vdex_fd;
Shubham Ajmerab6bcd222017-10-19 10:08:03 -07001838 if (!open_vdex_files_for_dex2oat(dex_path, out_oat_path, dexopt_needed, instruction_set,
1839 is_public, uid, is_secondary_dex, profile_guided, &in_vdex_fd, &out_vdex_fd)) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07001840 return -1;
1841 }
1842
Calin Juravlecb556e32017-04-04 20:22:50 -07001843 // Ensure that the oat dir and the compiler artifacts of secondary dex files have the correct
1844 // selinux context (we generate them on the fly during the dexopt invocation and they don't
1845 // fully inherit their parent context).
1846 // Note that for primary apk the oat files are created before, in a separate installd
1847 // call which also does the restorecon. TODO(calin): unify the paths.
1848 if (is_secondary_dex) {
1849 if (selinux_android_restorecon_pkgdir(oat_dir, se_info, uid,
1850 SELINUX_ANDROID_RESTORECON_RECURSE)) {
1851 LOG(ERROR) << "Failed to restorecon " << oat_dir;
1852 return -1;
1853 }
1854 }
1855
Jeff Sharkey90aff262016-12-12 14:28:24 -07001856 // Create a swap file if necessary.
Calin Juravle1a0af3b2017-03-09 14:33:33 -08001857 unique_fd swap_fd = maybe_open_dexopt_swap_file(out_oat_path);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001858
Calin Juravle7a570e82017-01-14 16:23:30 -08001859 // Create the app image file if needed.
1860 Dex2oatFileWrapper image_fd =
Calin Juravle2289c0a2017-02-15 12:44:14 -08001861 maybe_open_app_image(out_oat_path, profile_guided, is_public, uid, is_secondary_dex);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001862
Calin Juravle7a570e82017-01-14 16:23:30 -08001863 // Open the reference profile if needed.
Calin Juravle114f0812017-03-08 19:05:07 -08001864 Dex2oatFileWrapper reference_profile_fd = maybe_open_reference_profile(
1865 pkgname, dex_path, profile_guided, is_public, uid, is_secondary_dex);
Calin Juravle7a570e82017-01-14 16:23:30 -08001866
Calin Juravlec9eab382017-01-25 01:17:17 -08001867 ALOGV("DexInv: --- BEGIN '%s' ---\n", dex_path);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001868
1869 pid_t pid = fork();
1870 if (pid == 0) {
1871 /* child -- drop privileges before continuing */
1872 drop_capabilities(uid);
1873
Richard Uhler76cc0272016-12-08 10:46:35 +00001874 SetDex2OatScheduling(boot_complete);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001875 if (flock(out_oat_fd.get(), LOCK_EX | LOCK_NB) != 0) {
1876 ALOGE("flock(%s) failed: %s\n", out_oat_path, strerror(errno));
1877 _exit(67);
1878 }
1879
Richard Uhler76cc0272016-12-08 10:46:35 +00001880 run_dex2oat(input_fd.get(),
1881 out_oat_fd.get(),
1882 in_vdex_fd.get(),
Calin Juravle7a570e82017-01-14 16:23:30 -08001883 out_vdex_fd.get(),
Richard Uhler76cc0272016-12-08 10:46:35 +00001884 image_fd.get(),
Jeff Hao10b8a6e2017-04-05 17:11:39 -07001885 dex_path,
Richard Uhler76cc0272016-12-08 10:46:35 +00001886 out_oat_path,
1887 swap_fd.get(),
1888 instruction_set,
1889 compiler_filter,
Richard Uhler76cc0272016-12-08 10:46:35 +00001890 debuggable,
1891 boot_complete,
Andreas Gampea73a0cb2017-11-02 18:14:42 -07001892 background_job_compile,
Richard Uhler76cc0272016-12-08 10:46:35 +00001893 reference_profile_fd.get(),
David Brazdil570d3982018-01-16 20:15:43 +00001894 class_loader_context,
1895 target_sdk_version);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001896 _exit(68); /* only get here on exec failure */
1897 } else {
1898 int res = wait_child(pid);
1899 if (res == 0) {
Calin Juravlec9eab382017-01-25 01:17:17 -08001900 ALOGV("DexInv: --- END '%s' (success) ---\n", dex_path);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001901 } else {
Calin Juravlec9eab382017-01-25 01:17:17 -08001902 ALOGE("DexInv: --- END '%s' --- status=0x%04x, process failed\n", dex_path, res);
Andreas Gampe013f02e2017-03-20 18:36:54 -07001903 return res;
Jeff Sharkey90aff262016-12-12 14:28:24 -07001904 }
1905 }
1906
Calin Juravlec9eab382017-01-25 01:17:17 -08001907 update_out_oat_access_times(dex_path, out_oat_path);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001908
1909 // We've been successful, don't delete output.
1910 out_oat_fd.SetCleanup(false);
Calin Juravle7a570e82017-01-14 16:23:30 -08001911 out_vdex_fd.SetCleanup(false);
Jeff Sharkey90aff262016-12-12 14:28:24 -07001912 image_fd.SetCleanup(false);
1913 reference_profile_fd.SetCleanup(false);
1914
1915 return 0;
1916}
1917
Calin Juravlec9eab382017-01-25 01:17:17 -08001918// Try to remove the given directory. Log an error if the directory exists
1919// and is empty but could not be removed.
1920static bool rmdir_if_empty(const char* dir) {
1921 if (rmdir(dir) == 0) {
1922 return true;
1923 }
1924 if (errno == ENOENT || errno == ENOTEMPTY) {
1925 return true;
1926 }
1927 PLOG(ERROR) << "Failed to remove dir: " << dir;
1928 return false;
1929}
1930
1931// Try to unlink the given file. Log an error if the file exists and could not
1932// be unlinked.
1933static bool unlink_if_exists(const std::string& file) {
1934 if (unlink(file.c_str()) == 0) {
1935 return true;
1936 }
1937 if (errno == ENOENT) {
1938 return true;
1939
1940 }
1941 PLOG(ERROR) << "Could not unlink: " << file;
1942 return false;
1943}
1944
Calin Juravle7d765462017-09-04 15:57:10 -07001945enum ReconcileSecondaryDexResult {
1946 kReconcileSecondaryDexExists = 0,
1947 kReconcileSecondaryDexCleanedUp = 1,
1948 kReconcileSecondaryDexValidationError = 2,
1949 kReconcileSecondaryDexCleanUpError = 3,
1950 kReconcileSecondaryDexAccessIOError = 4,
1951};
Calin Juravlec9eab382017-01-25 01:17:17 -08001952
1953// Reconcile the secondary dex 'dex_path' and its generated oat files.
1954// Return true if all the parameters are valid and the secondary dex file was
1955// processed successfully (i.e. the dex_path either exists, or if not, its corresponding
1956// oat/vdex/art files where deleted successfully). In this case, out_secondary_dex_exists
1957// will be true if the secondary dex file still exists. If the secondary dex file does not exist,
1958// the method cleans up any previously generated compiler artifacts (oat, vdex, art).
1959// Return false if there were errors during processing. In this case
1960// out_secondary_dex_exists will be set to false.
1961bool reconcile_secondary_dex_file(const std::string& dex_path,
1962 const std::string& pkgname, int uid, const std::vector<std::string>& isas,
1963 const std::unique_ptr<std::string>& volume_uuid, int storage_flag,
1964 /*out*/bool* out_secondary_dex_exists) {
Calin Juravle7d765462017-09-04 15:57:10 -07001965 *out_secondary_dex_exists = false; // start by assuming the file does not exist.
Calin Juravlec9eab382017-01-25 01:17:17 -08001966 if (isas.size() == 0) {
1967 LOG(ERROR) << "reconcile_secondary_dex_file called with empty isas vector";
1968 return false;
1969 }
1970
Calin Juravle7d765462017-09-04 15:57:10 -07001971 if (storage_flag != FLAG_STORAGE_CE && storage_flag != FLAG_STORAGE_DE) {
1972 LOG(ERROR) << "reconcile_secondary_dex_file called with invalid storage_flag: "
1973 << storage_flag;
Calin Juravlec9eab382017-01-25 01:17:17 -08001974 return false;
1975 }
1976
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07001977 // As a security measure we want to unlink art artifacts with the reduced capabilities
1978 // of the package user id. So we fork and drop capabilities in the child.
1979 pid_t pid = fork();
1980 if (pid == 0) {
Calin Juravle7d765462017-09-04 15:57:10 -07001981 /* child -- drop privileges before continuing */
1982 drop_capabilities(uid);
1983
1984 const char* volume_uuid_cstr = volume_uuid == nullptr ? nullptr : volume_uuid->c_str();
1985 if (!validate_secondary_dex_path(pkgname.c_str(), dex_path.c_str(), volume_uuid_cstr,
1986 uid, storage_flag)) {
1987 LOG(ERROR) << "Could not validate secondary dex path " << dex_path;
1988 _exit(kReconcileSecondaryDexValidationError);
1989 }
1990
1991 SecondaryDexAccess access_check = check_secondary_dex_access(dex_path);
1992 switch (access_check) {
1993 case kSecondaryDexAccessDoesNotExist:
1994 // File does not exist. Proceed with cleaning.
1995 break;
1996 case kSecondaryDexAccessReadOk: _exit(kReconcileSecondaryDexExists);
1997 case kSecondaryDexAccessIOError: _exit(kReconcileSecondaryDexAccessIOError);
1998 case kSecondaryDexAccessPermissionError: _exit(kReconcileSecondaryDexValidationError);
1999 default:
2000 LOG(ERROR) << "Unexpected result from check_secondary_dex_access: " << access_check;
2001 _exit(kReconcileSecondaryDexValidationError);
2002 }
2003
2004 // The secondary dex does not exist anymore or it's. Clear any generated files.
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002005 char oat_path[PKG_PATH_MAX];
2006 char oat_dir[PKG_PATH_MAX];
2007 char oat_isa_dir[PKG_PATH_MAX];
2008 bool result = true;
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002009 for (size_t i = 0; i < isas.size(); i++) {
Calin Juravle7d765462017-09-04 15:57:10 -07002010 if (!create_secondary_dex_oat_layout(
2011 dex_path,isas[i], oat_dir, oat_isa_dir, oat_path)) {
2012 LOG(ERROR) << "Could not create secondary odex layout: " << dex_path;
2013 _exit(kReconcileSecondaryDexValidationError);
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002014 }
Calin Juravle51314092017-05-18 15:33:05 -07002015
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002016 // Delete oat/vdex/art files.
2017 result = unlink_if_exists(oat_path) && result;
2018 result = unlink_if_exists(create_vdex_filename(oat_path)) && result;
2019 result = unlink_if_exists(create_image_filename(oat_path)) && result;
Calin Juravlec9eab382017-01-25 01:17:17 -08002020
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002021 // Delete profiles.
2022 std::string current_profile = create_current_profile_path(
Calin Juravle51314092017-05-18 15:33:05 -07002023 multiuser_get_user_id(uid), dex_path, /*is_secondary*/true);
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002024 std::string reference_profile = create_reference_profile_path(
Calin Juravle51314092017-05-18 15:33:05 -07002025 dex_path, /*is_secondary*/true);
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002026 result = unlink_if_exists(current_profile) && result;
2027 result = unlink_if_exists(reference_profile) && result;
Calin Juravle51314092017-05-18 15:33:05 -07002028
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002029 // We upgraded once the location of current profile for secondary dex files.
2030 // Check for any previous left-overs and remove them as well.
2031 std::string old_current_profile = dex_path + ".prof";
2032 result = unlink_if_exists(old_current_profile);
Calin Juravle3760ad32017-07-27 16:31:55 -07002033
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002034 // Try removing the directories as well, they might be empty.
2035 result = rmdir_if_empty(oat_isa_dir) && result;
2036 result = rmdir_if_empty(oat_dir) && result;
2037 }
Calin Juravle7d765462017-09-04 15:57:10 -07002038 if (!result) {
2039 PLOG(ERROR) << "Failed to clean secondary dex artifacts for location " << dex_path;
2040 }
2041 _exit(result ? kReconcileSecondaryDexCleanedUp : kReconcileSecondaryDexAccessIOError);
Calin Juravlec9eab382017-01-25 01:17:17 -08002042 }
2043
Shubham Ajmerae6d7ad52017-08-25 13:07:44 -07002044 int return_code = wait_child(pid);
Calin Juravle7d765462017-09-04 15:57:10 -07002045 if (!WIFEXITED(return_code)) {
2046 LOG(WARNING) << "reconcile dex failed for location " << dex_path << ": " << return_code;
2047 } else {
2048 return_code = WEXITSTATUS(return_code);
2049 }
2050
2051 LOG(DEBUG) << "Reconcile secondary dex path " << dex_path << " result=" << return_code;
2052
2053 switch (return_code) {
2054 case kReconcileSecondaryDexCleanedUp:
2055 case kReconcileSecondaryDexValidationError:
2056 // If we couldn't validate assume the dex file does not exist.
2057 // This will purge the entry from the PM records.
2058 *out_secondary_dex_exists = false;
2059 return true;
2060 case kReconcileSecondaryDexExists:
2061 *out_secondary_dex_exists = true;
2062 return true;
2063 case kReconcileSecondaryDexAccessIOError:
2064 // We had an access IO error.
2065 // Return false so that we can try again.
2066 // The value of out_secondary_dex_exists does not matter in this case and by convention
2067 // is set to false.
2068 *out_secondary_dex_exists = false;
2069 return false;
2070 default:
2071 LOG(ERROR) << "Unexpected code from reconcile_secondary_dex_file: " << return_code;
2072 *out_secondary_dex_exists = false;
2073 return false;
2074 }
Calin Juravlec9eab382017-01-25 01:17:17 -08002075}
2076
Jeff Sharkey90aff262016-12-12 14:28:24 -07002077// Helper for move_ab, so that we can have common failure-case cleanup.
2078static bool unlink_and_rename(const char* from, const char* to) {
2079 // Check whether "from" exists, and if so whether it's regular. If it is, unlink. Otherwise,
2080 // return a failure.
2081 struct stat s;
2082 if (stat(to, &s) == 0) {
2083 if (!S_ISREG(s.st_mode)) {
2084 LOG(ERROR) << from << " is not a regular file to replace for A/B.";
2085 return false;
2086 }
2087 if (unlink(to) != 0) {
2088 LOG(ERROR) << "Could not unlink " << to << " to move A/B.";
2089 return false;
2090 }
2091 } else {
2092 // This may be a permission problem. We could investigate the error code, but we'll just
2093 // let the rename failure do the work for us.
2094 }
2095
2096 // Try to rename "to" to "from."
2097 if (rename(from, to) != 0) {
2098 PLOG(ERROR) << "Could not rename " << from << " to " << to;
2099 return false;
2100 }
2101 return true;
2102}
2103
2104// Move/rename a B artifact (from) to an A artifact (to).
2105static bool move_ab_path(const std::string& b_path, const std::string& a_path) {
2106 // Check whether B exists.
2107 {
2108 struct stat s;
2109 if (stat(b_path.c_str(), &s) != 0) {
2110 // Silently ignore for now. The service calling this isn't smart enough to understand
2111 // lack of artifacts at the moment.
2112 return false;
2113 }
2114 if (!S_ISREG(s.st_mode)) {
2115 LOG(ERROR) << "A/B artifact " << b_path << " is not a regular file.";
2116 // Try to unlink, but swallow errors.
2117 unlink(b_path.c_str());
2118 return false;
2119 }
2120 }
2121
2122 // Rename B to A.
2123 if (!unlink_and_rename(b_path.c_str(), a_path.c_str())) {
2124 // Delete the b_path so we don't try again (or fail earlier).
2125 if (unlink(b_path.c_str()) != 0) {
2126 PLOG(ERROR) << "Could not unlink " << b_path;
2127 }
2128
2129 return false;
2130 }
2131
2132 return true;
2133}
2134
2135bool move_ab(const char* apk_path, const char* instruction_set, const char* oat_dir) {
2136 // Get the current slot suffix. No suffix, no A/B.
2137 std::string slot_suffix;
2138 {
2139 char buf[kPropertyValueMax];
2140 if (get_property("ro.boot.slot_suffix", buf, nullptr) <= 0) {
2141 return false;
2142 }
2143 slot_suffix = buf;
2144
2145 if (!ValidateTargetSlotSuffix(slot_suffix)) {
2146 LOG(ERROR) << "Target slot suffix not legal: " << slot_suffix;
2147 return false;
2148 }
2149 }
2150
2151 // Validate other inputs.
2152 if (validate_apk_path(apk_path) != 0) {
2153 LOG(ERROR) << "Invalid apk_path: " << apk_path;
2154 return false;
2155 }
2156 if (validate_apk_path(oat_dir) != 0) {
2157 LOG(ERROR) << "Invalid oat_dir: " << oat_dir;
2158 return false;
2159 }
2160
2161 char a_path[PKG_PATH_MAX];
2162 if (!calculate_oat_file_path(a_path, oat_dir, apk_path, instruction_set)) {
2163 return false;
2164 }
2165 const std::string a_vdex_path = create_vdex_filename(a_path);
2166 const std::string a_image_path = create_image_filename(a_path);
2167
2168 // B path = A path + slot suffix.
2169 const std::string b_path = StringPrintf("%s.%s", a_path, slot_suffix.c_str());
2170 const std::string b_vdex_path = StringPrintf("%s.%s", a_vdex_path.c_str(), slot_suffix.c_str());
2171 const std::string b_image_path = StringPrintf("%s.%s",
2172 a_image_path.c_str(),
2173 slot_suffix.c_str());
2174
2175 bool success = true;
2176 if (move_ab_path(b_path, a_path)) {
2177 if (move_ab_path(b_vdex_path, a_vdex_path)) {
2178 // Note: we can live without an app image. As such, ignore failure to move the image file.
2179 // If we decide to require the app image, or the app image being moved correctly,
2180 // then change accordingly.
2181 constexpr bool kIgnoreAppImageFailure = true;
2182
2183 if (!a_image_path.empty()) {
2184 if (!move_ab_path(b_image_path, a_image_path)) {
2185 unlink(a_image_path.c_str());
2186 if (!kIgnoreAppImageFailure) {
2187 success = false;
2188 }
2189 }
2190 }
2191 } else {
2192 // Cleanup: delete B image, ignore errors.
2193 unlink(b_image_path.c_str());
2194 success = false;
2195 }
2196 } else {
2197 // Cleanup: delete B image, ignore errors.
2198 unlink(b_vdex_path.c_str());
2199 unlink(b_image_path.c_str());
2200 success = false;
2201 }
2202 return success;
2203}
2204
2205bool delete_odex(const char* apk_path, const char* instruction_set, const char* oat_dir) {
2206 // Delete the oat/odex file.
2207 char out_path[PKG_PATH_MAX];
Calin Juravle80a21252017-01-17 14:43:25 -08002208 if (!create_oat_out_path(apk_path, instruction_set, oat_dir,
Calin Juravle114f0812017-03-08 19:05:07 -08002209 /*is_secondary_dex*/false, out_path)) {
Jeff Sharkey90aff262016-12-12 14:28:24 -07002210 return false;
2211 }
2212
2213 // In case of a permission failure report the issue. Otherwise just print a warning.
2214 auto unlink_and_check = [](const char* path) -> bool {
2215 int result = unlink(path);
2216 if (result != 0) {
2217 if (errno == EACCES || errno == EPERM) {
2218 PLOG(ERROR) << "Could not unlink " << path;
2219 return false;
2220 }
2221 PLOG(WARNING) << "Could not unlink " << path;
2222 }
2223 return true;
2224 };
2225
2226 // Delete the oat/odex file.
2227 bool return_value_oat = unlink_and_check(out_path);
2228
2229 // Derive and delete the app image.
2230 bool return_value_art = unlink_and_check(create_image_filename(out_path).c_str());
2231
Nicolas Geoffray192fb962017-05-25 13:58:06 +01002232 // Derive and delete the vdex file.
2233 bool return_value_vdex = unlink_and_check(create_vdex_filename(out_path).c_str());
2234
Jeff Sharkey90aff262016-12-12 14:28:24 -07002235 // Report success.
Nicolas Geoffray192fb962017-05-25 13:58:06 +01002236 return return_value_oat && return_value_art && return_value_vdex;
Jeff Sharkey90aff262016-12-12 14:28:24 -07002237}
2238
Jeff Sharkeyc1149c92017-09-21 14:51:09 -06002239static bool is_absolute_path(const std::string& path) {
2240 if (path.find('/') != 0 || path.find("..") != std::string::npos) {
2241 LOG(ERROR) << "Invalid absolute path " << path;
2242 return false;
2243 } else {
2244 return true;
2245 }
2246}
2247
2248static bool is_valid_instruction_set(const std::string& instruction_set) {
2249 // TODO: add explicit whitelisting of instruction sets
2250 if (instruction_set.find('/') != std::string::npos) {
2251 LOG(ERROR) << "Invalid instruction set " << instruction_set;
2252 return false;
2253 } else {
2254 return true;
2255 }
2256}
2257
2258bool calculate_oat_file_path_default(char path[PKG_PATH_MAX], const char *oat_dir,
2259 const char *apk_path, const char *instruction_set) {
2260 std::string oat_dir_ = oat_dir;
2261 std::string apk_path_ = apk_path;
2262 std::string instruction_set_ = instruction_set;
2263
2264 if (!is_absolute_path(oat_dir_)) return false;
2265 if (!is_absolute_path(apk_path_)) return false;
2266 if (!is_valid_instruction_set(instruction_set_)) return false;
2267
2268 std::string::size_type end = apk_path_.rfind('.');
2269 std::string::size_type start = apk_path_.rfind('/', end);
2270 if (end == std::string::npos || start == std::string::npos) {
2271 LOG(ERROR) << "Invalid apk_path " << apk_path_;
2272 return false;
2273 }
2274
2275 std::string res_ = oat_dir_ + '/' + instruction_set + '/'
2276 + apk_path_.substr(start + 1, end - start - 1) + ".odex";
2277 const char* res = res_.c_str();
2278 if (strlen(res) >= PKG_PATH_MAX) {
2279 LOG(ERROR) << "Result too large";
2280 return false;
2281 } else {
2282 strlcpy(path, res, PKG_PATH_MAX);
2283 return true;
2284 }
2285}
2286
2287bool calculate_odex_file_path_default(char path[PKG_PATH_MAX], const char *apk_path,
2288 const char *instruction_set) {
2289 std::string apk_path_ = apk_path;
2290 std::string instruction_set_ = instruction_set;
2291
2292 if (!is_absolute_path(apk_path_)) return false;
2293 if (!is_valid_instruction_set(instruction_set_)) return false;
2294
2295 std::string::size_type end = apk_path_.rfind('.');
2296 std::string::size_type start = apk_path_.rfind('/', end);
2297 if (end == std::string::npos || start == std::string::npos) {
2298 LOG(ERROR) << "Invalid apk_path " << apk_path_;
2299 return false;
2300 }
2301
2302 std::string oat_dir = apk_path_.substr(0, start + 1) + "oat";
2303 return calculate_oat_file_path_default(path, oat_dir.c_str(), apk_path, instruction_set);
2304}
2305
2306bool create_cache_path_default(char path[PKG_PATH_MAX], const char *src,
2307 const char *instruction_set) {
2308 std::string src_ = src;
2309 std::string instruction_set_ = instruction_set;
2310
2311 if (!is_absolute_path(src_)) return false;
2312 if (!is_valid_instruction_set(instruction_set_)) return false;
2313
2314 for (auto it = src_.begin() + 1; it < src_.end(); ++it) {
2315 if (*it == '/') {
2316 *it = '@';
2317 }
2318 }
2319
2320 std::string res_ = android_data_dir + DALVIK_CACHE + '/' + instruction_set_ + src_
2321 + DALVIK_CACHE_POSTFIX;
2322 const char* res = res_.c_str();
2323 if (strlen(res) >= PKG_PATH_MAX) {
2324 LOG(ERROR) << "Result too large";
2325 return false;
2326 } else {
2327 strlcpy(path, res, PKG_PATH_MAX);
2328 return true;
2329 }
2330}
2331
Calin Juravlec3596c32017-12-05 12:29:15 -08002332bool create_profile_snapshot(int32_t app_id, const std::string& package_name,
Calin Juravle29591732017-11-20 17:46:19 -08002333 const std::string& code_path) {
2334 int app_shared_gid = multiuser_get_shared_gid(/*user_id*/ 0, app_id);
2335
2336 unique_fd snapshot_fd = open_spnashot_profile(AID_SYSTEM, package_name, code_path);
2337 if (snapshot_fd < 0) {
2338 return false;
2339 }
2340
2341 std::vector<unique_fd> profiles_fd;
2342 unique_fd reference_profile_fd;
2343 open_profile_files(app_shared_gid, package_name, /*is_secondary_dex*/ false, &profiles_fd,
2344 &reference_profile_fd);
2345 if (profiles_fd.empty() || (reference_profile_fd.get() < 0)) {
2346 return false;
2347 }
2348
2349 profiles_fd.push_back(std::move(reference_profile_fd));
2350
2351 pid_t pid = fork();
2352 if (pid == 0) {
2353 /* child -- drop privileges before continuing */
2354 drop_capabilities(app_shared_gid);
2355 run_profman_merge(profiles_fd, snapshot_fd);
2356 exit(42); /* only get here on exec failure */
2357 }
2358
2359 /* parent */
2360 int return_code = wait_child(pid);
2361 if (!WIFEXITED(return_code)) {
2362 LOG(WARNING) << "profman failed for " << package_name << ":" << code_path;
2363 return false;
2364 }
2365
2366 return true;
2367}
2368
Jeff Sharkey6c2c0562016-12-07 12:12:00 -07002369} // namespace installd
2370} // namespace android