Home | History | Annotate | Download | only in runtime 
      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:
    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 
    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