1 /*
2 ** Copyright 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 */
16
17 #include <algorithm>
18 #include <inttypes.h>
19 #include <random>
20 #include <regex>
21 #include <selinux/android.h>
22 #include <selinux/avc.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/capability.h>
26 #include <sys/prctl.h>
27 #include <sys/stat.h>
28 #include <sys/wait.h>
29
30 #include <android-base/logging.h>
31 #include <android-base/macros.h>
32 #include <android-base/stringprintf.h>
33 #include <android-base/strings.h>
34 #include <cutils/fs.h>
35 #include <cutils/log.h>
36 #include <cutils/properties.h>
37 #include <private/android_filesystem_config.h>
38
39 #include <commands.h>
40 #include <file_parsing.h>
41 #include <globals.h>
42 #include <installd_deps.h> // Need to fill in requirements of commands.
43 #include <otapreopt_utils.h>
44 #include <system_properties.h>
45 #include <utils.h>
46
47 #ifndef LOG_TAG
48 #define LOG_TAG "otapreopt"
49 #endif
50
51 #define BUFFER_MAX 1024 /* input buffer for commands */
52 #define TOKEN_MAX 16 /* max number of arguments in buffer */
53 #define REPLY_MAX 256 /* largest reply allowed */
54
55 using android::base::EndsWith;
56 using android::base::Join;
57 using android::base::Split;
58 using android::base::StartsWith;
59 using android::base::StringPrintf;
60
61 namespace android {
62 namespace installd {
63
64 template<typename T>
RoundDown(T x,typename std::decay<T>::type n)65 static constexpr T RoundDown(T x, typename std::decay<T>::type n) {
66 return DCHECK_CONSTEXPR(IsPowerOfTwo(n), , T(0))(x & -n);
67 }
68
69 template<typename T>
RoundUp(T x,typename std::remove_reference<T>::type n)70 static constexpr T RoundUp(T x, typename std::remove_reference<T>::type n) {
71 return RoundDown(x + n - 1, n);
72 }
73
74 class OTAPreoptService {
75 public:
76 // Main driver. Performs the following steps.
77 //
78 // 1) Parse options (read system properties etc from B partition).
79 //
80 // 2) Read in package data.
81 //
82 // 3) Prepare environment variables.
83 //
84 // 4) Prepare(compile) boot image, if necessary.
85 //
86 // 5) Run update.
Main(int argc,char ** argv)87 int Main(int argc, char** argv) {
88 if (!ReadArguments(argc, argv)) {
89 LOG(ERROR) << "Failed reading command line.";
90 return 1;
91 }
92
93 if (!ReadSystemProperties()) {
94 LOG(ERROR)<< "Failed reading system properties.";
95 return 2;
96 }
97
98 if (!ReadEnvironment()) {
99 LOG(ERROR) << "Failed reading environment properties.";
100 return 3;
101 }
102
103 if (!CheckAndInitializeInstalldGlobals()) {
104 LOG(ERROR) << "Failed initializing globals.";
105 return 4;
106 }
107
108 PrepareEnvironment();
109
110 if (!PrepareBootImage(/* force */ false)) {
111 LOG(ERROR) << "Failed preparing boot image.";
112 return 5;
113 }
114
115 int dexopt_retcode = RunPreopt();
116
117 return dexopt_retcode;
118 }
119
GetProperty(const char * key,char * value,const char * default_value) const120 int GetProperty(const char* key, char* value, const char* default_value) const {
121 const std::string* prop_value = system_properties_.GetProperty(key);
122 if (prop_value == nullptr) {
123 if (default_value == nullptr) {
124 return 0;
125 }
126 // Copy in the default value.
127 strncpy(value, default_value, kPropertyValueMax - 1);
128 value[kPropertyValueMax - 1] = 0;
129 return strlen(default_value);// TODO: Need to truncate?
130 }
131 size_t size = std::min(kPropertyValueMax - 1, prop_value->length());
132 strncpy(value, prop_value->data(), size);
133 value[size] = 0;
134 return static_cast<int>(size);
135 }
136
GetOTADataDirectory() const137 std::string GetOTADataDirectory() const {
138 return StringPrintf("%s/%s", GetOtaDirectoryPrefix().c_str(), target_slot_.c_str());
139 }
140
GetTargetSlot() const141 const std::string& GetTargetSlot() const {
142 return target_slot_;
143 }
144
145 private:
146
ReadSystemProperties()147 bool ReadSystemProperties() {
148 static constexpr const char* kPropertyFiles[] = {
149 "/default.prop", "/system/build.prop"
150 };
151
152 for (size_t i = 0; i < arraysize(kPropertyFiles); ++i) {
153 if (!system_properties_.Load(kPropertyFiles[i])) {
154 return false;
155 }
156 }
157
158 return true;
159 }
160
ReadEnvironment()161 bool ReadEnvironment() {
162 // Parse the environment variables from init.environ.rc, which have the form
163 // export NAME VALUE
164 // For simplicity, don't respect string quotation. The values we are interested in can be
165 // encoded without them.
166 std::regex export_regex("\\s*export\\s+(\\S+)\\s+(\\S+)");
167 bool parse_result = ParseFile("/init.environ.rc", [&](const std::string& line) {
168 std::smatch export_match;
169 if (!std::regex_match(line, export_match, export_regex)) {
170 return true;
171 }
172
173 if (export_match.size() != 3) {
174 return true;
175 }
176
177 std::string name = export_match[1].str();
178 std::string value = export_match[2].str();
179
180 system_properties_.SetProperty(name, value);
181
182 return true;
183 });
184 if (!parse_result) {
185 return false;
186 }
187
188 if (system_properties_.GetProperty(kAndroidDataPathPropertyName) == nullptr) {
189 return false;
190 }
191 android_data_ = *system_properties_.GetProperty(kAndroidDataPathPropertyName);
192
193 if (system_properties_.GetProperty(kAndroidRootPathPropertyName) == nullptr) {
194 return false;
195 }
196 android_root_ = *system_properties_.GetProperty(kAndroidRootPathPropertyName);
197
198 if (system_properties_.GetProperty(kBootClassPathPropertyName) == nullptr) {
199 return false;
200 }
201 boot_classpath_ = *system_properties_.GetProperty(kBootClassPathPropertyName);
202
203 if (system_properties_.GetProperty(ASEC_MOUNTPOINT_ENV_NAME) == nullptr) {
204 return false;
205 }
206 asec_mountpoint_ = *system_properties_.GetProperty(ASEC_MOUNTPOINT_ENV_NAME);
207
208 return true;
209 }
210
GetAndroidData() const211 const std::string& GetAndroidData() const {
212 return android_data_;
213 }
214
GetAndroidRoot() const215 const std::string& GetAndroidRoot() const {
216 return android_root_;
217 }
218
GetOtaDirectoryPrefix() const219 const std::string GetOtaDirectoryPrefix() const {
220 return GetAndroidData() + "/ota";
221 }
222
CheckAndInitializeInstalldGlobals()223 bool CheckAndInitializeInstalldGlobals() {
224 // init_globals_from_data_and_root requires "ASEC_MOUNTPOINT" in the environment. We
225 // do not use any datapath that includes this, but we'll still have to set it.
226 CHECK(system_properties_.GetProperty(ASEC_MOUNTPOINT_ENV_NAME) != nullptr);
227 int result = setenv(ASEC_MOUNTPOINT_ENV_NAME, asec_mountpoint_.c_str(), 0);
228 if (result != 0) {
229 LOG(ERROR) << "Could not set ASEC_MOUNTPOINT environment variable";
230 return false;
231 }
232
233 if (!init_globals_from_data_and_root(GetAndroidData().c_str(), GetAndroidRoot().c_str())) {
234 LOG(ERROR) << "Could not initialize globals; exiting.";
235 return false;
236 }
237
238 // This is different from the normal installd. We only do the base
239 // directory, the rest will be created on demand when each app is compiled.
240 if (access(GetOtaDirectoryPrefix().c_str(), R_OK) < 0) {
241 LOG(ERROR) << "Could not access " << GetOtaDirectoryPrefix();
242 return false;
243 }
244
245 return true;
246 }
247
ReadArguments(int argc ATTRIBUTE_UNUSED,char ** argv)248 bool ReadArguments(int argc ATTRIBUTE_UNUSED, char** argv) {
249 // Expected command line:
250 // target-slot dexopt {DEXOPT_PARAMETERS}
251 // The DEXOPT_PARAMETERS are passed on to dexopt(), so we expect DEXOPT_PARAM_COUNT
252 // of them. We store them in package_parameters_ (size checks are done when
253 // parsing the special parameters and when copying into package_parameters_.
254
255 static_assert(DEXOPT_PARAM_COUNT == ARRAY_SIZE(package_parameters_),
256 "Unexpected dexopt param count");
257
258 const char* target_slot_arg = argv[1];
259 if (target_slot_arg == nullptr) {
260 LOG(ERROR) << "Missing parameters";
261 return false;
262 }
263 // Sanitize value. Only allow (a-zA-Z0-9_)+.
264 target_slot_ = target_slot_arg;
265 if (!ValidateTargetSlotSuffix(target_slot_)) {
266 LOG(ERROR) << "Target slot suffix not legal: " << target_slot_;
267 return false;
268 }
269
270 // Check for "dexopt" next.
271 if (argv[2] == nullptr) {
272 LOG(ERROR) << "Missing parameters";
273 return false;
274 }
275 if (std::string("dexopt").compare(argv[2]) != 0) {
276 LOG(ERROR) << "Second parameter not dexopt: " << argv[2];
277 return false;
278 }
279
280 // Copy the rest into package_parameters_, but be careful about over- and underflow.
281 size_t index = 0;
282 while (index < DEXOPT_PARAM_COUNT &&
283 argv[index + 3] != nullptr) {
284 package_parameters_[index] = argv[index + 3];
285 index++;
286 }
287 if (index != ARRAY_SIZE(package_parameters_) || argv[index + 3] != nullptr) {
288 LOG(ERROR) << "Wrong number of parameters";
289 return false;
290 }
291
292 return true;
293 }
294
PrepareEnvironment()295 void PrepareEnvironment() {
296 environ_.push_back(StringPrintf("BOOTCLASSPATH=%s", boot_classpath_.c_str()));
297 environ_.push_back(StringPrintf("ANDROID_DATA=%s", GetOTADataDirectory().c_str()));
298 environ_.push_back(StringPrintf("ANDROID_ROOT=%s", android_root_.c_str()));
299
300 for (const std::string& e : environ_) {
301 putenv(const_cast<char*>(e.c_str()));
302 }
303 }
304
305 // Ensure that we have the right boot image. The first time any app is
306 // compiled, we'll try to generate it.
PrepareBootImage(bool force) const307 bool PrepareBootImage(bool force) const {
308 if (package_parameters_[kISAIndex] == nullptr) {
309 LOG(ERROR) << "Instruction set missing.";
310 return false;
311 }
312 const char* isa = package_parameters_[kISAIndex];
313
314 // Check whether the file exists where expected.
315 std::string dalvik_cache = GetOTADataDirectory() + "/" + DALVIK_CACHE;
316 std::string isa_path = dalvik_cache + "/" + isa;
317 std::string art_path = isa_path + "/system@framework@boot.art";
318 std::string oat_path = isa_path + "/system@framework@boot.oat";
319 bool cleared = false;
320 if (access(art_path.c_str(), F_OK) == 0 && access(oat_path.c_str(), F_OK) == 0) {
321 // Files exist, assume everything is alright if not forced. Otherwise clean up.
322 if (!force) {
323 return true;
324 }
325 ClearDirectory(isa_path);
326 cleared = true;
327 }
328
329 // Reset umask in otapreopt, so that we control the the access for the files we create.
330 umask(0);
331
332 // Create the directories, if necessary.
333 if (access(dalvik_cache.c_str(), F_OK) != 0) {
334 if (!CreatePath(dalvik_cache)) {
335 PLOG(ERROR) << "Could not create dalvik-cache dir " << dalvik_cache;
336 return false;
337 }
338 }
339 if (access(isa_path.c_str(), F_OK) != 0) {
340 if (!CreatePath(isa_path)) {
341 PLOG(ERROR) << "Could not create dalvik-cache isa dir";
342 return false;
343 }
344 }
345
346 // Prepare to create.
347 if (!cleared) {
348 ClearDirectory(isa_path);
349 }
350
351 std::string preopted_boot_art_path = StringPrintf("/system/framework/%s/boot.art", isa);
352 if (access(preopted_boot_art_path.c_str(), F_OK) == 0) {
353 return PatchoatBootImage(art_path, isa);
354 } else {
355 // No preopted boot image. Try to compile.
356 return Dex2oatBootImage(boot_classpath_, art_path, oat_path, isa);
357 }
358 }
359
CreatePath(const std::string & path)360 static bool CreatePath(const std::string& path) {
361 // Create the given path. Use string processing instead of dirname, as dirname's need for
362 // a writable char buffer is painful.
363
364 // First, try to use the full path.
365 if (mkdir(path.c_str(), 0711) == 0) {
366 return true;
367 }
368 if (errno != ENOENT) {
369 PLOG(ERROR) << "Could not create path " << path;
370 return false;
371 }
372
373 // Now find the parent and try that first.
374 size_t last_slash = path.find_last_of('/');
375 if (last_slash == std::string::npos || last_slash == 0) {
376 PLOG(ERROR) << "Could not create " << path;
377 return false;
378 }
379
380 if (!CreatePath(path.substr(0, last_slash))) {
381 return false;
382 }
383
384 if (mkdir(path.c_str(), 0711) == 0) {
385 return true;
386 }
387 PLOG(ERROR) << "Could not create " << path;
388 return false;
389 }
390
ClearDirectory(const std::string & dir)391 static void ClearDirectory(const std::string& dir) {
392 DIR* c_dir = opendir(dir.c_str());
393 if (c_dir == nullptr) {
394 PLOG(WARNING) << "Unable to open " << dir << " to delete it's contents";
395 return;
396 }
397
398 for (struct dirent* de = readdir(c_dir); de != nullptr; de = readdir(c_dir)) {
399 const char* name = de->d_name;
400 if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
401 continue;
402 }
403 // We only want to delete regular files and symbolic links.
404 std::string file = StringPrintf("%s/%s", dir.c_str(), name);
405 if (de->d_type != DT_REG && de->d_type != DT_LNK) {
406 LOG(WARNING) << "Unexpected file "
407 << file
408 << " of type "
409 << std::hex
410 << de->d_type
411 << " encountered.";
412 } else {
413 // Try to unlink the file.
414 if (unlink(file.c_str()) != 0) {
415 PLOG(ERROR) << "Unable to unlink " << file;
416 }
417 }
418 }
419 CHECK_EQ(0, closedir(c_dir)) << "Unable to close directory.";
420 }
421
PatchoatBootImage(const std::string & art_path,const char * isa) const422 bool PatchoatBootImage(const std::string& art_path, const char* isa) const {
423 // This needs to be kept in sync with ART, see art/runtime/gc/space/image_space.cc.
424
425 std::vector<std::string> cmd;
426 cmd.push_back("/system/bin/patchoat");
427
428 cmd.push_back("--input-image-location=/system/framework/boot.art");
429 cmd.push_back(StringPrintf("--output-image-file=%s", art_path.c_str()));
430
431 cmd.push_back(StringPrintf("--instruction-set=%s", isa));
432
433 int32_t base_offset = ChooseRelocationOffsetDelta(ART_BASE_ADDRESS_MIN_DELTA,
434 ART_BASE_ADDRESS_MAX_DELTA);
435 cmd.push_back(StringPrintf("--base-offset-delta=%d", base_offset));
436
437 std::string error_msg;
438 bool result = Exec(cmd, &error_msg);
439 if (!result) {
440 LOG(ERROR) << "Could not generate boot image: " << error_msg;
441 }
442 return result;
443 }
444
Dex2oatBootImage(const std::string & boot_cp,const std::string & art_path,const std::string & oat_path,const char * isa) const445 bool Dex2oatBootImage(const std::string& boot_cp,
446 const std::string& art_path,
447 const std::string& oat_path,
448 const char* isa) const {
449 // This needs to be kept in sync with ART, see art/runtime/gc/space/image_space.cc.
450 std::vector<std::string> cmd;
451 cmd.push_back("/system/bin/dex2oat");
452 cmd.push_back(StringPrintf("--image=%s", art_path.c_str()));
453 for (const std::string& boot_part : Split(boot_cp, ":")) {
454 cmd.push_back(StringPrintf("--dex-file=%s", boot_part.c_str()));
455 }
456 cmd.push_back(StringPrintf("--oat-file=%s", oat_path.c_str()));
457
458 int32_t base_offset = ChooseRelocationOffsetDelta(ART_BASE_ADDRESS_MIN_DELTA,
459 ART_BASE_ADDRESS_MAX_DELTA);
460 cmd.push_back(StringPrintf("--base=0x%x", ART_BASE_ADDRESS + base_offset));
461
462 cmd.push_back(StringPrintf("--instruction-set=%s", isa));
463
464 // These things are pushed by AndroidRuntime, see frameworks/base/core/jni/AndroidRuntime.cpp.
465 AddCompilerOptionFromSystemProperty("dalvik.vm.image-dex2oat-Xms",
466 "-Xms",
467 true,
468 cmd);
469 AddCompilerOptionFromSystemProperty("dalvik.vm.image-dex2oat-Xmx",
470 "-Xmx",
471 true,
472 cmd);
473 AddCompilerOptionFromSystemProperty("dalvik.vm.image-dex2oat-filter",
474 "--compiler-filter=",
475 false,
476 cmd);
477 cmd.push_back("--image-classes=/system/etc/preloaded-classes");
478 // TODO: Compiled-classes.
479 const std::string* extra_opts =
480 system_properties_.GetProperty("dalvik.vm.image-dex2oat-flags");
481 if (extra_opts != nullptr) {
482 std::vector<std::string> extra_vals = Split(*extra_opts, " ");
483 cmd.insert(cmd.end(), extra_vals.begin(), extra_vals.end());
484 }
485 // TODO: Should we lower this? It's usually set close to max, because
486 // normally there's not much else going on at boot.
487 AddCompilerOptionFromSystemProperty("dalvik.vm.image-dex2oat-threads",
488 "-j",
489 false,
490 cmd);
491 AddCompilerOptionFromSystemProperty(
492 StringPrintf("dalvik.vm.isa.%s.variant", isa).c_str(),
493 "--instruction-set-variant=",
494 false,
495 cmd);
496 AddCompilerOptionFromSystemProperty(
497 StringPrintf("dalvik.vm.isa.%s.features", isa).c_str(),
498 "--instruction-set-features=",
499 false,
500 cmd);
501
502 std::string error_msg;
503 bool result = Exec(cmd, &error_msg);
504 if (!result) {
505 LOG(ERROR) << "Could not generate boot image: " << error_msg;
506 }
507 return result;
508 }
509
ParseNull(const char * arg)510 static const char* ParseNull(const char* arg) {
511 return (strcmp(arg, "!") == 0) ? nullptr : arg;
512 }
513
ShouldSkipPreopt() const514 bool ShouldSkipPreopt() const {
515 // There's one thing we have to be careful about: we may/will be asked to compile an app
516 // living in the system image. This may be a valid request - if the app wasn't compiled,
517 // e.g., if the system image wasn't large enough to include preopted files. However, the
518 // data we have is from the old system, so the driver (the OTA service) can't actually
519 // know. Thus, we will get requests for apps that have preopted components. To avoid
520 // duplication (we'd generate files that are not used and are *not* cleaned up), do two
521 // simple checks:
522 //
523 // 1) Does the apk_path start with the value of ANDROID_ROOT? (~in the system image)
524 // (For simplicity, assume the value of ANDROID_ROOT does not contain a symlink.)
525 //
526 // 2) If you replace the name in the apk_path with "oat," does the path exist?
527 // (=have a subdirectory for preopted files)
528 //
529 // If the answer to both is yes, skip the dexopt.
530 //
531 // Note: while one may think it's OK to call dexopt and it will fail (because APKs should
532 // be stripped), that's not true for APKs signed outside the build system (so the
533 // jar content must be exactly the same).
534
535 // (This is ugly as it's the only thing where we need to understand the contents
536 // of package_parameters_, but it beats postponing the decision or using the call-
537 // backs to do weird things.)
538 constexpr size_t kApkPathIndex = 0;
539 CHECK_GT(DEXOPT_PARAM_COUNT, kApkPathIndex);
540 CHECK(package_parameters_[kApkPathIndex] != nullptr);
541 if (StartsWith(package_parameters_[kApkPathIndex], android_root_.c_str())) {
542 const char* last_slash = strrchr(package_parameters_[kApkPathIndex], '/');
543 if (last_slash != nullptr) {
544 std::string path(package_parameters_[kApkPathIndex],
545 last_slash - package_parameters_[kApkPathIndex] + 1);
546 CHECK(EndsWith(path, "/"));
547 path = path + "oat";
548 if (access(path.c_str(), F_OK) == 0) {
549 return true;
550 }
551 }
552 }
553
554 // Another issue is unavailability of files in the new system. If the partition
555 // layout changes, otapreopt_chroot may not know about this. Then files from that
556 // partition will not be available and fail to build. This is problematic, as
557 // this tool will wipe the OTA artifact cache and try again (for robustness after
558 // a failed OTA with remaining cache artifacts).
559 if (access(package_parameters_[kApkPathIndex], F_OK) != 0) {
560 LOG(WARNING) << "Skipping preopt of non-existing package "
561 << package_parameters_[kApkPathIndex];
562 return true;
563 }
564
565 return false;
566 }
567
RunPreopt()568 int RunPreopt() {
569 if (ShouldSkipPreopt()) {
570 return 0;
571 }
572
573 int dexopt_result = dexopt(package_parameters_);
574 if (dexopt_result == 0) {
575 return 0;
576 }
577
578 // If the dexopt failed, we may have a stale boot image from a previous OTA run.
579 // Try to delete and retry.
580
581 if (!PrepareBootImage(/* force */ true)) {
582 LOG(ERROR) << "Forced boot image creating failed. Original error return was "
583 << dexopt_result;
584 return dexopt_result;
585 }
586
587 LOG(WARNING) << "Original dexopt failed, re-trying after boot image was regenerated.";
588 return dexopt(package_parameters_);
589 }
590
591 ////////////////////////////////////
592 // Helpers, mostly taken from ART //
593 ////////////////////////////////////
594
595 // Wrapper on fork/execv to run a command in a subprocess.
Exec(const std::vector<std::string> & arg_vector,std::string * error_msg)596 static bool Exec(const std::vector<std::string>& arg_vector, std::string* error_msg) {
597 const std::string command_line = Join(arg_vector, ' ');
598
599 CHECK_GE(arg_vector.size(), 1U) << command_line;
600
601 // Convert the args to char pointers.
602 const char* program = arg_vector[0].c_str();
603 std::vector<char*> args;
604 for (size_t i = 0; i < arg_vector.size(); ++i) {
605 const std::string& arg = arg_vector[i];
606 char* arg_str = const_cast<char*>(arg.c_str());
607 CHECK(arg_str != nullptr) << i;
608 args.push_back(arg_str);
609 }
610 args.push_back(nullptr);
611
612 // Fork and exec.
613 pid_t pid = fork();
614 if (pid == 0) {
615 // No allocation allowed between fork and exec.
616
617 // Change process groups, so we don't get reaped by ProcessManager.
618 setpgid(0, 0);
619
620 execv(program, &args[0]);
621
622 PLOG(ERROR) << "Failed to execv(" << command_line << ")";
623 // _exit to avoid atexit handlers in child.
624 _exit(1);
625 } else {
626 if (pid == -1) {
627 *error_msg = StringPrintf("Failed to execv(%s) because fork failed: %s",
628 command_line.c_str(), strerror(errno));
629 return false;
630 }
631
632 // wait for subprocess to finish
633 int status;
634 pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
635 if (got_pid != pid) {
636 *error_msg = StringPrintf("Failed after fork for execv(%s) because waitpid failed: "
637 "wanted %d, got %d: %s",
638 command_line.c_str(), pid, got_pid, strerror(errno));
639 return false;
640 }
641 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
642 *error_msg = StringPrintf("Failed execv(%s) because non-0 exit status",
643 command_line.c_str());
644 return false;
645 }
646 }
647 return true;
648 }
649
650 // Choose a random relocation offset. Taken from art/runtime/gc/image_space.cc.
ChooseRelocationOffsetDelta(int32_t min_delta,int32_t max_delta)651 static int32_t ChooseRelocationOffsetDelta(int32_t min_delta, int32_t max_delta) {
652 constexpr size_t kPageSize = PAGE_SIZE;
653 CHECK_EQ(min_delta % kPageSize, 0u);
654 CHECK_EQ(max_delta % kPageSize, 0u);
655 CHECK_LT(min_delta, max_delta);
656
657 std::default_random_engine generator;
658 generator.seed(GetSeed());
659 std::uniform_int_distribution<int32_t> distribution(min_delta, max_delta);
660 int32_t r = distribution(generator);
661 if (r % 2 == 0) {
662 r = RoundUp(r, kPageSize);
663 } else {
664 r = RoundDown(r, kPageSize);
665 }
666 CHECK_LE(min_delta, r);
667 CHECK_GE(max_delta, r);
668 CHECK_EQ(r % kPageSize, 0u);
669 return r;
670 }
671
GetSeed()672 static uint64_t GetSeed() {
673 #ifdef __BIONIC__
674 // Bionic exposes arc4random, use it.
675 uint64_t random_data;
676 arc4random_buf(&random_data, sizeof(random_data));
677 return random_data;
678 #else
679 #error "This is only supposed to run with bionic. Otherwise, implement..."
680 #endif
681 }
682
AddCompilerOptionFromSystemProperty(const char * system_property,const char * prefix,bool runtime,std::vector<std::string> & out) const683 void AddCompilerOptionFromSystemProperty(const char* system_property,
684 const char* prefix,
685 bool runtime,
686 std::vector<std::string>& out) const {
687 const std::string* value = system_properties_.GetProperty(system_property);
688 if (value != nullptr) {
689 if (runtime) {
690 out.push_back("--runtime-arg");
691 }
692 if (prefix != nullptr) {
693 out.push_back(StringPrintf("%s%s", prefix, value->c_str()));
694 } else {
695 out.push_back(*value);
696 }
697 }
698 }
699
700 static constexpr const char* kBootClassPathPropertyName = "BOOTCLASSPATH";
701 static constexpr const char* kAndroidRootPathPropertyName = "ANDROID_ROOT";
702 static constexpr const char* kAndroidDataPathPropertyName = "ANDROID_DATA";
703 // The index of the instruction-set string inside the package parameters. Needed for
704 // some special-casing that requires knowledge of the instruction-set.
705 static constexpr size_t kISAIndex = 3;
706
707 // Stores the system properties read out of the B partition. We need to use these properties
708 // to compile, instead of the A properties we could get from init/get_property.
709 SystemProperties system_properties_;
710
711 // Some select properties that are always needed.
712 std::string target_slot_;
713 std::string android_root_;
714 std::string android_data_;
715 std::string boot_classpath_;
716 std::string asec_mountpoint_;
717
718 const char* package_parameters_[DEXOPT_PARAM_COUNT];
719
720 // Store environment values we need to set.
721 std::vector<std::string> environ_;
722 };
723
724 OTAPreoptService gOps;
725
726 ////////////////////////
727 // Plug-in functions. //
728 ////////////////////////
729
get_property(const char * key,char * value,const char * default_value)730 int get_property(const char *key, char *value, const char *default_value) {
731 return gOps.GetProperty(key, value, default_value);
732 }
733
734 // Compute the output path of
calculate_oat_file_path(char path[PKG_PATH_MAX],const char * oat_dir,const char * apk_path,const char * instruction_set)735 bool calculate_oat_file_path(char path[PKG_PATH_MAX], const char *oat_dir,
736 const char *apk_path,
737 const char *instruction_set) {
738 const char *file_name_start;
739 const char *file_name_end;
740
741 file_name_start = strrchr(apk_path, '/');
742 if (file_name_start == nullptr) {
743 ALOGE("apk_path '%s' has no '/'s in it\n", apk_path);
744 return false;
745 }
746 file_name_end = strrchr(file_name_start, '.');
747 if (file_name_end == nullptr) {
748 ALOGE("apk_path '%s' has no extension\n", apk_path);
749 return false;
750 }
751
752 // Calculate file_name
753 file_name_start++; // Move past '/', is valid as file_name_end is valid.
754 size_t file_name_len = file_name_end - file_name_start;
755 std::string file_name(file_name_start, file_name_len);
756
757 // <apk_parent_dir>/oat/<isa>/<file_name>.odex.b
758 snprintf(path,
759 PKG_PATH_MAX,
760 "%s/%s/%s.odex.%s",
761 oat_dir,
762 instruction_set,
763 file_name.c_str(),
764 gOps.GetTargetSlot().c_str());
765 return true;
766 }
767
768 /*
769 * Computes the odex file for the given apk_path and instruction_set.
770 * /system/framework/whatever.jar -> /system/framework/oat/<isa>/whatever.odex
771 *
772 * Returns false if it failed to determine the odex file path.
773 */
calculate_odex_file_path(char path[PKG_PATH_MAX],const char * apk_path,const char * instruction_set)774 bool calculate_odex_file_path(char path[PKG_PATH_MAX], const char *apk_path,
775 const char *instruction_set) {
776 const char *path_end = strrchr(apk_path, '/');
777 if (path_end == nullptr) {
778 ALOGE("apk_path '%s' has no '/'s in it?!\n", apk_path);
779 return false;
780 }
781 std::string path_component(apk_path, path_end - apk_path);
782
783 const char *name_begin = path_end + 1;
784 const char *extension_start = strrchr(name_begin, '.');
785 if (extension_start == nullptr) {
786 ALOGE("apk_path '%s' has no extension.\n", apk_path);
787 return false;
788 }
789 std::string name_component(name_begin, extension_start - name_begin);
790
791 std::string new_path = StringPrintf("%s/oat/%s/%s.odex.%s",
792 path_component.c_str(),
793 instruction_set,
794 name_component.c_str(),
795 gOps.GetTargetSlot().c_str());
796 if (new_path.length() >= PKG_PATH_MAX) {
797 LOG(ERROR) << "apk_path of " << apk_path << " is too long: " << new_path;
798 return false;
799 }
800 strcpy(path, new_path.c_str());
801 return true;
802 }
803
create_cache_path(char path[PKG_PATH_MAX],const char * src,const char * instruction_set)804 bool create_cache_path(char path[PKG_PATH_MAX],
805 const char *src,
806 const char *instruction_set) {
807 size_t srclen = strlen(src);
808
809 /* demand that we are an absolute path */
810 if ((src == 0) || (src[0] != '/') || strstr(src,"..")) {
811 return false;
812 }
813
814 if (srclen > PKG_PATH_MAX) { // XXX: PKG_NAME_MAX?
815 return false;
816 }
817
818 std::string from_src = std::string(src + 1);
819 std::replace(from_src.begin(), from_src.end(), '/', '@');
820
821 std::string assembled_path = StringPrintf("%s/%s/%s/%s%s",
822 gOps.GetOTADataDirectory().c_str(),
823 DALVIK_CACHE,
824 instruction_set,
825 from_src.c_str(),
826 DALVIK_CACHE_POSTFIX2);
827
828 if (assembled_path.length() + 1 > PKG_PATH_MAX) {
829 return false;
830 }
831 strcpy(path, assembled_path.c_str());
832
833 return true;
834 }
835
log_callback(int type,const char * fmt,...)836 static int log_callback(int type, const char *fmt, ...) {
837 va_list ap;
838 int priority;
839
840 switch (type) {
841 case SELINUX_WARNING:
842 priority = ANDROID_LOG_WARN;
843 break;
844 case SELINUX_INFO:
845 priority = ANDROID_LOG_INFO;
846 break;
847 default:
848 priority = ANDROID_LOG_ERROR;
849 break;
850 }
851 va_start(ap, fmt);
852 LOG_PRI_VA(priority, "SELinux", fmt, ap);
853 va_end(ap);
854 return 0;
855 }
856
otapreopt_main(const int argc,char * argv[])857 static int otapreopt_main(const int argc, char *argv[]) {
858 int selinux_enabled = (is_selinux_enabled() > 0);
859
860 setenv("ANDROID_LOG_TAGS", "*:v", 1);
861 android::base::InitLogging(argv);
862
863 if (argc < 2) {
864 ALOGE("Expecting parameters");
865 exit(1);
866 }
867
868 union selinux_callback cb;
869 cb.func_log = log_callback;
870 selinux_set_callback(SELINUX_CB_LOG, cb);
871
872 if (selinux_enabled && selinux_status_open(true) < 0) {
873 ALOGE("Could not open selinux status; exiting.\n");
874 exit(1);
875 }
876
877 int ret = android::installd::gOps.Main(argc, argv);
878
879 return ret;
880 }
881
882 } // namespace installd
883 } // namespace android
884
main(const int argc,char * argv[])885 int main(const int argc, char *argv[]) {
886 return android::installd::otapreopt_main(argc, argv);
887 }
888