oat_file_assistant.cc revision fd336c344058274fada3c48fbd356befca285b9a 
1/*
2 * Copyright (C) 2014 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 "oat_file_assistant.h"
18
19#include <fcntl.h>
20#ifdef __linux__
21#include <sys/sendfile.h>
22#else
23#include <sys/socket.h>
24#endif
25#include <sys/types.h>
26#include <sys/stat.h>
27#include <unistd.h>
28
29#include <set>
30
31#include "base/logging.h"
32#include "base/stringprintf.h"
33#include "class_linker.h"
34#include "gc/heap.h"
35#include "gc/space/image_space.h"
36#include "image.h"
37#include "oat.h"
38#include "os.h"
39#include "runtime.h"
40#include "scoped_thread_state_change.h"
41#include "ScopedFd.h"
42#include "utils.h"
43
44namespace art {
45
46OatFileAssistant::OatFileAssistant(const char* dex_location,
47                                   const InstructionSet isa,
48                                   bool profile_changed,
49                                   bool load_executable)
50    : OatFileAssistant(dex_location, nullptr, isa, profile_changed, load_executable)
51{ }
52
53OatFileAssistant::OatFileAssistant(const char* dex_location,
54                                   const char* oat_location,
55                                   const InstructionSet isa,
56                                   bool profile_changed,
57                                   bool load_executable)
58    : isa_(isa), profile_changed_(profile_changed), load_executable_(load_executable) {
59  CHECK(dex_location != nullptr) << "OatFileAssistant: null dex location";
60  dex_location_.assign(dex_location);
61
62  if (load_executable_ && isa != kRuntimeISA) {
63    LOG(WARNING) << "OatFileAssistant: Load executable specified, "
64      << "but isa is not kRuntimeISA. Will not attempt to load executable.";
65    load_executable_ = false;
66  }
67
68  // If the user gave a target oat location, save that as the cached oat
69  // location now so we won't try to construct the default location later.
70  if (oat_location != nullptr) {
71    cached_oat_file_name_ = std::string(oat_location);
72    cached_oat_file_name_attempted_ = true;
73    cached_oat_file_name_found_ = true;
74  }
75}
76
77OatFileAssistant::~OatFileAssistant() {
78  // Clean up the lock file.
79  if (flock_.HasFile()) {
80    unlink(flock_.GetFile()->GetPath().c_str());
81  }
82}
83
84bool OatFileAssistant::IsInBootClassPath() {
85  // Note: We check the current boot class path, regardless of the ISA
86  // specified by the user. This is okay, because the boot class path should
87  // be the same for all ISAs.
88  // TODO: Can we verify the boot class path is the same for all ISAs?
89  Runtime* runtime = Runtime::Current();
90  ClassLinker* class_linker = runtime->GetClassLinker();
91  const auto& boot_class_path = class_linker->GetBootClassPath();
92  for (size_t i = 0; i < boot_class_path.size(); i++) {
93    if (boot_class_path[i]->GetLocation() == dex_location_) {
94      VLOG(oat) << "Dex location " << dex_location_ << " is in boot class path";
95      return true;
96    }
97  }
98  return false;
99}
100
101bool OatFileAssistant::Lock(std::string* error_msg) {
102  CHECK(error_msg != nullptr);
103  CHECK(!flock_.HasFile()) << "OatFileAssistant::Lock already acquired";
104
105  if (OatFileName() == nullptr) {
106    *error_msg = "Failed to determine lock file";
107    return false;
108  }
109  std::string lock_file_name = *OatFileName() + ".flock";
110
111  if (!flock_.Init(lock_file_name.c_str(), error_msg)) {
112    unlink(lock_file_name.c_str());
113    return false;
114  }
115  return true;
116}
117
118bool OatFileAssistant::OatFileCompilerFilterIsOkay(CompilerFilter::Filter target) {
119  const OatFile* oat_file = GetOatFile();
120  if (oat_file != nullptr) {
121    CompilerFilter::Filter current = oat_file->GetCompilerFilter();
122    return CompilerFilter::IsAsGoodAs(current, target);
123  }
124  return false;
125}
126
127bool OatFileAssistant::OdexFileCompilerFilterIsOkay(CompilerFilter::Filter target) {
128  const OatFile* odex_file = GetOdexFile();
129  if (odex_file != nullptr) {
130    CompilerFilter::Filter current = odex_file->GetCompilerFilter();
131    return CompilerFilter::IsAsGoodAs(current, target);
132  }
133  return false;
134}
135
136OatFileAssistant::DexOptNeeded OatFileAssistant::GetDexOptNeeded(CompilerFilter::Filter target) {
137  bool compilation_desired = CompilerFilter::IsCompilationEnabled(target);
138
139  // See if the oat file is in good shape as is.
140  bool oat_okay = OatFileCompilerFilterIsOkay(target);
141  if (oat_okay) {
142    if (compilation_desired) {
143      if (OatFileIsUpToDate()) {
144        return kNoDexOptNeeded;
145      }
146    } else {
147      if (!OatFileIsOutOfDate()) {
148        return kNoDexOptNeeded;
149      }
150    }
151  }
152
153  // See if the odex file is in good shape as is.
154  bool odex_okay = OdexFileCompilerFilterIsOkay(target);
155  if (odex_okay) {
156    if (compilation_desired) {
157      if (OdexFileIsUpToDate()) {
158        return kNoDexOptNeeded;
159      }
160    } else {
161      if (!OdexFileIsOutOfDate()) {
162        return kNoDexOptNeeded;
163      }
164    }
165  }
166
167  // See if we can get an up-to-date file by running patchoat.
168  if (compilation_desired) {
169    if (odex_okay && OdexFileNeedsRelocation() && OdexFileHasPatchInfo()) {
170      return kPatchOatNeeded;
171    }
172
173    if (oat_okay && OatFileNeedsRelocation() && OatFileHasPatchInfo()) {
174      return kSelfPatchOatNeeded;
175    }
176  }
177
178  // We can only run dex2oat if there are original dex files.
179  return HasOriginalDexFiles() ? kDex2OatNeeded : kNoDexOptNeeded;
180}
181
182OatFileAssistant::ResultOfAttemptToUpdate
183OatFileAssistant::MakeUpToDate(CompilerFilter::Filter target, std::string* error_msg) {
184  switch (GetDexOptNeeded(target)) {
185    case kNoDexOptNeeded: return kUpdateSucceeded;
186    case kDex2OatNeeded: return GenerateOatFile(target, error_msg);
187    case kPatchOatNeeded: return RelocateOatFile(OdexFileName(), error_msg);
188    case kSelfPatchOatNeeded: return RelocateOatFile(OatFileName(), error_msg);
189  }
190  UNREACHABLE();
191}
192
193std::unique_ptr<OatFile> OatFileAssistant::GetBestOatFile() {
194  // The best oat files are, in descending order of bestness:
195  // 1. Properly relocated files. These may be opened executable.
196  // 2. Not out-of-date files that are already opened non-executable.
197  // 3. Not out-of-date files that we must reopen non-executable.
198
199  if (OatFileIsUpToDate()) {
200    oat_file_released_ = true;
201    return std::move(cached_oat_file_);
202  }
203
204  if (OdexFileIsUpToDate()) {
205    oat_file_released_ = true;
206    return std::move(cached_odex_file_);
207  }
208
209  VLOG(oat) << "Oat File Assistant: No relocated oat file found,"
210    << " attempting to fall back to interpreting oat file instead.";
211
212  if (!OatFileIsOutOfDate() && !OatFileIsExecutable()) {
213    oat_file_released_ = true;
214    return std::move(cached_oat_file_);
215  }
216
217  if (!OdexFileIsOutOfDate() && !OdexFileIsExecutable()) {
218    oat_file_released_ = true;
219    return std::move(cached_odex_file_);
220  }
221
222  if (!OatFileIsOutOfDate()) {
223    load_executable_ = false;
224    ClearOatFileCache();
225    if (!OatFileIsOutOfDate()) {
226      CHECK(!OatFileIsExecutable());
227      oat_file_released_ = true;
228      return std::move(cached_oat_file_);
229    }
230  }
231
232  if (!OdexFileIsOutOfDate()) {
233    load_executable_ = false;
234    ClearOdexFileCache();
235    if (!OdexFileIsOutOfDate()) {
236      CHECK(!OdexFileIsExecutable());
237      oat_file_released_ = true;
238      return std::move(cached_odex_file_);
239    }
240  }
241
242  return std::unique_ptr<OatFile>();
243}
244
245std::vector<std::unique_ptr<const DexFile>> OatFileAssistant::LoadDexFiles(
246    const OatFile& oat_file, const char* dex_location) {
247  std::vector<std::unique_ptr<const DexFile>> dex_files;
248
249  // Load the primary dex file.
250  std::string error_msg;
251  const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(
252      dex_location, nullptr, false);
253  if (oat_dex_file == nullptr) {
254    LOG(WARNING) << "Attempt to load out-of-date oat file "
255      << oat_file.GetLocation() << " for dex location " << dex_location;
256    return std::vector<std::unique_ptr<const DexFile>>();
257  }
258
259  std::unique_ptr<const DexFile> dex_file = oat_dex_file->OpenDexFile(&error_msg);
260  if (dex_file.get() == nullptr) {
261    LOG(WARNING) << "Failed to open dex file from oat dex file: " << error_msg;
262    return std::vector<std::unique_ptr<const DexFile>>();
263  }
264  dex_files.push_back(std::move(dex_file));
265
266  // Load secondary multidex files
267  for (size_t i = 1; ; i++) {
268    std::string secondary_dex_location = DexFile::GetMultiDexLocation(i, dex_location);
269    oat_dex_file = oat_file.GetOatDexFile(secondary_dex_location.c_str(), nullptr, false);
270    if (oat_dex_file == nullptr) {
271      // There are no more secondary dex files to load.
272      break;
273    }
274
275    dex_file = oat_dex_file->OpenDexFile(&error_msg);
276    if (dex_file.get() == nullptr) {
277      LOG(WARNING) << "Failed to open dex file from oat dex file: " << error_msg;
278      return std::vector<std::unique_ptr<const DexFile>>();
279    }
280    dex_files.push_back(std::move(dex_file));
281  }
282  return dex_files;
283}
284
285bool OatFileAssistant::HasOriginalDexFiles() {
286  // Ensure GetRequiredDexChecksum has been run so that
287  // has_original_dex_files_ is initialized. We don't care about the result of
288  // GetRequiredDexChecksum.
289  GetRequiredDexChecksum();
290  return has_original_dex_files_;
291}
292
293const std::string* OatFileAssistant::OdexFileName() {
294  if (!cached_odex_file_name_attempted_) {
295    cached_odex_file_name_attempted_ = true;
296
297    std::string error_msg;
298    cached_odex_file_name_found_ = DexFilenameToOdexFilename(
299        dex_location_, isa_, &cached_odex_file_name_, &error_msg);
300    if (!cached_odex_file_name_found_) {
301      // If we can't figure out the odex file, we treat it as if the odex
302      // file was inaccessible.
303      LOG(WARNING) << "Failed to determine odex file name: " << error_msg;
304    }
305  }
306  return cached_odex_file_name_found_ ? &cached_odex_file_name_ : nullptr;
307}
308
309bool OatFileAssistant::OdexFileExists() {
310  return GetOdexFile() != nullptr;
311}
312
313OatFileAssistant::OatStatus OatFileAssistant::OdexFileStatus() {
314  if (OdexFileIsOutOfDate()) {
315    return kOatOutOfDate;
316  }
317  if (OdexFileIsUpToDate()) {
318    return kOatUpToDate;
319  }
320  return kOatNeedsRelocation;
321}
322
323bool OatFileAssistant::OdexFileIsOutOfDate() {
324  if (!odex_file_is_out_of_date_attempted_) {
325    odex_file_is_out_of_date_attempted_ = true;
326    const OatFile* odex_file = GetOdexFile();
327    if (odex_file == nullptr) {
328      cached_odex_file_is_out_of_date_ = true;
329    } else {
330      cached_odex_file_is_out_of_date_ = GivenOatFileIsOutOfDate(*odex_file);
331    }
332  }
333  return cached_odex_file_is_out_of_date_;
334}
335
336bool OatFileAssistant::OdexFileNeedsRelocation() {
337  return OdexFileStatus() == kOatNeedsRelocation;
338}
339
340bool OatFileAssistant::OdexFileIsUpToDate() {
341  if (!odex_file_is_up_to_date_attempted_) {
342    odex_file_is_up_to_date_attempted_ = true;
343    const OatFile* odex_file = GetOdexFile();
344    if (odex_file == nullptr) {
345      cached_odex_file_is_up_to_date_ = false;
346    } else {
347      cached_odex_file_is_up_to_date_ = GivenOatFileIsUpToDate(*odex_file);
348    }
349  }
350  return cached_odex_file_is_up_to_date_;
351}
352
353std::string OatFileAssistant::ArtFileName(const OatFile* oat_file) const {
354  const std::string oat_file_location = oat_file->GetLocation();
355  // Replace extension with .art
356  const size_t last_ext = oat_file_location.find_last_of('.');
357  if (last_ext == std::string::npos) {
358    LOG(ERROR) << "No extension in oat file " << oat_file_location;
359    return std::string();
360  }
361  return oat_file_location.substr(0, last_ext) + ".art";
362}
363
364const std::string* OatFileAssistant::OatFileName() {
365  if (!cached_oat_file_name_attempted_) {
366    cached_oat_file_name_attempted_ = true;
367
368    // Compute the oat file name from the dex location.
369    // TODO: The oat file assistant should be the definitive place for
370    // determining the oat file name from the dex location, not
371    // GetDalvikCacheFilename.
372    std::string cache_dir = StringPrintf("%s%s",
373        DalvikCacheDirectory().c_str(), GetInstructionSetString(isa_));
374    std::string error_msg;
375    cached_oat_file_name_found_ = GetDalvikCacheFilename(dex_location_.c_str(),
376        cache_dir.c_str(), &cached_oat_file_name_, &error_msg);
377    if (!cached_oat_file_name_found_) {
378      // If we can't determine the oat file name, we treat the oat file as
379      // inaccessible.
380      LOG(WARNING) << "Failed to determine oat file name for dex location "
381        << dex_location_ << ": " << error_msg;
382    }
383  }
384  return cached_oat_file_name_found_ ? &cached_oat_file_name_ : nullptr;
385}
386
387bool OatFileAssistant::OatFileExists() {
388  return GetOatFile() != nullptr;
389}
390
391OatFileAssistant::OatStatus OatFileAssistant::OatFileStatus() {
392  if (OatFileIsOutOfDate()) {
393    return kOatOutOfDate;
394  }
395  if (OatFileIsUpToDate()) {
396    return kOatUpToDate;
397  }
398  return kOatNeedsRelocation;
399}
400
401bool OatFileAssistant::OatFileIsOutOfDate() {
402  if (!oat_file_is_out_of_date_attempted_) {
403    oat_file_is_out_of_date_attempted_ = true;
404    const OatFile* oat_file = GetOatFile();
405    if (oat_file == nullptr) {
406      cached_oat_file_is_out_of_date_ = true;
407    } else {
408      cached_oat_file_is_out_of_date_ = GivenOatFileIsOutOfDate(*oat_file);
409    }
410  }
411  return cached_oat_file_is_out_of_date_;
412}
413
414bool OatFileAssistant::OatFileNeedsRelocation() {
415  return OatFileStatus() == kOatNeedsRelocation;
416}
417
418bool OatFileAssistant::OatFileIsUpToDate() {
419  if (!oat_file_is_up_to_date_attempted_) {
420    oat_file_is_up_to_date_attempted_ = true;
421    const OatFile* oat_file = GetOatFile();
422    if (oat_file == nullptr) {
423      cached_oat_file_is_up_to_date_ = false;
424    } else {
425      cached_oat_file_is_up_to_date_ = GivenOatFileIsUpToDate(*oat_file);
426    }
427  }
428  return cached_oat_file_is_up_to_date_;
429}
430
431OatFileAssistant::OatStatus OatFileAssistant::GivenOatFileStatus(const OatFile& file) {
432  // TODO: This could cause GivenOatFileIsOutOfDate to be called twice, which
433  // is more work than we need to do. If performance becomes a concern, and
434  // this method is actually called, this should be fixed.
435  if (GivenOatFileIsOutOfDate(file)) {
436    return kOatOutOfDate;
437  }
438  if (GivenOatFileIsUpToDate(file)) {
439    return kOatUpToDate;
440  }
441  return kOatNeedsRelocation;
442}
443
444bool OatFileAssistant::GivenOatFileIsOutOfDate(const OatFile& file) {
445  // Verify the dex checksum.
446  // Note: GetOatDexFile will return null if the dex checksum doesn't match
447  // what we provide, which verifies the primary dex checksum for us.
448  const uint32_t* dex_checksum_pointer = GetRequiredDexChecksum();
449  const OatFile::OatDexFile* oat_dex_file = file.GetOatDexFile(
450      dex_location_.c_str(), dex_checksum_pointer, false);
451  if (oat_dex_file == nullptr) {
452    return true;
453  }
454
455  // Verify the dex checksums for any secondary multidex files
456  for (size_t i = 1; ; i++) {
457    std::string secondary_dex_location
458      = DexFile::GetMultiDexLocation(i, dex_location_.c_str());
459    const OatFile::OatDexFile* secondary_oat_dex_file
460      = file.GetOatDexFile(secondary_dex_location.c_str(), nullptr, false);
461    if (secondary_oat_dex_file == nullptr) {
462      // There are no more secondary dex files to check.
463      break;
464    }
465
466    std::string error_msg;
467    uint32_t expected_secondary_checksum = 0;
468    if (DexFile::GetChecksum(secondary_dex_location.c_str(),
469          &expected_secondary_checksum, &error_msg)) {
470      uint32_t actual_secondary_checksum
471        = secondary_oat_dex_file->GetDexFileLocationChecksum();
472      if (expected_secondary_checksum != actual_secondary_checksum) {
473        VLOG(oat) << "Dex checksum does not match for secondary dex: "
474          << secondary_dex_location
475          << ". Expected: " << expected_secondary_checksum
476          << ", Actual: " << actual_secondary_checksum;
477        return true;
478      }
479    } else {
480      // If we can't get the checksum for the secondary location, we assume
481      // the dex checksum is up to date for this and all other secondary dex
482      // files.
483      break;
484    }
485  }
486
487  CompilerFilter::Filter current_compiler_filter = file.GetCompilerFilter();
488  VLOG(oat) << "Compiler filter for " << file.GetLocation() << " is " << current_compiler_filter;
489
490  // Verify the image checksum
491  if (CompilerFilter::DependsOnImageChecksum(current_compiler_filter)) {
492    const ImageInfo* image_info = GetImageInfo();
493    if (image_info == nullptr) {
494      VLOG(oat) << "No image for oat image checksum to match against.";
495      return true;
496    }
497
498    if (file.GetOatHeader().GetImageFileLocationOatChecksum() != GetCombinedImageChecksum()) {
499      VLOG(oat) << "Oat image checksum does not match image checksum.";
500      return true;
501    }
502  } else {
503    VLOG(oat) << "Image checksum test skipped for compiler filter " << current_compiler_filter;
504  }
505
506  // Verify the profile hasn't changed recently.
507  // TODO: Move this check to OatFileCompilerFilterIsOkay? Nothing bad should
508  // happen if we use an oat file compiled with an out-of-date profile.
509  if (CompilerFilter::DependsOnProfile(current_compiler_filter)) {
510    if (profile_changed_) {
511      VLOG(oat) << "The profile has changed recently.";
512      return true;
513    }
514  } else {
515    VLOG(oat) << "Profile check skipped for compiler filter " << current_compiler_filter;
516  }
517
518  // Everything looks good; the dex file is not out of date.
519  return false;
520}
521
522bool OatFileAssistant::GivenOatFileNeedsRelocation(const OatFile& file) {
523  return GivenOatFileStatus(file) == kOatNeedsRelocation;
524}
525
526bool OatFileAssistant::GivenOatFileIsUpToDate(const OatFile& file) {
527  if (GivenOatFileIsOutOfDate(file)) {
528    return false;
529  }
530
531  CompilerFilter::Filter current_compiler_filter = file.GetCompilerFilter();
532
533  if (CompilerFilter::IsCompilationEnabled(current_compiler_filter)) {
534    if (!file.IsPic()) {
535      const ImageInfo* image_info = GetImageInfo();
536      if (image_info == nullptr) {
537        VLOG(oat) << "No image to check oat relocation against.";
538        return false;
539      }
540
541      // Verify the oat_data_begin recorded for the image in the oat file matches
542      // the actual oat_data_begin for boot.oat in the image.
543      const OatHeader& oat_header = file.GetOatHeader();
544      uintptr_t oat_data_begin = oat_header.GetImageFileLocationOatDataBegin();
545      if (oat_data_begin != image_info->oat_data_begin) {
546        VLOG(oat) << file.GetLocation() <<
547          ": Oat file image oat_data_begin (" << oat_data_begin << ")"
548          << " does not match actual image oat_data_begin ("
549          << image_info->oat_data_begin << ")";
550        return false;
551      }
552
553      // Verify the oat_patch_delta recorded for the image in the oat file matches
554      // the actual oat_patch_delta for the image.
555      int32_t oat_patch_delta = oat_header.GetImagePatchDelta();
556      if (oat_patch_delta != image_info->patch_delta) {
557        VLOG(oat) << file.GetLocation() <<
558          ": Oat file image patch delta (" << oat_patch_delta << ")"
559          << " does not match actual image patch delta ("
560          << image_info->patch_delta << ")";
561        return false;
562      }
563    } else {
564      // Oat files compiled in PIC mode do not require relocation.
565      VLOG(oat) << "Oat relocation test skipped for PIC oat file";
566    }
567  } else {
568    VLOG(oat) << "Oat relocation test skipped for compiler filter " << current_compiler_filter;
569  }
570  return true;
571}
572
573OatFileAssistant::ResultOfAttemptToUpdate
574OatFileAssistant::RelocateOatFile(const std::string* input_file, std::string* error_msg) {
575  CHECK(error_msg != nullptr);
576
577  if (input_file == nullptr) {
578    *error_msg = "Patching of oat file for dex location " + dex_location_
579      + " not attempted because the input file name could not be determined.";
580    return kUpdateNotAttempted;
581  }
582  const std::string& input_file_name = *input_file;
583
584  if (OatFileName() == nullptr) {
585    *error_msg = "Patching of oat file for dex location " + dex_location_
586      + " not attempted because the oat file name could not be determined.";
587    return kUpdateNotAttempted;
588  }
589  const std::string& oat_file_name = *OatFileName();
590
591  const ImageInfo* image_info = GetImageInfo();
592  Runtime* runtime = Runtime::Current();
593  if (image_info == nullptr) {
594    *error_msg = "Patching of oat file " + oat_file_name
595      + " not attempted because no image location was found.";
596    return kUpdateNotAttempted;
597  }
598
599  if (!runtime->IsDex2OatEnabled()) {
600    *error_msg = "Patching of oat file " + oat_file_name
601      + " not attempted because dex2oat is disabled";
602    return kUpdateNotAttempted;
603  }
604
605  std::vector<std::string> argv;
606  argv.push_back(runtime->GetPatchoatExecutable());
607  argv.push_back("--instruction-set=" + std::string(GetInstructionSetString(isa_)));
608  argv.push_back("--input-oat-file=" + input_file_name);
609  argv.push_back("--output-oat-file=" + oat_file_name);
610  argv.push_back("--patched-image-location=" + image_info->location);
611
612  std::string command_line(Join(argv, ' '));
613  if (!Exec(argv, error_msg)) {
614    // Manually delete the file. This ensures there is no garbage left over if
615    // the process unexpectedly died.
616    unlink(oat_file_name.c_str());
617    return kUpdateFailed;
618  }
619
620  // Mark that the oat file has changed and we should try to reload.
621  ClearOatFileCache();
622  return kUpdateSucceeded;
623}
624
625OatFileAssistant::ResultOfAttemptToUpdate
626OatFileAssistant::GenerateOatFile(CompilerFilter::Filter target, std::string* error_msg) {
627  CHECK(error_msg != nullptr);
628
629  Runtime* runtime = Runtime::Current();
630  if (!runtime->IsDex2OatEnabled()) {
631    *error_msg = "Generation of oat file for dex location " + dex_location_
632      + " not attempted because dex2oat is disabled.";
633    return kUpdateNotAttempted;
634  }
635
636  if (OatFileName() == nullptr) {
637    *error_msg = "Generation of oat file for dex location " + dex_location_
638      + " not attempted because the oat file name could not be determined.";
639    return kUpdateNotAttempted;
640  }
641  const std::string& oat_file_name = *OatFileName();
642
643  // dex2oat ignores missing dex files and doesn't report an error.
644  // Check explicitly here so we can detect the error properly.
645  // TODO: Why does dex2oat behave that way?
646  if (!OS::FileExists(dex_location_.c_str())) {
647    *error_msg = "Dex location " + dex_location_ + " does not exists.";
648    return kUpdateNotAttempted;
649  }
650
651  std::unique_ptr<File> oat_file;
652  oat_file.reset(OS::CreateEmptyFile(oat_file_name.c_str()));
653  if (oat_file.get() == nullptr) {
654    *error_msg = "Generation of oat file " + oat_file_name
655      + " not attempted because the oat file could not be created.";
656    return kUpdateNotAttempted;
657  }
658
659  if (fchmod(oat_file->Fd(), 0644) != 0) {
660    *error_msg = "Generation of oat file " + oat_file_name
661      + " not attempted because the oat file could not be made world readable.";
662    oat_file->Erase();
663    return kUpdateNotAttempted;
664  }
665
666  std::vector<std::string> args;
667  args.push_back("--dex-file=" + dex_location_);
668  args.push_back("--oat-fd=" + std::to_string(oat_file->Fd()));
669  args.push_back("--oat-location=" + oat_file_name);
670  args.push_back("--compiler-filter=" + CompilerFilter::NameOfFilter(target));
671
672  if (!Dex2Oat(args, error_msg)) {
673    // Manually delete the file. This ensures there is no garbage left over if
674    // the process unexpectedly died.
675    oat_file->Erase();
676    unlink(oat_file_name.c_str());
677    return kUpdateFailed;
678  }
679
680  if (oat_file->FlushCloseOrErase() != 0) {
681    *error_msg = "Unable to close oat file " + oat_file_name;
682    unlink(oat_file_name.c_str());
683    return kUpdateFailed;
684  }
685
686  // Mark that the oat file has changed and we should try to reload.
687  ClearOatFileCache();
688  return kUpdateSucceeded;
689}
690
691bool OatFileAssistant::Dex2Oat(const std::vector<std::string>& args,
692                               std::string* error_msg) {
693  Runtime* runtime = Runtime::Current();
694  std::string image_location = ImageLocation();
695  if (image_location.empty()) {
696    *error_msg = "No image location found for Dex2Oat.";
697    return false;
698  }
699
700  std::vector<std::string> argv;
701  argv.push_back(runtime->GetCompilerExecutable());
702  argv.push_back("--runtime-arg");
703  argv.push_back("-classpath");
704  argv.push_back("--runtime-arg");
705  argv.push_back(runtime->GetClassPathString());
706  if (runtime->IsDebuggable()) {
707    argv.push_back("--debuggable");
708  }
709  runtime->AddCurrentRuntimeFeaturesAsDex2OatArguments(&argv);
710
711  if (!runtime->IsVerificationEnabled()) {
712    argv.push_back("--compiler-filter=verify-none");
713  }
714
715  if (runtime->MustRelocateIfPossible()) {
716    argv.push_back("--runtime-arg");
717    argv.push_back("-Xrelocate");
718  } else {
719    argv.push_back("--runtime-arg");
720    argv.push_back("-Xnorelocate");
721  }
722
723  if (!kIsTargetBuild) {
724    argv.push_back("--host");
725  }
726
727  argv.push_back("--boot-image=" + image_location);
728
729  std::vector<std::string> compiler_options = runtime->GetCompilerOptions();
730  argv.insert(argv.end(), compiler_options.begin(), compiler_options.end());
731
732  argv.insert(argv.end(), args.begin(), args.end());
733
734  std::string command_line(Join(argv, ' '));
735  return Exec(argv, error_msg);
736}
737
738bool OatFileAssistant::DexFilenameToOdexFilename(const std::string& location,
739    InstructionSet isa, std::string* odex_filename, std::string* error_msg) {
740  CHECK(odex_filename != nullptr);
741  CHECK(error_msg != nullptr);
742
743  // The odex file name is formed by replacing the dex_location extension with
744  // .odex and inserting an oat/<isa> directory. For example:
745  //   location = /foo/bar/baz.jar
746  //   odex_location = /foo/bar/oat/<isa>/baz.odex
747
748  // Find the directory portion of the dex location and add the oat/<isa>
749  // directory.
750  size_t pos = location.rfind('/');
751  if (pos == std::string::npos) {
752    *error_msg = "Dex location " + location + " has no directory.";
753    return false;
754  }
755  std::string dir = location.substr(0, pos+1);
756  dir += "oat/" + std::string(GetInstructionSetString(isa));
757
758  // Find the file portion of the dex location.
759  std::string file;
760  if (pos == std::string::npos) {
761    file = location;
762  } else {
763    file = location.substr(pos+1);
764  }
765
766  // Get the base part of the file without the extension.
767  pos = file.rfind('.');
768  if (pos == std::string::npos) {
769    *error_msg = "Dex location " + location + " has no extension.";
770    return false;
771  }
772  std::string base = file.substr(0, pos);
773
774  *odex_filename = dir + "/" + base + ".odex";
775  return true;
776}
777
778std::string OatFileAssistant::DalvikCacheDirectory() {
779  // Note: We don't cache this, because it will only be called once by
780  // OatFileName.
781
782  // TODO: The work done in GetDalvikCache is overkill for what we need.
783  // Ideally a new API for getting the DalvikCacheDirectory the way we want
784  // (without existence testing, creation, or death) is provided with the rest
785  // of the GetDalvikCache family of functions. Until such an API is in place,
786  // we use GetDalvikCache to avoid duplicating the logic for determining the
787  // dalvik cache directory.
788  std::string result;
789  bool have_android_data;
790  bool dalvik_cache_exists;
791  bool is_global_cache;
792  GetDalvikCache("", false, &result, &have_android_data, &dalvik_cache_exists, &is_global_cache);
793  return result;
794}
795
796std::string OatFileAssistant::ImageLocation() {
797  Runtime* runtime = Runtime::Current();
798  const std::vector<gc::space::ImageSpace*>& image_spaces =
799      runtime->GetHeap()->GetBootImageSpaces();
800  if (image_spaces.empty()) {
801    return "";
802  }
803  return image_spaces[0]->GetImageLocation();
804}
805
806const uint32_t* OatFileAssistant::GetRequiredDexChecksum() {
807  if (!required_dex_checksum_attempted_) {
808    required_dex_checksum_attempted_ = true;
809    required_dex_checksum_found_ = false;
810    std::string error_msg;
811    if (DexFile::GetChecksum(dex_location_.c_str(), &cached_required_dex_checksum_, &error_msg)) {
812      required_dex_checksum_found_ = true;
813      has_original_dex_files_ = true;
814    } else {
815      // This can happen if the original dex file has been stripped from the
816      // apk.
817      VLOG(oat) << "OatFileAssistant: " << error_msg;
818      has_original_dex_files_ = false;
819
820      // Get the checksum from the odex if we can.
821      const OatFile* odex_file = GetOdexFile();
822      if (odex_file != nullptr) {
823        const OatFile::OatDexFile* odex_dex_file = odex_file->GetOatDexFile(
824            dex_location_.c_str(), nullptr, false);
825        if (odex_dex_file != nullptr) {
826          cached_required_dex_checksum_ = odex_dex_file->GetDexFileLocationChecksum();
827          required_dex_checksum_found_ = true;
828        }
829      }
830    }
831  }
832  return required_dex_checksum_found_ ? &cached_required_dex_checksum_ : nullptr;
833}
834
835const OatFile* OatFileAssistant::GetOdexFile() {
836  CHECK(!oat_file_released_) << "OdexFile called after oat file released.";
837  if (!odex_file_load_attempted_) {
838    odex_file_load_attempted_ = true;
839    if (OdexFileName() != nullptr) {
840      const std::string& odex_file_name = *OdexFileName();
841      std::string error_msg;
842      cached_odex_file_.reset(OatFile::Open(odex_file_name.c_str(),
843                                            odex_file_name.c_str(),
844                                            nullptr,
845                                            nullptr,
846                                            load_executable_,
847                                            /*low_4gb*/false,
848                                            dex_location_.c_str(),
849                                            &error_msg));
850      if (cached_odex_file_.get() == nullptr) {
851        VLOG(oat) << "OatFileAssistant test for existing pre-compiled oat file "
852          << odex_file_name << ": " << error_msg;
853      }
854    }
855  }
856  return cached_odex_file_.get();
857}
858
859bool OatFileAssistant::OdexFileIsExecutable() {
860  const OatFile* odex_file = GetOdexFile();
861  return (odex_file != nullptr && odex_file->IsExecutable());
862}
863
864bool OatFileAssistant::OdexFileHasPatchInfo() {
865  const OatFile* odex_file = GetOdexFile();
866  return (odex_file != nullptr && odex_file->HasPatchInfo());
867}
868
869void OatFileAssistant::ClearOdexFileCache() {
870  odex_file_load_attempted_ = false;
871  cached_odex_file_.reset();
872  odex_file_is_out_of_date_attempted_ = false;
873  odex_file_is_up_to_date_attempted_ = false;
874}
875
876const OatFile* OatFileAssistant::GetOatFile() {
877  CHECK(!oat_file_released_) << "OatFile called after oat file released.";
878  if (!oat_file_load_attempted_) {
879    oat_file_load_attempted_ = true;
880    if (OatFileName() != nullptr) {
881      const std::string& oat_file_name = *OatFileName();
882      std::string error_msg;
883      cached_oat_file_.reset(OatFile::Open(oat_file_name.c_str(),
884                                           oat_file_name.c_str(),
885                                           nullptr,
886                                           nullptr,
887                                           load_executable_,
888                                           /*low_4gb*/false,
889                                           dex_location_.c_str(),
890                                           &error_msg));
891      if (cached_oat_file_.get() == nullptr) {
892        VLOG(oat) << "OatFileAssistant test for existing oat file "
893          << oat_file_name << ": " << error_msg;
894      }
895    }
896  }
897  return cached_oat_file_.get();
898}
899
900bool OatFileAssistant::OatFileIsExecutable() {
901  const OatFile* oat_file = GetOatFile();
902  return (oat_file != nullptr && oat_file->IsExecutable());
903}
904
905bool OatFileAssistant::OatFileHasPatchInfo() {
906  const OatFile* oat_file = GetOatFile();
907  return (oat_file != nullptr && oat_file->HasPatchInfo());
908}
909
910void OatFileAssistant::ClearOatFileCache() {
911  oat_file_load_attempted_ = false;
912  cached_oat_file_.reset();
913  oat_file_is_out_of_date_attempted_ = false;
914  oat_file_is_up_to_date_attempted_ = false;
915}
916
917const OatFileAssistant::ImageInfo* OatFileAssistant::GetImageInfo() {
918  if (!image_info_load_attempted_) {
919    image_info_load_attempted_ = true;
920
921    Runtime* runtime = Runtime::Current();
922    std::vector<gc::space::ImageSpace*> image_spaces = runtime->GetHeap()->GetBootImageSpaces();
923    if (!image_spaces.empty()) {
924      cached_image_info_.location = image_spaces[0]->GetImageLocation();
925
926      if (isa_ == kRuntimeISA) {
927        const ImageHeader& image_header = image_spaces[0]->GetImageHeader();
928        cached_image_info_.oat_checksum = image_header.GetOatChecksum();
929        cached_image_info_.oat_data_begin = reinterpret_cast<uintptr_t>(
930            image_header.GetOatDataBegin());
931        cached_image_info_.patch_delta = image_header.GetPatchDelta();
932      } else {
933        std::unique_ptr<ImageHeader> image_header(
934            gc::space::ImageSpace::ReadImageHeaderOrDie(cached_image_info_.location.c_str(), isa_));
935        cached_image_info_.oat_checksum = image_header->GetOatChecksum();
936        cached_image_info_.oat_data_begin = reinterpret_cast<uintptr_t>(
937            image_header->GetOatDataBegin());
938        cached_image_info_.patch_delta = image_header->GetPatchDelta();
939      }
940    }
941    image_info_load_succeeded_ = (!image_spaces.empty());
942
943    combined_image_checksum_ = CalculateCombinedImageChecksum(isa_);
944  }
945  return image_info_load_succeeded_ ? &cached_image_info_ : nullptr;
946}
947
948// TODO: Use something better than xor.
949uint32_t OatFileAssistant::CalculateCombinedImageChecksum(InstructionSet isa) {
950  uint32_t checksum = 0;
951  std::vector<gc::space::ImageSpace*> image_spaces =
952      Runtime::Current()->GetHeap()->GetBootImageSpaces();
953  if (isa == kRuntimeISA) {
954    for (gc::space::ImageSpace* image_space : image_spaces) {
955      checksum ^= image_space->GetImageHeader().GetOatChecksum();
956    }
957  } else {
958    for (gc::space::ImageSpace* image_space : image_spaces) {
959      std::string location = image_space->GetImageLocation();
960      std::unique_ptr<ImageHeader> image_header(
961          gc::space::ImageSpace::ReadImageHeaderOrDie(location.c_str(), isa));
962      checksum ^= image_header->GetOatChecksum();
963    }
964  }
965  return checksum;
966}
967
968uint32_t OatFileAssistant::GetCombinedImageChecksum() {
969  if (!image_info_load_attempted_) {
970    GetImageInfo();
971  }
972  return combined_image_checksum_;
973}
974
975gc::space::ImageSpace* OatFileAssistant::OpenImageSpace(const OatFile* oat_file) {
976  DCHECK(oat_file != nullptr);
977  std::string art_file = ArtFileName(oat_file);
978  if (art_file.empty()) {
979    return nullptr;
980  }
981  std::string error_msg;
982  ScopedObjectAccess soa(Thread::Current());
983  gc::space::ImageSpace* ret = gc::space::ImageSpace::CreateFromAppImage(art_file.c_str(),
984                                                                         oat_file,
985                                                                         &error_msg);
986  if (ret == nullptr && (VLOG_IS_ON(image) || OS::FileExists(art_file.c_str()))) {
987    LOG(INFO) << "Failed to open app image " << art_file.c_str() << " " << error_msg;
988  }
989  return ret;
990}
991
992}  // namespace art
993
994