blob: 7b45bca94676727329703f5e27139b396bd22244 [file] [log] [blame]
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_RUNTIME_OAT_FILE_ASSISTANT_H_
#define ART_RUNTIME_OAT_FILE_ASSISTANT_H_
#include <cstdint>
#include <memory>
#include <string>
#include "arch/instruction_set.h"
#include "base/scoped_flock.h"
#include "base/unix_file/fd_file.h"
#include "oat_file.h"
#include "os.h"
#include "profiler.h"
namespace art {
namespace gc {
namespace space {
class ImageSpace;
} // namespace space
} // namespace gc
// Class for assisting with oat file management.
//
// This class collects common utilities for determining the status of an oat
// file on the device, updating the oat file, and loading the oat file.
//
// The oat file assistant is intended to be used with dex locations not on the
// boot class path. See the IsInBootClassPath method for a way to check if the
// dex location is in the boot class path.
//
// TODO: All the profiling related code is old and untested. It should either
// be restored and tested, or removed.
class OatFileAssistant {
public:
enum DexOptNeeded {
// kNoDexOptNeeded - The code for this dex location is up to date and can
// be used as is.
// Matches Java: dalvik.system.DexFile.NO_DEXOPT_NEEDED = 0
kNoDexOptNeeded = 0,
// kDex2OatNeeded - In order to make the code for this dex location up to
// date, dex2oat must be run on the dex file.
// Matches Java: dalvik.system.DexFile.DEX2OAT_NEEDED = 1
kDex2OatNeeded = 1,
// kPatchOatNeeded - In order to make the code for this dex location up to
// date, patchoat must be run on the odex file.
// Matches Java: dalvik.system.DexFile.PATCHOAT_NEEDED = 2
kPatchOatNeeded = 2,
// kSelfPatchOatNeeded - In order to make the code for this dex location
// up to date, patchoat must be run on the oat file.
// Matches Java: dalvik.system.DexFile.SELF_PATCHOAT_NEEDED = 3
kSelfPatchOatNeeded = 3,
};
enum OatStatus {
// kOatOutOfDate - An oat file is said to be out of date if the file does
// not exist, or is out of date with respect to the dex file or boot
// image.
kOatOutOfDate,
// kOatNeedsRelocation - An oat file is said to need relocation if the
// code is up to date, but not yet properly relocated for address space
// layout randomization (ASLR). In this case, the oat file is neither
// "out of date" nor "up to date".
kOatNeedsRelocation,
// kOatUpToDate - An oat file is said to be up to date if it is not out of
// date and has been properly relocated for the purposes of ASLR.
kOatUpToDate,
};
// Constructs an OatFileAssistant object to assist the oat file
// corresponding to the given dex location with the target instruction set.
//
// The dex_location must not be null and should remain available and
// unchanged for the duration of the lifetime of the OatFileAssistant object.
// Typically the dex_location is the absolute path to the original,
// un-optimized dex file.
//
// Note: Currently the dex_location must have an extension.
// TODO: Relax this restriction?
//
// The isa should be either the 32 bit or 64 bit variant for the current
// device. For example, on an arm device, use arm or arm64. An oat file can
// be loaded executable only if the ISA matches the current runtime.
OatFileAssistant(const char* dex_location, const InstructionSet isa,
bool load_executable);
// Constructs an OatFileAssistant, providing an explicit target oat_location
// to use instead of the standard oat location.
OatFileAssistant(const char* dex_location, const char* oat_location,
const InstructionSet isa, bool load_executable);
// Constructs an OatFileAssistant, providing an additional package_name used
// solely for the purpose of locating profile files.
//
// TODO: Why is the name of the profile file based on the package name and
// not the dex location? If there is no technical reason the dex_location
// can't be used, we should prefer that instead.
OatFileAssistant(const char* dex_location, const InstructionSet isa,
bool load_executable, const char* package_name);
// Constructs an OatFileAssistant with user specified oat location and a
// package name.
OatFileAssistant(const char* dex_location, const char* oat_location,
const InstructionSet isa, bool load_executable,
const char* package_name);
~OatFileAssistant();
// Returns true if the dex location refers to an element of the boot class
// path.
bool IsInBootClassPath();
// Obtains a lock on the target oat file.
// Only one OatFileAssistant object can hold the lock for a target oat file
// at a time. The Lock is released automatically when the OatFileAssistant
// object goes out of scope. The Lock() method must not be called if the
// lock has already been acquired.
//
// Returns true on success.
// Returns false on error, in which case error_msg will contain more
// information on the error.
//
// The 'error_msg' argument must not be null.
//
// This is intended to be used to avoid race conditions when multiple
// processes generate oat files, such as when a foreground Activity and
// a background Service both use DexClassLoaders pointing to the same dex
// file.
bool Lock(std::string* error_msg);
// Return what action needs to be taken to produce up-to-date code for this
// dex location.
DexOptNeeded GetDexOptNeeded();
// Attempts to generate or relocate the oat file as needed to make it up to
// date.
// Returns true on success.
//
// If there is a failure, the value of error_msg will be set to a string
// describing why there was failure. error_msg must not be null.
bool MakeUpToDate(std::string* error_msg);
// Returns an oat file that can be used for loading dex files.
// Returns null if no suitable oat file was found.
//
// After this call, no other methods of the OatFileAssistant should be
// called, because access to the loaded oat file has been taken away from
// the OatFileAssistant object.
std::unique_ptr<OatFile> GetBestOatFile();
// Open and returns an image space associated with the oat file.
gc::space::ImageSpace* OpenImageSpace(const OatFile* oat_file);
// Loads the dex files in the given oat file for the given dex location.
// The oat file should be up to date for the given dex location.
// This loads multiple dex files in the case of multidex.
// Returns an empty vector if no dex files for that location could be loaded
// from the oat file.
//
// The caller is responsible for freeing the dex_files returned, if any. The
// dex_files will only remain valid as long as the oat_file is valid.
static std::vector<std::unique_ptr<const DexFile>> LoadDexFiles(
const OatFile& oat_file, const char* dex_location);
// Returns true if there are dex files in the original dex location that can
// be compiled with dex2oat for this dex location.
// Returns false if there is no original dex file, or if the original dex
// file is an apk/zip without a classes.dex entry.
bool HasOriginalDexFiles();
// If the dex file has been installed with a compiled oat file alongside
// it, the compiled oat file will have the extension .odex, and is referred
// to as the odex file. It is called odex for legacy reasons; the file is
// really an oat file. The odex file will often, but not always, have a
// patch delta of 0 and need to be relocated before use for the purposes of
// ASLR. The odex file is treated as if it were read-only.
// These methods return the location and status of the odex file for the dex
// location.
// Notes:
// * OdexFileName may return null if the odex file name could not be
// determined.
const std::string* OdexFileName();
bool OdexFileExists();
OatStatus OdexFileStatus();
bool OdexFileIsOutOfDate();
bool OdexFileNeedsRelocation();
bool OdexFileIsUpToDate();
// When the dex files is compiled on the target device, the oat file is the
// result. The oat file will have been relocated to some
// (possibly-out-of-date) offset for ASLR.
// These methods return the location and status of the target oat file for
// the dex location.
//
// Notes:
// * OatFileName may return null if the oat file name could not be
// determined.
const std::string* OatFileName();
bool OatFileExists();
OatStatus OatFileStatus();
bool OatFileIsOutOfDate();
bool OatFileNeedsRelocation();
bool OatFileIsUpToDate();
// Return image file name. Does not cache since it relies on the oat file.
std::string ArtFileName(const OatFile* oat_file) const;
// These methods return the status for a given opened oat file with respect
// to the dex location.
OatStatus GivenOatFileStatus(const OatFile& file);
bool GivenOatFileIsOutOfDate(const OatFile& file);
bool GivenOatFileNeedsRelocation(const OatFile& file);
bool GivenOatFileIsUpToDate(const OatFile& file);
// Returns true if there is an accessible profile associated with the dex
// location.
// This returns false if profiling is disabled.
bool ProfileExists();
// The old profile is a file containing a previous snapshot of profiling
// information associated with the dex file code. This is used to track how
// the profiling information has changed over time.
//
// Returns true if there is an accessible old profile associated with the
// dex location.
// This returns false if profiling is disabled.
bool OldProfileExists();
// Returns true if there has been a significant change between the old
// profile and the current profile.
// This returns false if profiling is disabled.
bool IsProfileChangeSignificant();
// Copy the current profile to the old profile location.
void CopyProfileFile();
// Generates the oat file by relocation from the named input file.
// This does not check the current status before attempting to relocate the
// oat file.
// Returns true on success.
// This will fail if dex2oat is not enabled in the current runtime.
//
// If there is a failure, the value of error_msg will be set to a string
// describing why there was failure. error_msg must not be null.
bool RelocateOatFile(const std::string* input_file, std::string* error_msg);
// Generate the oat file from the dex file.
// This does not check the current status before attempting to generate the
// oat file.
// Returns true on success.
// This will fail if dex2oat is not enabled in the current runtime.
//
// If there is a failure, the value of error_msg will be set to a string
// describing why there was failure. error_msg must not be null.
bool GenerateOatFile(std::string* error_msg);
// Executes dex2oat using the current runtime configuration overridden with
// the given arguments. This does not check to see if dex2oat is enabled in
// the runtime configuration.
// Returns true on success.
//
// If there is a failure, the value of error_msg will be set to a string
// describing why there was failure. error_msg must not be null.
//
// TODO: The OatFileAssistant probably isn't the right place to have this
// function.
static bool Dex2Oat(const std::vector<std::string>& args, std::string* error_msg);
// Constructs the odex file name for the given dex location.
// Returns true on success, in which case odex_filename is set to the odex
// file name.
// Returns false on error, in which case error_msg describes the error.
// Neither odex_filename nor error_msg may be null.
static bool DexFilenameToOdexFilename(const std::string& location,
InstructionSet isa, std::string* odex_filename, std::string* error_msg);
private:
struct ImageInfo {
uint32_t oat_checksum = 0;
uintptr_t oat_data_begin = 0;
int32_t patch_delta = 0;
std::string location;
};
// Returns the path to the dalvik cache directory.
// Does not check existence of the cache or try to create it.
// Includes the trailing slash.
// Returns an empty string if we can't get the dalvik cache directory path.
std::string DalvikCacheDirectory();
// Constructs the filename for the profile file.
// Returns an empty string if we do not have the necessary information to
// construct the filename.
std::string ProfileFileName();
// Constructs the filename for the old profile file.
// Returns an empty string if we do not have the necessary information to
// construct the filename.
std::string OldProfileFileName();
// Returns the current image location.
// Returns an empty string if the image location could not be retrieved.
//
// TODO: This method should belong with an image file manager, not
// the oat file assistant.
static std::string ImageLocation();
// Gets the dex checksum required for an up-to-date oat file.
// Returns dex_checksum if a required checksum was located. Returns
// null if the required checksum was not found.
// The caller shouldn't clean up or free the returned pointer.
// This sets the has_original_dex_files_ field to true if a checksum was
// found for the dex_location_ dex file.
const uint32_t* GetRequiredDexChecksum();
// Returns the loaded odex file.
// Loads the file if needed. Returns null if the file failed to load.
// The caller shouldn't clean up or free the returned pointer.
const OatFile* GetOdexFile();
// Returns true if the odex file is opened executable.
bool OdexFileIsExecutable();
// Clear any cached information about the odex file that depends on the
// contents of the file.
void ClearOdexFileCache();
// Returns the loaded oat file.
// Loads the file if needed. Returns null if the file failed to load.
// The caller shouldn't clean up or free the returned pointer.
const OatFile* GetOatFile();
// Returns true if the oat file is opened executable.
bool OatFileIsExecutable();
// Clear any cached information about the oat file that depends on the
// contents of the file.
void ClearOatFileCache();
// Returns the loaded image info.
// Loads the image info if needed. Returns null if the image info failed
// to load.
// The caller shouldn't clean up or free the returned pointer.
const ImageInfo* GetImageInfo();
// Returns the loaded profile.
// Loads the profile if needed. Returns null if the profile failed
// to load.
// The caller shouldn't clean up or free the returned pointer.
ProfileFile* GetProfile();
// Returns the loaded old profile.
// Loads the old profile if needed. Returns null if the old profile
// failed to load.
// The caller shouldn't clean up or free the returned pointer.
ProfileFile* GetOldProfile();
// To implement Lock(), we lock a dummy file where the oat file would go
// (adding ".flock" to the target file name) and retain the lock for the
// remaining lifetime of the OatFileAssistant object.
ScopedFlock flock_;
std::string dex_location_;
// In a properly constructed OatFileAssistant object, isa_ should be either
// the 32 or 64 bit variant for the current device.
const InstructionSet isa_ = kNone;
// The package name, used solely to find the profile file.
// This may be null in a properly constructed object. In this case,
// profile_load_attempted_ and old_profile_load_attempted_ will be true, and
// profile_load_succeeded_ and old_profile_load_succeeded_ will be false.
const char* package_name_ = nullptr;
// Whether we will attempt to load oat files executable.
bool load_executable_ = false;
// Cached value of the required dex checksum.
// This should be accessed only by the GetRequiredDexChecksum() method.
uint32_t cached_required_dex_checksum_;
bool required_dex_checksum_attempted_ = false;
bool required_dex_checksum_found_;
bool has_original_dex_files_;
// Cached value of the odex file name.
// This should be accessed only by the OdexFileName() method.
bool cached_odex_file_name_attempted_ = false;
bool cached_odex_file_name_found_;
std::string cached_odex_file_name_;
// Cached value of the loaded odex file.
// Use the GetOdexFile method rather than accessing this directly, unless you
// know the odex file isn't out of date.
bool odex_file_load_attempted_ = false;
std::unique_ptr<OatFile> cached_odex_file_;
// Cached results for OdexFileIsOutOfDate
bool odex_file_is_out_of_date_attempted_ = false;
bool cached_odex_file_is_out_of_date_;
// Cached results for OdexFileIsUpToDate
bool odex_file_is_up_to_date_attempted_ = false;
bool cached_odex_file_is_up_to_date_;
// Cached value of the oat file name.
// This should be accessed only by the OatFileName() method.
bool cached_oat_file_name_attempted_ = false;
bool cached_oat_file_name_found_;
std::string cached_oat_file_name_;
// Cached value of the loaded oat file.
// Use the GetOatFile method rather than accessing this directly, unless you
// know the oat file isn't out of date.
bool oat_file_load_attempted_ = false;
std::unique_ptr<OatFile> cached_oat_file_;
// Cached results for OatFileIsOutOfDate
bool oat_file_is_out_of_date_attempted_ = false;
bool cached_oat_file_is_out_of_date_;
// Cached results for OatFileIsUpToDate
bool oat_file_is_up_to_date_attempted_ = false;
bool cached_oat_file_is_up_to_date_;
// Cached value of the image info.
// Use the GetImageInfo method rather than accessing these directly.
// TODO: The image info should probably be moved out of the oat file
// assistant to an image file manager.
bool image_info_load_attempted_ = false;
bool image_info_load_succeeded_ = false;
ImageInfo cached_image_info_;
// Cached value of the profile file.
// Use the GetProfile method rather than accessing these directly.
bool profile_load_attempted_ = false;
bool profile_load_succeeded_ = false;
ProfileFile cached_profile_;
// Cached value of the profile file.
// Use the GetOldProfile method rather than accessing these directly.
bool old_profile_load_attempted_ = false;
bool old_profile_load_succeeded_ = false;
ProfileFile cached_old_profile_;
// For debugging only.
// If this flag is set, the oat or odex file has been released to the user
// of the OatFileAssistant object and the OatFileAssistant object is in a
// bad state and should no longer be used.
bool oat_file_released_ = false;
DISALLOW_COPY_AND_ASSIGN(OatFileAssistant);
};
} // namespace art
#endif // ART_RUNTIME_OAT_FILE_ASSISTANT_H_