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_JNI_ENV_EXT_H_ 18 #define ART_RUNTIME_JNI_ENV_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 class JavaVMExt; 31 32 namespace mirror { 33 class Object; 34 } // namespace mirror 35 36 // Number of local references in the indirect reference table. The value is arbitrary but 37 // low enough that it forces sanity checks. 38 static constexpr size_t kLocalsInitial = 512; 39 40 struct JNIEnvExt : public JNIEnv { 41 // Creates a new JNIEnvExt. Returns null on error, in which case error_msg 42 // will contain a description of the error. 43 static JNIEnvExt* Create(Thread* self, JavaVMExt* vm, std::string* error_msg); 44 45 ~JNIEnvExt(); 46 47 void DumpReferenceTables(std::ostream& os) 48 REQUIRES_SHARED(Locks::mutator_lock_); 49 50 void SetCheckJniEnabled(bool enabled) REQUIRES(!Locks::jni_function_table_lock_); 51 52 void PushFrame(int capacity) REQUIRES_SHARED(Locks::mutator_lock_); 53 void PopFrame() REQUIRES_SHARED(Locks::mutator_lock_); 54 55 template<typename T> 56 T AddLocalReference(ObjPtr<mirror::Object> obj) REQUIRES_SHARED(Locks::mutator_lock_); 57 58 static Offset SegmentStateOffset(size_t pointer_size); 59 static Offset LocalRefCookieOffset(size_t pointer_size); 60 static Offset SelfOffset(size_t pointer_size); 61 62 static jint GetEnvHandler(JavaVMExt* vm, /*out*/void** out, jint version); 63 64 jobject NewLocalRef(mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_); 65 void DeleteLocalRef(jobject obj) REQUIRES_SHARED(Locks::mutator_lock_); 66 67 Thread* const self; 68 JavaVMExt* const vm; 69 70 // Cookie used when using the local indirect reference table. 71 IRTSegmentState local_ref_cookie; 72 73 // JNI local references. 74 IndirectReferenceTable locals GUARDED_BY(Locks::mutator_lock_); 75 76 // Stack of cookies corresponding to PushLocalFrame/PopLocalFrame calls. 77 // TODO: to avoid leaks (and bugs), we need to clear this vector on entry (or return) 78 // to a native method. 79 std::vector<IRTSegmentState> stacked_local_ref_cookies; 80 81 // Frequently-accessed fields cached from JavaVM. 82 bool check_jni; 83 84 // If we are a JNI env for a daemon thread with a deleted runtime. 85 bool runtime_deleted; 86 87 // How many nested "critical" JNI calls are we in? 88 int critical; 89 90 // Entered JNI monitors, for bulk exit on thread detach. 91 ReferenceTable monitors; 92 93 // Used by -Xcheck:jni. 94 const JNINativeInterface* unchecked_functions; 95 96 // Functions to keep track of monitor lock and unlock operations. Used to ensure proper locking 97 // rules in CheckJNI mode. 98 99 // Record locking of a monitor. 100 void RecordMonitorEnter(jobject obj) REQUIRES_SHARED(Locks::mutator_lock_); 101 102 // Check the release, that is, that the release is performed in the same JNI "segment." 103 void CheckMonitorRelease(jobject obj) REQUIRES_SHARED(Locks::mutator_lock_); 104 105 // Check that no monitors are held that have been acquired in this JNI "segment." 106 void CheckNoHeldMonitors() REQUIRES_SHARED(Locks::mutator_lock_); 107 108 // Set the functions to the runtime shutdown functions. 109 void SetFunctionsToRuntimeShutdownFunctions(); 110 111 // Set the function table override. This will install the override (or original table, if null) 112 // to all threads. 113 // Note: JNI function table overrides are sensitive to the order of operations wrt/ CheckJNI. 114 // After overriding the JNI function table, CheckJNI toggling is ignored. 115 static void SetTableOverride(const JNINativeInterface* table_override) 116 REQUIRES(!Locks::thread_list_lock_, !Locks::jni_function_table_lock_); 117 118 // Return either the regular, or the CheckJNI function table. Will return table_override_ instead 119 // if it is not null. 120 static const JNINativeInterface* GetFunctionTable(bool check_jni) 121 REQUIRES(Locks::jni_function_table_lock_); 122 123 private: 124 // Override of function tables. This applies to both default as well as instrumented (CheckJNI) 125 // function tables. 126 static const JNINativeInterface* table_override_ GUARDED_BY(Locks::jni_function_table_lock_); 127 128 // The constructor should not be called directly. It may leave the object in an erroneous state, 129 // and the result needs to be checked. 130 JNIEnvExt(Thread* self, JavaVMExt* vm, std::string* error_msg) 131 REQUIRES(!Locks::jni_function_table_lock_); 132 133 // All locked objects, with the (Java caller) stack frame that locked them. Used in CheckJNI 134 // to ensure that only monitors locked in this native frame are being unlocked, and that at 135 // the end all are unlocked. 136 std::vector<std::pair<uintptr_t, jobject>> locked_objects_; 137 }; 138 139 // Used to save and restore the JNIEnvExt state when not going through code created by the JNI 140 // compiler. 141 class ScopedJniEnvLocalRefState { 142 public: ScopedJniEnvLocalRefState(JNIEnvExt * env)143 explicit ScopedJniEnvLocalRefState(JNIEnvExt* env) : env_(env) { 144 saved_local_ref_cookie_ = env->local_ref_cookie; 145 env->local_ref_cookie = env->locals.GetSegmentState(); 146 } 147 ~ScopedJniEnvLocalRefState()148 ~ScopedJniEnvLocalRefState() { 149 env_->locals.SetSegmentState(env_->local_ref_cookie); 150 env_->local_ref_cookie = saved_local_ref_cookie_; 151 } 152 153 private: 154 JNIEnvExt* const env_; 155 IRTSegmentState saved_local_ref_cookie_; 156 157 DISALLOW_COPY_AND_ASSIGN(ScopedJniEnvLocalRefState); 158 }; 159 160 } // namespace art 161 162 #endif // ART_RUNTIME_JNI_ENV_EXT_H_ 163