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 "object_callbacks.h"
26 #include "reference_table.h"
27 
28 namespace art {
29 
30 class JavaVMExt;
31 
32 // Maximum number of local references in the indirect reference table. The value is arbitrary but
33 // low enough that it forces sanity checks.
34 static constexpr size_t kLocalsMax = 512;
35 
36 struct JNIEnvExt : public JNIEnv {
37   static JNIEnvExt* Create(Thread* self, JavaVMExt* vm);
38 
39   ~JNIEnvExt();
40 
41   void DumpReferenceTables(std::ostream& os)
42       SHARED_REQUIRES(Locks::mutator_lock_);
43 
44   void SetCheckJniEnabled(bool enabled);
45 
46   void PushFrame(int capacity) SHARED_REQUIRES(Locks::mutator_lock_);
47   void PopFrame() SHARED_REQUIRES(Locks::mutator_lock_);
48 
49   template<typename T>
50   T AddLocalReference(mirror::Object* obj)
51       SHARED_REQUIRES(Locks::mutator_lock_);
52 
53   static Offset SegmentStateOffset(size_t pointer_size);
54   static Offset LocalRefCookieOffset(size_t pointer_size);
55   static Offset SelfOffset(size_t pointer_size);
56 
57   jobject NewLocalRef(mirror::Object* obj) SHARED_REQUIRES(Locks::mutator_lock_);
58   void DeleteLocalRef(jobject obj) SHARED_REQUIRES(Locks::mutator_lock_);
59 
60   Thread* const self;
61   JavaVMExt* const vm;
62 
63   // Cookie used when using the local indirect reference table.
64   uint32_t local_ref_cookie;
65 
66   // JNI local references.
67   IndirectReferenceTable locals GUARDED_BY(Locks::mutator_lock_);
68 
69   // Stack of cookies corresponding to PushLocalFrame/PopLocalFrame calls.
70   // TODO: to avoid leaks (and bugs), we need to clear this vector on entry (or return)
71   // to a native method.
72   std::vector<uint32_t> stacked_local_ref_cookies;
73 
74   // Frequently-accessed fields cached from JavaVM.
75   bool check_jni;
76 
77   // If we are a JNI env for a daemon thread with a deleted runtime.
78   bool runtime_deleted;
79 
80   // How many nested "critical" JNI calls are we in?
81   int critical;
82 
83   // Entered JNI monitors, for bulk exit on thread detach.
84   ReferenceTable monitors;
85 
86   // Used by -Xcheck:jni.
87   const JNINativeInterface* unchecked_functions;
88 
89   // Functions to keep track of monitor lock and unlock operations. Used to ensure proper locking
90   // rules in CheckJNI mode.
91 
92   // Record locking of a monitor.
93   void RecordMonitorEnter(jobject obj) SHARED_REQUIRES(Locks::mutator_lock_);
94 
95   // Check the release, that is, that the release is performed in the same JNI "segment."
96   void CheckMonitorRelease(jobject obj) SHARED_REQUIRES(Locks::mutator_lock_);
97 
98   // Check that no monitors are held that have been acquired in this JNI "segment."
99   void CheckNoHeldMonitors() SHARED_REQUIRES(Locks::mutator_lock_);
100 
101   // Set the functions to the runtime shutdown functions.
102   void SetFunctionsToRuntimeShutdownFunctions();
103 
104  private:
105   // The constructor should not be called directly. It may leave the object in an erronuous state,
106   // and the result needs to be checked.
107   JNIEnvExt(Thread* self, JavaVMExt* vm);
108 
109   // All locked objects, with the (Java caller) stack frame that locked them. Used in CheckJNI
110   // to ensure that only monitors locked in this native frame are being unlocked, and that at
111   // the end all are unlocked.
112   std::vector<std::pair<uintptr_t, jobject>> locked_objects_;
113 };
114 
115 // Used to save and restore the JNIEnvExt state when not going through code created by the JNI
116 // compiler.
117 class ScopedJniEnvLocalRefState {
118  public:
ScopedJniEnvLocalRefState(JNIEnvExt * env)119   explicit ScopedJniEnvLocalRefState(JNIEnvExt* env) : env_(env) {
120     saved_local_ref_cookie_ = env->local_ref_cookie;
121     env->local_ref_cookie = env->locals.GetSegmentState();
122   }
123 
~ScopedJniEnvLocalRefState()124   ~ScopedJniEnvLocalRefState() {
125     env_->locals.SetSegmentState(env_->local_ref_cookie);
126     env_->local_ref_cookie = saved_local_ref_cookie_;
127   }
128 
129  private:
130   JNIEnvExt* const env_;
131   uint32_t saved_local_ref_cookie_;
132 
133   DISALLOW_COPY_AND_ASSIGN(ScopedJniEnvLocalRefState);
134 };
135 
136 }  // namespace art
137 
138 #endif  // ART_RUNTIME_JNI_ENV_EXT_H_
139