runtime/native_bridge_art_interface.cc

   1 /*
   2  * Copyright (C) 2014 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 #include "native_bridge_art_interface.h"
  18
  19 #include <signal.h>
  20
  21 #include "nativebridge/native_bridge.h"
  22
  23 #include "art_method-inl.h"
  24 #include "base/logging.h"
  25 #include "base/macros.h"
  26 #include "dex_file-inl.h"
  27 #include "mirror/class-inl.h"
  28 #include "scoped_thread_state_change.h"
  29 #include "sigchain.h"
  30
  31 namespace art {
  32
  33 static const char* GetMethodShorty(JNIEnv* env, jmethodID mid) {
  34   ScopedObjectAccess soa(env);
  35   ArtMethod* m = soa.DecodeMethod(mid);
  36   return m->GetShorty();
  37 }
  38
  39 static uint32_t GetNativeMethodCount(JNIEnv* env, jclass clazz) {
  40   if (clazz == nullptr) {
  41     return 0;
  42   }
  43
  44   ScopedObjectAccess soa(env);
  45   mirror::Class* c = soa.Decode<mirror::Class*>(clazz);
  46
  47   uint32_t native_method_count = 0;
  48   for (auto& m : c->GetMethods(sizeof(void*))) {
  49     native_method_count += m.IsNative() ? 1u : 0u;
  50   }
  51   return native_method_count;
  52 }
  53
  54 static uint32_t GetNativeMethods(JNIEnv* env, jclass clazz, JNINativeMethod* methods,
  55                                  uint32_t method_count) {
  56   if ((clazz == nullptr) || (methods == nullptr)) {
  57     return 0;
  58   }
  59   ScopedObjectAccess soa(env);
  60   mirror::Class* c = soa.Decode<mirror::Class*>(clazz);
  61
  62   uint32_t count = 0;
  63   for (auto& m : c->GetMethods(sizeof(void*))) {
  64     if (m.IsNative()) {
  65       if (count < method_count) {
  66         methods[count].name = m.GetName();
  67         methods[count].signature = m.GetShorty();
  68         methods[count].fnPtr = m.GetEntryPointFromJni();
  69         count++;
  70       } else {
  71         LOG(WARNING) << "Output native method array too small. Skipping " << PrettyMethod(&m);
  72       }
  73     }
  74   }
  75   return count;
  76 }
  77
  78 // Native bridge library runtime callbacks. They represent the runtime interface to native bridge.
  79 //
  80 // The interface is expected to expose the following methods:
  81 // getMethodShorty(): in the case of native method calling JNI native function CallXXXXMethodY(),
  82 //   native bridge calls back to VM for the shorty of the method so that it can prepare based on
  83 //   host calling convention.
  84 // getNativeMethodCount() and getNativeMethods(): in case of JNI function UnregisterNatives(),
  85 //   native bridge can call back to get all native methods of specified class so that all
  86 //   corresponding trampolines can be destroyed.
  87 static android::NativeBridgeRuntimeCallbacks native_bridge_art_callbacks_ {
  88   GetMethodShorty, GetNativeMethodCount, GetNativeMethods
  89 };
  90
  91 bool LoadNativeBridge(std::string& native_bridge_library_filename) {
  92   VLOG(startup) << "Runtime::Setup native bridge library: "
  93       << (native_bridge_library_filename.empty() ? "(empty)" : native_bridge_library_filename);
  94   return android::LoadNativeBridge(native_bridge_library_filename.c_str(),
  95                                    &native_bridge_art_callbacks_);
  96 }
  97
  98 void PreInitializeNativeBridge(std::string dir) {
  99   VLOG(startup) << "Runtime::Pre-initialize native bridge";
 100 #ifndef __APPLE__  // Mac OS does not support CLONE_NEWNS.
 101   if (unshare(CLONE_NEWNS) == -1) {
 102     LOG(WARNING) << "Could not create mount namespace.";
 103   }
 104   android::PreInitializeNativeBridge(dir.c_str(), GetInstructionSetString(kRuntimeISA));
 105 #else
 106   UNUSED(dir);
 107 #endif
 108 }
 109
 110 void InitializeNativeBridge(JNIEnv* env, const char* instruction_set) {
 111   if (android::InitializeNativeBridge(env, instruction_set)) {
 112     if (android::NativeBridgeGetVersion() >= 2U) {
 113 #ifdef _NSIG  // Undefined on Apple, but we don't support running on Mac, anyways.
 114       // Managed signal handling support added in version 2.
 115       for (int signal = 0; signal < _NSIG; ++signal) {
 116         android::NativeBridgeSignalHandlerFn fn = android::NativeBridgeGetSignalHandler(signal);
 117         if (fn != nullptr) {
 118           SetSpecialSignalHandlerFn(signal, fn);
 119         }
 120       }
 121 #endif
 122     }
 123   }
 124 }
 125
 126 void UnloadNativeBridge() {
 127   android::UnloadNativeBridge();
 128 }
 129
 130 }  // namespace art