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
31namespace art {
32
33namespace gc {
34namespace space {
35class ImageSpace;
36}  // namespace space
37}  // namespace gc
38
39class DexFile;
40class 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.
46class 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