1 /*
2  * Copyright (C) 2011 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_JAVA_VM_EXT_H_
18 #define ART_RUNTIME_JAVA_VM_EXT_H_
19 
20 #include "jni.h"
21 
22 #include "base/macros.h"
23 #include "base/mutex.h"
24 #include "indirect_reference_table.h"
25 #include "obj_ptr.h"
26 #include "reference_table.h"
27 
28 namespace art {
29 
30 namespace mirror {
31 class Array;
32 }  // namespace mirror
33 
34 class ArtMethod;
35 class IsMarkedVisitor;
36 class Libraries;
37 class ParsedOptions;
38 class Runtime;
39 struct RuntimeArgumentMap;
40 
41 class JavaVMExt;
42 // Hook definition for runtime plugins.
43 using GetEnvHook = jint (*)(JavaVMExt* vm, /*out*/void** new_env, jint version);
44 
45 class JavaVMExt : public JavaVM {
46  public:
47   // Creates a new JavaVMExt object.
48   // Returns nullptr on error, in which case error_msg is set to a message
49   // describing the error.
50   static std::unique_ptr<JavaVMExt> Create(Runtime* runtime,
51                                            const RuntimeArgumentMap& runtime_options,
52                                            std::string* error_msg);
53 
54 
55   ~JavaVMExt();
56 
ForceCopy()57   bool ForceCopy() const {
58     return force_copy_;
59   }
60 
IsCheckJniEnabled()61   bool IsCheckJniEnabled() const {
62     return check_jni_;
63   }
64 
IsTracingEnabled()65   bool IsTracingEnabled() const {
66     return tracing_enabled_;
67   }
68 
GetRuntime()69   Runtime* GetRuntime() const {
70     return runtime_;
71   }
72 
SetCheckJniAbortHook(void (* hook)(void *,const std::string &),void * data)73   void SetCheckJniAbortHook(void (*hook)(void*, const std::string&), void* data) {
74     check_jni_abort_hook_ = hook;
75     check_jni_abort_hook_data_ = data;
76   }
77 
78   // Aborts execution unless there is an abort handler installed in which case it will return. Its
79   // therefore important that callers return after aborting as otherwise code following the abort
80   // will be executed in the abort handler case.
81   void JniAbort(const char* jni_function_name, const char* msg);
82 
83   void JniAbortV(const char* jni_function_name, const char* fmt, va_list ap);
84 
85   void JniAbortF(const char* jni_function_name, const char* fmt, ...)
86       __attribute__((__format__(__printf__, 3, 4)));
87 
88   // If both "-Xcheck:jni" and "-Xjnitrace:" are enabled, we print trace messages
89   // when a native method that matches the -Xjnitrace argument calls a JNI function
90   // such as NewByteArray.
91   // If -verbose:third-party-jni is on, we want to log any JNI function calls
92   // made by a third-party native method.
93   bool ShouldTrace(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_);
94 
95   /**
96    * Loads the given shared library. 'path' is an absolute pathname.
97    *
98    * Returns 'true' on success. On failure, sets 'error_msg' to a
99    * human-readable description of the error.
100    */
101   bool LoadNativeLibrary(JNIEnv* env,
102                          const std::string& path,
103                          jobject class_loader,
104                          std::string* error_msg);
105 
106   // Unload native libraries with cleared class loaders.
107   void UnloadNativeLibraries()
108       REQUIRES(!Locks::jni_libraries_lock_)
109       REQUIRES_SHARED(Locks::mutator_lock_);
110 
111   /**
112    * Returns a pointer to the code for the native method 'm', found
113    * using dlsym(3) on every native library that's been loaded so far.
114    */
115   void* FindCodeForNativeMethod(ArtMethod* m)
116       REQUIRES_SHARED(Locks::mutator_lock_);
117 
118   void DumpForSigQuit(std::ostream& os)
119       REQUIRES(!Locks::jni_libraries_lock_,
120                !Locks::jni_globals_lock_,
121                !Locks::jni_weak_globals_lock_);
122 
123   void DumpReferenceTables(std::ostream& os)
124       REQUIRES_SHARED(Locks::mutator_lock_)
125       REQUIRES(!Locks::jni_globals_lock_,
126                !Locks::jni_weak_globals_lock_,
127                !Locks::alloc_tracker_lock_);
128 
129   bool SetCheckJniEnabled(bool enabled);
130 
131   void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_)
132       REQUIRES(!Locks::jni_globals_lock_);
133 
134   void DisallowNewWeakGlobals()
135       REQUIRES_SHARED(Locks::mutator_lock_)
136       REQUIRES(!Locks::jni_weak_globals_lock_);
137   void AllowNewWeakGlobals()
138       REQUIRES_SHARED(Locks::mutator_lock_)
139       REQUIRES(!Locks::jni_weak_globals_lock_);
140   void BroadcastForNewWeakGlobals()
141       REQUIRES(!Locks::jni_weak_globals_lock_);
142 
143   jobject AddGlobalRef(Thread* self, ObjPtr<mirror::Object> obj)
144       REQUIRES_SHARED(Locks::mutator_lock_)
145       REQUIRES(!Locks::jni_globals_lock_);
146 
147   jweak AddWeakGlobalRef(Thread* self, ObjPtr<mirror::Object> obj)
148       REQUIRES_SHARED(Locks::mutator_lock_)
149       REQUIRES(!Locks::jni_weak_globals_lock_);
150 
151   void DeleteGlobalRef(Thread* self, jobject obj) REQUIRES(!Locks::jni_globals_lock_);
152 
153   void DeleteWeakGlobalRef(Thread* self, jweak obj) REQUIRES(!Locks::jni_weak_globals_lock_);
154 
155   void SweepJniWeakGlobals(IsMarkedVisitor* visitor)
156       REQUIRES_SHARED(Locks::mutator_lock_)
157       REQUIRES(!Locks::jni_weak_globals_lock_);
158 
159   ObjPtr<mirror::Object> DecodeGlobal(IndirectRef ref)
160       REQUIRES_SHARED(Locks::mutator_lock_);
161 
162   void UpdateGlobal(Thread* self, IndirectRef ref, ObjPtr<mirror::Object> result)
163       REQUIRES_SHARED(Locks::mutator_lock_)
164       REQUIRES(!Locks::jni_globals_lock_);
165 
166   ObjPtr<mirror::Object> DecodeWeakGlobal(Thread* self, IndirectRef ref)
167       REQUIRES_SHARED(Locks::mutator_lock_)
168       REQUIRES(!Locks::jni_weak_globals_lock_);
169 
170   ObjPtr<mirror::Object> DecodeWeakGlobalLocked(Thread* self, IndirectRef ref)
171       REQUIRES_SHARED(Locks::mutator_lock_)
172       REQUIRES(Locks::jni_weak_globals_lock_);
173 
174   // Like DecodeWeakGlobal() but to be used only during a runtime shutdown where self may be
175   // null.
176   ObjPtr<mirror::Object> DecodeWeakGlobalDuringShutdown(Thread* self, IndirectRef ref)
177       REQUIRES_SHARED(Locks::mutator_lock_)
178       REQUIRES(!Locks::jni_weak_globals_lock_);
179 
180   // Checks if the weak global ref has been cleared by the GC without decode (read barrier.)
181   bool IsWeakGlobalCleared(Thread* self, IndirectRef ref)
182       REQUIRES_SHARED(Locks::mutator_lock_)
183       REQUIRES(!Locks::jni_weak_globals_lock_);
184 
185   void UpdateWeakGlobal(Thread* self, IndirectRef ref, ObjPtr<mirror::Object> result)
186       REQUIRES_SHARED(Locks::mutator_lock_)
187       REQUIRES(!Locks::jni_weak_globals_lock_);
188 
GetUncheckedFunctions()189   const JNIInvokeInterface* GetUncheckedFunctions() const {
190     return unchecked_functions_;
191   }
192 
193   void TrimGlobals() REQUIRES_SHARED(Locks::mutator_lock_)
194       REQUIRES(!Locks::jni_globals_lock_);
195 
196   jint HandleGetEnv(/*out*/void** env, jint version);
197 
198   void AddEnvironmentHook(GetEnvHook hook);
199 
200   static bool IsBadJniVersion(int version);
201 
202   // Return the library search path for the given classloader, if the classloader is of a
203   // well-known type. The jobject will be a local reference and is expected to be managed by the
204   // caller.
205   static jstring GetLibrarySearchPath(JNIEnv* env, jobject class_loader);
206 
207  private:
208   // The constructor should not be called directly. It may leave the object in
209   // an erroneous state, and the result needs to be checked.
210   JavaVMExt(Runtime* runtime, const RuntimeArgumentMap& runtime_options, std::string* error_msg);
211 
212   // Return true if self can currently access weak globals.
213   bool MayAccessWeakGlobalsUnlocked(Thread* self) const REQUIRES_SHARED(Locks::mutator_lock_);
214   bool MayAccessWeakGlobals(Thread* self) const
215       REQUIRES_SHARED(Locks::mutator_lock_)
216       REQUIRES(Locks::jni_weak_globals_lock_);
217 
218   void CheckGlobalRefAllocationTracking();
219 
220   Runtime* const runtime_;
221 
222   // Used for testing. By default, we'll LOG(FATAL) the reason.
223   void (*check_jni_abort_hook_)(void* data, const std::string& reason);
224   void* check_jni_abort_hook_data_;
225 
226   // Extra checking.
227   bool check_jni_;
228   const bool force_copy_;
229   const bool tracing_enabled_;
230 
231   // Extra diagnostics.
232   const std::string trace_;
233 
234   // Not guarded by globals_lock since we sometimes use SynchronizedGet in Thread::DecodeJObject.
235   IndirectReferenceTable globals_;
236 
237   // No lock annotation since UnloadNativeLibraries is called on libraries_ but locks the
238   // jni_libraries_lock_ internally.
239   std::unique_ptr<Libraries> libraries_;
240 
241   // Used by -Xcheck:jni.
242   const JNIInvokeInterface* const unchecked_functions_;
243 
244   // Since weak_globals_ contain weak roots, be careful not to
245   // directly access the object references in it. Use Get() with the
246   // read barrier enabled.
247   // Not guarded by weak_globals_lock since we may use SynchronizedGet in DecodeWeakGlobal.
248   IndirectReferenceTable weak_globals_;
249   // Not guarded by weak_globals_lock since we may use SynchronizedGet in DecodeWeakGlobal.
250   Atomic<bool> allow_accessing_weak_globals_;
251   ConditionVariable weak_globals_add_condition_ GUARDED_BY(Locks::jni_weak_globals_lock_);
252 
253   // TODO Maybe move this to Runtime.
254   std::vector<GetEnvHook> env_hooks_;
255 
256   size_t enable_allocation_tracking_delta_;
257   std::atomic<bool> allocation_tracking_enabled_;
258   std::atomic<bool> old_allocation_tracking_state_;
259 
260   DISALLOW_COPY_AND_ASSIGN(JavaVMExt);
261 };
262 
263 }  // namespace art
264 
265 #endif  // ART_RUNTIME_JAVA_VM_EXT_H_
266