You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
384 lines
18 KiB
384 lines
18 KiB
/*
|
|
* Copyright (C) 2017 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_CLASS_LOADER_CONTEXT_H_
|
|
#define ART_RUNTIME_CLASS_LOADER_CONTEXT_H_
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <set>
|
|
|
|
#include "arch/instruction_set.h"
|
|
#include "base/dchecked_vector.h"
|
|
#include "dex/dex_file.h"
|
|
#include "handle_scope.h"
|
|
#include "mirror/class_loader.h"
|
|
#include "oat_file.h"
|
|
#include "scoped_thread_state_change.h"
|
|
|
|
namespace art {
|
|
|
|
class DexFile;
|
|
class OatFile;
|
|
|
|
// Utility class which holds the class loader context used during compilation/verification.
|
|
class ClassLoaderContext {
|
|
public:
|
|
enum class VerificationResult {
|
|
kVerifies,
|
|
kMismatch,
|
|
};
|
|
|
|
enum ClassLoaderType {
|
|
kInvalidClassLoader = 0,
|
|
kPathClassLoader = 1,
|
|
kDelegateLastClassLoader = 2,
|
|
kInMemoryDexClassLoader = 3
|
|
};
|
|
|
|
// Special encoding used to denote a foreign ClassLoader was found when trying to encode class
|
|
// loader contexts for each classpath element in a ClassLoader. See
|
|
// EncodeClassPathContextsForClassLoader. Keep in sync with PackageDexUsage in the framework.
|
|
static constexpr const char* kUnsupportedClassLoaderContextEncoding =
|
|
"=UnsupportedClassLoaderContext=";
|
|
|
|
~ClassLoaderContext();
|
|
|
|
// Opens requested class path files and appends them to ClassLoaderInfo::opened_dex_files.
|
|
// If the dex files have been stripped, the method opens them from their oat files which are added
|
|
// to ClassLoaderInfo::opened_oat_files. The 'classpath_dir' argument specifies the directory to
|
|
// use for the relative class paths.
|
|
// Returns true if all dex files where successfully opened.
|
|
// It may be called only once per ClassLoaderContext. Subsequent calls will return the same
|
|
// result without doing anything.
|
|
// If `context_fds` is an empty vector, files will be opened using the class path locations as
|
|
// filenames. Otherwise `context_fds` is expected to contain file descriptors to class path dex
|
|
// files, following the order of dex file locations in a flattened class loader context. If their
|
|
// number (size of `context_fds`) does not match the number of dex files, OpenDexFiles will fail.
|
|
//
|
|
// This will replace the class path locations with the locations of the opened dex files.
|
|
// (Note that one dex file can contain multidexes. Each multidex will be added to the classpath
|
|
// separately.)
|
|
//
|
|
// only_read_checksums controls whether or not we only read the dex locations and the checksums
|
|
// from the apk instead of fully opening the dex files.
|
|
//
|
|
// This method is not thread safe.
|
|
//
|
|
// Note that a "false" return could mean that either an apk/jar contained no dex files or
|
|
// that we hit a I/O or checksum mismatch error.
|
|
// TODO(calin): Currently there's no easy way to tell the difference.
|
|
//
|
|
// TODO(calin): we're forced to complicate the flow in this class with a different
|
|
// OpenDexFiles step because the current dex2oat flow requires the dex files be opened before
|
|
// the class loader is created. Consider reworking the dex2oat part.
|
|
bool OpenDexFiles(const std::string& classpath_dir = "",
|
|
const std::vector<int>& context_fds = std::vector<int>(),
|
|
bool only_read_checksums = false);
|
|
|
|
// Remove the specified compilation sources from all classpaths present in this context.
|
|
// Should only be called before the first call to OpenDexFiles().
|
|
bool RemoveLocationsFromClassPaths(const dchecked_vector<std::string>& compilation_sources);
|
|
|
|
// Creates the entire class loader hierarchy according to the current context.
|
|
// Returns the first class loader from the chain.
|
|
//
|
|
// For example: if the context was built from the spec
|
|
// "ClassLoaderType1[ClasspathElem1:ClasspathElem2...];ClassLoaderType2[...]..."
|
|
// the method returns the class loader correponding to ClassLoader1. The parent chain will be
|
|
// ClassLoader1 --> ClassLoader2 --> ... --> BootClassLoader.
|
|
//
|
|
// The compilation sources are appended to the classpath of the first class loader (in the above
|
|
// example ClassLoader1).
|
|
//
|
|
// If the context is empty, this method only creates a single PathClassLoader with the
|
|
// given compilation_sources.
|
|
//
|
|
// Shared libraries found in the chain will be canonicalized based on the dex files they
|
|
// contain.
|
|
//
|
|
// Implementation notes:
|
|
// 1) the objects are not completely set up. Do not use this outside of tests and the compiler.
|
|
// 2) should only be called before the first call to OpenDexFiles().
|
|
jobject CreateClassLoader(const std::vector<const DexFile*>& compilation_sources) const;
|
|
|
|
// Encodes the context as a string suitable to be added in oat files.
|
|
// (so that it can be read and verified at runtime against the actual class
|
|
// loader hierarchy).
|
|
// Should only be called if OpenDexFiles() returned true.
|
|
// If stored context is non-null, the stored names are overwritten by the class path from the
|
|
// stored context.
|
|
// E.g. if the context is PCL[a.dex:b.dex] this will return
|
|
// "PCL[a.dex*a_checksum*b.dex*a_checksum]".
|
|
std::string EncodeContextForOatFile(const std::string& base_dir,
|
|
ClassLoaderContext* stored_context = nullptr) const;
|
|
|
|
// Encodes the context as a string suitable to be passed to dex2oat.
|
|
// This is the same as EncodeContextForOatFile but without adding the checksums
|
|
// and only adding each dex files once (no multidex).
|
|
// Should only be called if OpenDexFiles() returned true.
|
|
std::string EncodeContextForDex2oat(const std::string& base_dir) const;
|
|
|
|
// Encodes the contexts for each of the classpath elements in the child-most
|
|
// classloader. Under the hood EncodeContextForDex2oat is used, so no checksums
|
|
// will be encoded.
|
|
// Should only be called if the dex files are opened (either via OpenDexFiles() or by creating the
|
|
// context from a live class loader).
|
|
// Notably, for each classpath element the encoded classloader context will contain only the
|
|
// elements that appear before it in the containing classloader. E.g. if `this` contains
|
|
// (from child to parent):
|
|
//
|
|
// PathClassLoader { multidex.apk!classes.dex, multidex.apk!classes2.dex, foo.dex, bar.dex } ->
|
|
// PathClassLoader { baz.dex } -> BootClassLoader
|
|
//
|
|
// then the return value will look like:
|
|
//
|
|
// `{ "multidex.apk": "PCL[];PCL[baz.dex]",
|
|
// "foo.dex" : "PCL[multidex.apk];PCL[baz.dex]",
|
|
// "bar.dex" : "PCL[multidex.apk:foo.dex];PCL[baz.dex]" }`
|
|
std::map<std::string, std::string> EncodeClassPathContexts(const std::string& base_dir) const;
|
|
|
|
// Flattens the opened dex files into the given vector.
|
|
// Should only be called if OpenDexFiles() returned true.
|
|
std::vector<const DexFile*> FlattenOpenedDexFiles() const;
|
|
|
|
// Return a colon-separated list of dex file locations from this class loader
|
|
// context after flattening.
|
|
std::string FlattenDexPaths() const;
|
|
|
|
// Verifies that the current context is identical to the context encoded as `context_spec`.
|
|
// Identical means:
|
|
// - the number and type of the class loaders from the chain matches
|
|
// - the class loader from the same position have the same classpath
|
|
// (the order and checksum of the dex files matches)
|
|
// This should be called after OpenDexFiles() with only_read_checksums=true. There's no
|
|
// need to fully open the dex files if the only thing that needs to be done is to verify
|
|
// the context.
|
|
//
|
|
// Names are only verified if verify_names is true.
|
|
// Checksums are only verified if verify_checksums is true.
|
|
VerificationResult VerifyClassLoaderContextMatch(const std::string& context_spec,
|
|
bool verify_names = true,
|
|
bool verify_checksums = true) const;
|
|
|
|
// Checks if any of the given dex files is already loaded in the current class loader context.
|
|
// It only checks the first class loader.
|
|
// Returns the list of duplicate dex files (empty if there are no duplicates).
|
|
std::set<const DexFile*> CheckForDuplicateDexFiles(
|
|
const std::vector<const DexFile*>& dex_files);
|
|
|
|
// Creates the class loader context from the given string.
|
|
// The format: ClassLoaderType1[ClasspathElem1:ClasspathElem2...];ClassLoaderType2[...]...
|
|
// ClassLoaderType is either "PCL" (PathClassLoader) or "DLC" (DelegateLastClassLoader).
|
|
// ClasspathElem is the path of dex/jar/apk file.
|
|
//
|
|
// The spec represents a class loader chain with the natural interpretation:
|
|
// ClassLoader1 has ClassLoader2 as parent which has ClassLoader3 as a parent and so on.
|
|
// The last class loader is assumed to have the BootClassLoader as a parent.
|
|
//
|
|
// Note that we allowed class loaders with an empty class path in order to support a custom
|
|
// class loader for the source dex files.
|
|
static std::unique_ptr<ClassLoaderContext> Create(const std::string& spec);
|
|
|
|
// Creates a context for the given class_loader and dex_elements.
|
|
// The method will walk the parent chain starting from `class_loader` and add their dex files
|
|
// to the current class loaders chain. The `dex_elements` will be added at the end of the
|
|
// classpath belonging to the `class_loader` argument.
|
|
// The ownership of the opened dex files will be retained by the given `class_loader`.
|
|
// If there are errors in processing the class loader chain (e.g. unsupported elements) the
|
|
// method returns null.
|
|
static std::unique_ptr<ClassLoaderContext> CreateContextForClassLoader(jobject class_loader,
|
|
jobjectArray dex_elements);
|
|
|
|
// Returns the default class loader context to be used when none is specified.
|
|
// This will return a context with a single and empty PathClassLoader.
|
|
static std::unique_ptr<ClassLoaderContext> Default();
|
|
|
|
// Encodes the contexts for each of the classpath elements in `class_loader`. See
|
|
// ClassLoaderContext::EncodeClassPathContexts for more information about the return value.
|
|
//
|
|
// If `class_loader` does not derive from BaseDexClassLoader then an empty map is returned.
|
|
// Otherwise if a foreign ClassLoader is found in the class loader chain then the results values
|
|
// will all be ClassLoaderContext::kUnsupportedClassLoaderContextEncoding.
|
|
static std::map<std::string, std::string> EncodeClassPathContextsForClassLoader(
|
|
jobject class_loader);
|
|
|
|
// Returns whether `encoded_class_loader_context` is a valid encoded ClassLoaderContext or
|
|
// EncodedUnsupportedClassLoaderContext.
|
|
static bool IsValidEncoding(const std::string& possible_encoded_class_loader_context);
|
|
|
|
struct ClassLoaderInfo {
|
|
// The type of this class loader.
|
|
ClassLoaderType type;
|
|
// Shared libraries this context has.
|
|
std::vector<std::unique_ptr<ClassLoaderInfo>> shared_libraries;
|
|
// The list of class path elements that this loader loads.
|
|
// Note that this list may contain relative paths.
|
|
std::vector<std::string> classpath;
|
|
// Original opened class path (ignoring multidex).
|
|
std::vector<std::string> original_classpath;
|
|
// The list of class path elements checksums.
|
|
// May be empty if the checksums are not given when the context is created.
|
|
std::vector<uint32_t> checksums;
|
|
// After OpenDexFiles is called this holds the opened dex files.
|
|
std::vector<std::unique_ptr<const DexFile>> opened_dex_files;
|
|
// After OpenDexFiles, in case some of the dex files were opened from their oat files
|
|
// this holds the list of opened oat files.
|
|
std::vector<std::unique_ptr<OatFile>> opened_oat_files;
|
|
// The parent class loader.
|
|
std::unique_ptr<ClassLoaderInfo> parent;
|
|
|
|
explicit ClassLoaderInfo(ClassLoaderType cl_type) : type(cl_type) {}
|
|
};
|
|
|
|
private:
|
|
// Creates an empty context (with no class loaders).
|
|
ClassLoaderContext();
|
|
|
|
// Get the parent of the class loader chain at depth `index`.
|
|
ClassLoaderInfo* GetParent(size_t index) const {
|
|
ClassLoaderInfo* result = class_loader_chain_.get();
|
|
while ((result != nullptr) && (index-- != 0)) {
|
|
result = result->parent.get();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
size_t GetParentChainSize() const {
|
|
size_t result = 0;
|
|
ClassLoaderInfo* info = class_loader_chain_.get();
|
|
while (info != nullptr) {
|
|
++result;
|
|
info = info->parent.get();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Constructs an empty context.
|
|
// `owns_the_dex_files` specifies whether or not the context will own the opened dex files
|
|
// present in the class loader chain. If `owns_the_dex_files` is true then OpenDexFiles cannot
|
|
// be called on this context (dex_files_open_attempted_ and dex_files_open_result_ will be set
|
|
// to true as well)
|
|
explicit ClassLoaderContext(bool owns_the_dex_files);
|
|
|
|
// Reads the class loader spec in place and returns true if the spec is valid and the
|
|
// compilation context was constructed.
|
|
bool Parse(const std::string& spec, bool parse_checksums = false);
|
|
ClassLoaderInfo* ParseInternal(const std::string& spec, bool parse_checksums);
|
|
|
|
// Attempts to parse a single class loader spec.
|
|
// Returns the ClassLoaderInfo abstraction for this spec, or null if it cannot be parsed.
|
|
std::unique_ptr<ClassLoaderInfo> ParseClassLoaderSpec(
|
|
const std::string& class_loader_spec,
|
|
bool parse_checksums = false);
|
|
|
|
// CHECKs that the dex files were opened (OpenDexFiles was called and set dex_files_open_result_
|
|
// to true). Aborts if not. The `calling_method` is used in the log message to identify the source
|
|
// of the call.
|
|
void CheckDexFilesOpened(const std::string& calling_method) const;
|
|
|
|
// Creates the `ClassLoaderInfo` representing`class_loader` and attach it to `this`.
|
|
// The dex file present in `dex_elements` array (if not null) will be added at the end of
|
|
// the classpath.
|
|
bool CreateInfoFromClassLoader(ScopedObjectAccessAlreadyRunnable& soa,
|
|
Handle<mirror::ClassLoader> class_loader,
|
|
Handle<mirror::ObjectArray<mirror::Object>> dex_elements,
|
|
ClassLoaderInfo* child_info,
|
|
bool is_shared_library)
|
|
REQUIRES_SHARED(Locks::mutator_lock_);
|
|
|
|
// Encodes the context as a string suitable to be passed to dex2oat or to be added to the
|
|
// oat file as the class path key.
|
|
// If for_dex2oat is true, the encoding adds each file once (i.e. it does not add multidex
|
|
// location). Otherwise, for oat files, the encoding adds all the dex files (including multidex)
|
|
// together with their checksums.
|
|
// Should only be called if OpenDexFiles() returned true.
|
|
std::string EncodeContext(const std::string& base_dir,
|
|
bool for_dex2oat,
|
|
ClassLoaderContext* stored_context) const;
|
|
|
|
// Internal version of `EncodeContext`, which will be called recursively
|
|
// on the parent and shared libraries.
|
|
void EncodeContextInternal(const ClassLoaderInfo& info,
|
|
const std::string& base_dir,
|
|
bool for_dex2oat,
|
|
ClassLoaderInfo* stored_info,
|
|
std::ostringstream& out) const;
|
|
|
|
// Encodes e.g. PCL[foo.dex:bar.dex]
|
|
void EncodeClassPath(const std::string& base_dir,
|
|
const std::vector<std::string>& dex_locations,
|
|
const std::vector<uint32_t>& checksums,
|
|
ClassLoaderType type,
|
|
std::ostringstream& out) const;
|
|
|
|
// Encodes the shared libraries classloaders and the parent classloader if
|
|
// either are present in info, e.g. {PCL[foo.dex]#PCL[bar.dex]};PCL[baz.dex]
|
|
void EncodeSharedLibAndParent(const ClassLoaderInfo& info,
|
|
const std::string& base_dir,
|
|
bool for_dex2oat,
|
|
ClassLoaderInfo* stored_info,
|
|
std::ostringstream& out) const;
|
|
|
|
bool ClassLoaderInfoMatch(const ClassLoaderInfo& info,
|
|
const ClassLoaderInfo& expected_info,
|
|
const std::string& context_spec,
|
|
bool verify_names,
|
|
bool verify_checksums) const;
|
|
|
|
// Extracts the class loader type from the given spec.
|
|
// Return ClassLoaderContext::kInvalidClassLoader if the class loader type is not
|
|
// recognized.
|
|
static ClassLoaderType ExtractClassLoaderType(const std::string& class_loader_spec);
|
|
|
|
// Returns the string representation of the class loader type.
|
|
// The returned format can be used when parsing a context spec.
|
|
static const char* GetClassLoaderTypeName(ClassLoaderType type);
|
|
|
|
// Encodes the state of processing the dex files associated with the context.
|
|
enum ContextDexFilesState {
|
|
// The dex files are not opened.
|
|
kDexFilesNotOpened = 1,
|
|
// The dex checksums/locations were read from the apk/dex but the dex files were not opened.
|
|
kDexFilesChecksumsRead = 2,
|
|
// The dex files are opened (either because we called OpenDexFiles, or we used a class loader
|
|
// to create the context). This implies kDexFilesChecksumsRead.
|
|
kDexFilesOpened = 3,
|
|
// We failed to open the dex files or read the checksums.
|
|
kDexFilesOpenFailed = 4
|
|
};
|
|
|
|
// The class loader chain.
|
|
std::unique_ptr<ClassLoaderInfo> class_loader_chain_;
|
|
|
|
// The opening state of the dex files.
|
|
ContextDexFilesState dex_files_state_;
|
|
|
|
// Whether or not the context owns the opened dex and oat files.
|
|
// If true, the opened dex files will be de-allocated when the context is destructed.
|
|
// If false, the objects will continue to be alive.
|
|
// Note that for convenience the the opened dex/oat files are stored as unique pointers
|
|
// which will release their ownership in the destructor based on this flag.
|
|
const bool owns_the_dex_files_;
|
|
|
|
friend class ClassLoaderContextTest;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(ClassLoaderContext);
|
|
};
|
|
|
|
} // namespace art
|
|
#endif // ART_RUNTIME_CLASS_LOADER_CONTEXT_H_
|