1 /* 2 * Copyright (C) 2015 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 #ifndef ART_RUNTIME_OAT_FILE_MANAGER_H_ 18 #define ART_RUNTIME_OAT_FILE_MANAGER_H_ 19 20 #include <memory> 21 #include <set> 22 #include <string> 23 #include <unordered_map> 24 #include <vector> 25 26 #include "base/macros.h" 27 #include "base/mutex.h" 28 #include "compiler_filter.h" 29 #include "jni.h" 30 31 namespace art { 32 33 namespace gc { 34 namespace space { 35 class ImageSpace; 36 } // namespace space 37 } // namespace gc 38 39 class DexFile; 40 class OatFile; 41 42 // Class for dealing with oat file management. 43 // 44 // This class knows about all the loaded oat files and provides utility functions. The oat file 45 // pointers returned from functions are always valid. 46 class OatFileManager { 47 public: 48 OatFileManager() : have_non_pic_oat_file_(false) {} 49 ~OatFileManager(); 50 51 // Add an oat file to the internal accounting, std::aborts if there already exists an oat file 52 // with the same base address. Returns the oat file pointer from oat_file. 53 const OatFile* RegisterOatFile(std::unique_ptr<const OatFile> oat_file) 54 REQUIRES(!Locks::oat_file_manager_lock_); 55 56 void UnRegisterAndDeleteOatFile(const OatFile* oat_file) 57 REQUIRES(!Locks::oat_file_manager_lock_); 58 59 // Find the first opened oat file with the same location, returns null if there are none. 60 const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location) const 61 REQUIRES(!Locks::oat_file_manager_lock_); 62 63 // Find the oat file which contains a dex files with the given dex base location, 64 // returns null if there are none. 65 const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_base_location) const 66 REQUIRES(!Locks::oat_file_manager_lock_); 67 68 // Returns true if we have a non pic oat file. 69 bool HaveNonPicOatFile() const { 70 return have_non_pic_oat_file_; 71 } 72 73 // Returns the boot image oat files. 74 std::vector<const OatFile*> GetBootOatFiles() const; 75 76 // Returns the first non-image oat file in the class path. 77 const OatFile* GetPrimaryOatFile() const REQUIRES(!Locks::oat_file_manager_lock_); 78 79 // Returns the oat files for the images, registers the oat files. 80 // Takes ownership of the imagespace's underlying oat files. 81 std::vector<const OatFile*> RegisterImageOatFiles(std::vector<gc::space::ImageSpace*> spaces) 82 REQUIRES(!Locks::oat_file_manager_lock_); 83 84 // Finds or creates the oat file holding dex_location. Then loads and returns 85 // all corresponding dex files (there may be more than one dex file loaded 86 // in the case of multidex). 87 // This may return the original, unquickened dex files if the oat file could 88 // not be generated. 89 // 90 // Returns an empty vector if the dex files could not be loaded. In this 91 // case, there will be at least one error message returned describing why no 92 // dex files could not be loaded. The 'error_msgs' argument must not be 93 // null, regardless of whether there is an error or not. 94 // 95 // This method should not be called with the mutator_lock_ held, because it 96 // could end up starving GC if we need to generate or relocate any oat 97 // files. 98 std::vector<std::unique_ptr<const DexFile>> OpenDexFilesFromOat( 99 const char* dex_location, 100 const char* oat_location, 101 jobject class_loader, 102 jobjectArray dex_elements, 103 /*out*/ const OatFile** out_oat_file, 104 /*out*/ std::vector<std::string>* error_msgs) 105 REQUIRES(!Locks::oat_file_manager_lock_, !Locks::mutator_lock_); 106 107 void DumpForSigQuit(std::ostream& os); 108 109 static void SetCompilerFilter(CompilerFilter::Filter filter) { 110 filter_ = filter; 111 } 112 113 private: 114 // Check that the shared libraries in the given oat file match those in the given class loader and 115 // dex elements. If the class loader is null or we do not support one of the class loaders in the 116 // chain, compare against all non-boot oat files instead. If the shared libraries are not ok, 117 // check for duplicate class definitions of the given oat file against the oat files (either from 118 // the class loader and dex elements if possible or all non-boot oat files otherwise). 119 // Return true if there are any class definition collisions in the oat_file. 120 bool HasCollisions(const OatFile* oat_file, 121 jobject class_loader, 122 jobjectArray dex_elements, 123 /*out*/ std::string* error_msg) const 124 REQUIRES(!Locks::oat_file_manager_lock_); 125 126 const OatFile* FindOpenedOatFileFromOatLocationLocked(const std::string& oat_location) const 127 REQUIRES(Locks::oat_file_manager_lock_); 128 129 std::set<std::unique_ptr<const OatFile>> oat_files_ GUARDED_BY(Locks::oat_file_manager_lock_); 130 bool have_non_pic_oat_file_; 131 132 // The compiler filter used for oat files loaded by the oat file manager. 133 static CompilerFilter::Filter filter_; 134 135 DISALLOW_COPY_AND_ASSIGN(OatFileManager); 136 }; 137 138 } // namespace art 139 140 #endif // ART_RUNTIME_OAT_FILE_MANAGER_H_ 141
