| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/android/jni_android.h" |
| |
| #include <stddef.h> |
| #include <sys/prctl.h> |
| |
| #include "base/android/java_exception_reporter.h" |
| #include "base/android/jni_string.h" |
| #include "base/android/jni_utils.h" |
| #include "base/android_runtime_jni_headers/Throwable_jni.h" |
| #include "base/base_jni/JniAndroid_jni.h" |
| #include "base/debug/debugging_buildflags.h" |
| #include "base/feature_list.h" |
| #include "base/logging.h" |
| #include "build/build_config.h" |
| #include "third_party/abseil-cpp/absl/base/attributes.h" |
| |
| namespace base { |
| namespace android { |
| namespace { |
| |
| // If disabled, we LOG(FATAL) immediately in native code when faced with an |
| // uncaught Java exception (historical behavior). If enabled, we give the Java |
| // uncaught exception handler a chance to handle the exception first, so that |
| // the crash is (hopefully) seen as a Java crash, not a native crash. |
| // TODO(https://crbug.com/1426888): remove this switch once we are confident the |
| // new behavior is fine. |
| BASE_FEATURE(kHandleExceptionsInJava, |
| "HandleJniExceptionsInJava", |
| base::FEATURE_ENABLED_BY_DEFAULT); |
| |
| JavaVM* g_jvm = nullptr; |
| jobject g_class_loader = nullptr; |
| jclass g_out_of_memory_error_class = nullptr; |
| jmethodID g_class_loader_load_class_method_id = nullptr; |
| |
| ScopedJavaLocalRef<jclass> GetClassInternal(JNIEnv* env, |
| const char* class_name, |
| jobject class_loader) { |
| jclass clazz; |
| if (class_loader != nullptr) { |
| // ClassLoader.loadClass expects a classname with components separated by |
| // dots instead of the slashes that JNIEnv::FindClass expects. The JNI |
| // generator generates names with slashes, so we have to replace them here. |
| // TODO(torne): move to an approach where we always use ClassLoader except |
| // for the special case of base::android::GetClassLoader(), and change the |
| // JNI generator to generate dot-separated names. http://crbug.com/461773 |
| size_t bufsize = strlen(class_name) + 1; |
| char dotted_name[bufsize]; |
| memmove(dotted_name, class_name, bufsize); |
| for (size_t i = 0; i < bufsize; ++i) { |
| if (dotted_name[i] == '/') { |
| dotted_name[i] = '.'; |
| } |
| } |
| |
| clazz = static_cast<jclass>( |
| env->CallObjectMethod(class_loader, g_class_loader_load_class_method_id, |
| ConvertUTF8ToJavaString(env, dotted_name).obj())); |
| } else { |
| clazz = env->FindClass(class_name); |
| } |
| if (ClearException(env) || !clazz) { |
| LOG(FATAL) << "Failed to find class " << class_name; |
| } |
| return ScopedJavaLocalRef<jclass>(env, clazz); |
| } |
| |
| } // namespace |
| |
| JNIEnv* AttachCurrentThread() { |
| DCHECK(g_jvm); |
| JNIEnv* env = nullptr; |
| jint ret = g_jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_2); |
| if (ret == JNI_EDETACHED || !env) { |
| JavaVMAttachArgs args; |
| args.version = JNI_VERSION_1_2; |
| args.group = nullptr; |
| |
| // 16 is the maximum size for thread names on Android. |
| char thread_name[16]; |
| int err = prctl(PR_GET_NAME, thread_name); |
| if (err < 0) { |
| DPLOG(ERROR) << "prctl(PR_GET_NAME)"; |
| args.name = nullptr; |
| } else { |
| args.name = thread_name; |
| } |
| |
| #if BUILDFLAG(IS_ANDROID) |
| ret = g_jvm->AttachCurrentThread(&env, &args); |
| #else |
| ret = g_jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), &args); |
| #endif |
| CHECK_EQ(JNI_OK, ret); |
| } |
| return env; |
| } |
| |
| JNIEnv* AttachCurrentThreadWithName(const std::string& thread_name) { |
| DCHECK(g_jvm); |
| JavaVMAttachArgs args; |
| args.version = JNI_VERSION_1_2; |
| args.name = const_cast<char*>(thread_name.c_str()); |
| args.group = nullptr; |
| JNIEnv* env = nullptr; |
| #if BUILDFLAG(IS_ANDROID) |
| jint ret = g_jvm->AttachCurrentThread(&env, &args); |
| #else |
| jint ret = g_jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), &args); |
| #endif |
| CHECK_EQ(JNI_OK, ret); |
| return env; |
| } |
| |
| void DetachFromVM() { |
| // Ignore the return value, if the thread is not attached, DetachCurrentThread |
| // will fail. But it is ok as the native thread may never be attached. |
| if (g_jvm) |
| g_jvm->DetachCurrentThread(); |
| } |
| |
| void InitVM(JavaVM* vm) { |
| DCHECK(!g_jvm || g_jvm == vm); |
| g_jvm = vm; |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| g_out_of_memory_error_class = static_cast<jclass>( |
| env->NewGlobalRef(env->FindClass("java/lang/OutOfMemoryError"))); |
| DCHECK(g_out_of_memory_error_class); |
| } |
| |
| bool IsVMInitialized() { |
| return g_jvm != nullptr; |
| } |
| |
| JavaVM* GetVM() { |
| return g_jvm; |
| } |
| |
| void DisableJvmForTesting() { |
| g_jvm = nullptr; |
| } |
| |
| void InitGlobalClassLoader(JNIEnv* env) { |
| DCHECK(g_class_loader == nullptr); |
| |
| ScopedJavaLocalRef<jclass> class_loader_clazz = |
| GetClass(env, "java/lang/ClassLoader"); |
| CHECK(!ClearException(env)); |
| g_class_loader_load_class_method_id = |
| env->GetMethodID(class_loader_clazz.obj(), |
| "loadClass", |
| "(Ljava/lang/String;)Ljava/lang/Class;"); |
| CHECK(!ClearException(env)); |
| |
| // GetClassLoader() caches the reference, so we do not need to wrap it in a |
| // smart pointer as well. |
| g_class_loader = GetClassLoader(env); |
| } |
| |
| ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, |
| const char* class_name, |
| const char* split_name) { |
| return GetClassInternal(env, class_name, |
| GetSplitClassLoader(env, split_name)); |
| } |
| |
| ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, const char* class_name) { |
| return GetClassInternal(env, class_name, g_class_loader); |
| } |
| |
| // This is duplicated with LazyGetClass below because these are performance |
| // sensitive. |
| jclass LazyGetClass(JNIEnv* env, |
| const char* class_name, |
| const char* split_name, |
| std::atomic<jclass>* atomic_class_id) { |
| const jclass value = atomic_class_id->load(std::memory_order_acquire); |
| if (value) |
| return value; |
| ScopedJavaGlobalRef<jclass> clazz; |
| clazz.Reset(GetClass(env, class_name, split_name)); |
| jclass cas_result = nullptr; |
| if (atomic_class_id->compare_exchange_strong(cas_result, clazz.obj(), |
| std::memory_order_acq_rel)) { |
| // We intentionally leak the global ref since we now storing it as a raw |
| // pointer in |atomic_class_id|. |
| return clazz.Release(); |
| } else { |
| return cas_result; |
| } |
| } |
| |
| // This is duplicated with LazyGetClass above because these are performance |
| // sensitive. |
| jclass LazyGetClass(JNIEnv* env, |
| const char* class_name, |
| std::atomic<jclass>* atomic_class_id) { |
| const jclass value = atomic_class_id->load(std::memory_order_acquire); |
| if (value) |
| return value; |
| ScopedJavaGlobalRef<jclass> clazz; |
| clazz.Reset(GetClass(env, class_name)); |
| jclass cas_result = nullptr; |
| if (atomic_class_id->compare_exchange_strong(cas_result, clazz.obj(), |
| std::memory_order_acq_rel)) { |
| // We intentionally leak the global ref since we now storing it as a raw |
| // pointer in |atomic_class_id|. |
| return clazz.Release(); |
| } else { |
| return cas_result; |
| } |
| } |
| |
| template<MethodID::Type type> |
| jmethodID MethodID::Get(JNIEnv* env, |
| jclass clazz, |
| const char* method_name, |
| const char* jni_signature) { |
| auto get_method_ptr = type == MethodID::TYPE_STATIC ? |
| &JNIEnv::GetStaticMethodID : |
| &JNIEnv::GetMethodID; |
| jmethodID id = (env->*get_method_ptr)(clazz, method_name, jni_signature); |
| if (base::android::ClearException(env) || !id) { |
| LOG(FATAL) << "Failed to find " << |
| (type == TYPE_STATIC ? "static " : "") << |
| "method " << method_name << " " << jni_signature; |
| } |
| return id; |
| } |
| |
| // If |atomic_method_id| set, it'll return immediately. Otherwise, it'll call |
| // into ::Get() above. If there's a race, it's ok since the values are the same |
| // (and the duplicated effort will happen only once). |
| template <MethodID::Type type> |
| jmethodID MethodID::LazyGet(JNIEnv* env, |
| jclass clazz, |
| const char* method_name, |
| const char* jni_signature, |
| std::atomic<jmethodID>* atomic_method_id) { |
| const jmethodID value = atomic_method_id->load(std::memory_order_acquire); |
| if (value) |
| return value; |
| jmethodID id = MethodID::Get<type>(env, clazz, method_name, jni_signature); |
| atomic_method_id->store(id, std::memory_order_release); |
| return id; |
| } |
| |
| // Various template instantiations. |
| template jmethodID MethodID::Get<MethodID::TYPE_STATIC>( |
| JNIEnv* env, jclass clazz, const char* method_name, |
| const char* jni_signature); |
| |
| template jmethodID MethodID::Get<MethodID::TYPE_INSTANCE>( |
| JNIEnv* env, jclass clazz, const char* method_name, |
| const char* jni_signature); |
| |
| template jmethodID MethodID::LazyGet<MethodID::TYPE_STATIC>( |
| JNIEnv* env, jclass clazz, const char* method_name, |
| const char* jni_signature, std::atomic<jmethodID>* atomic_method_id); |
| |
| template jmethodID MethodID::LazyGet<MethodID::TYPE_INSTANCE>( |
| JNIEnv* env, jclass clazz, const char* method_name, |
| const char* jni_signature, std::atomic<jmethodID>* atomic_method_id); |
| |
| bool HasException(JNIEnv* env) { |
| return env->ExceptionCheck() != JNI_FALSE; |
| } |
| |
| bool ClearException(JNIEnv* env) { |
| if (!HasException(env)) |
| return false; |
| env->ExceptionDescribe(); |
| env->ExceptionClear(); |
| return true; |
| } |
| |
| void CheckException(JNIEnv* env) { |
| if (!HasException(env)) |
| return; |
| |
| static thread_local bool g_reentering = false; |
| if (g_reentering) { |
| // We were handling an uncaught Java exception already, but one of the Java |
| // methods we called below threw another exception. (This is unlikely to |
| // happen as we are careful to never throw from these methods, but we can't |
| // rule it out entirely as the JVM itself may throw - think |
| // OutOfMemoryError, for example.) |
| env->ExceptionDescribe(); |
| jthrowable raw_throwable = env->ExceptionOccurred(); |
| env->ExceptionClear(); |
| jclass clazz = env->GetObjectClass(raw_throwable); |
| bool is_oom_error = env->IsSameObject(clazz, g_out_of_memory_error_class); |
| env->Throw(raw_throwable); // Ensure we don't re-enter Java. |
| |
| if (is_oom_error) { |
| constexpr char kMessage[] = |
| "While handling an uncaught Java exception, an OutOfMemoryError " |
| "occurred."; |
| base::android::SetJavaException(kMessage); |
| // Use different LOG(FATAL) statements to ensure unique stack traces. |
| LOG(FATAL) << kMessage; |
| } else { |
| constexpr char kMessage[] = |
| "While handling an uncaught Java exception, another exception " |
| "occurred."; |
| base::android::SetJavaException(kMessage); |
| LOG(FATAL) << kMessage; |
| } |
| } |
| g_reentering = true; |
| |
| // Log a message to ensure there is something in the log even if the rest of |
| // this function goes horribly wrong, and also to provide a convenient marker |
| // in the log for where Java exception crash information starts. |
| LOG(ERROR) << "Crashing due to uncaught Java exception"; |
| |
| const bool handle_exception_in_java = |
| base::FeatureList::IsEnabled(kHandleExceptionsInJava); |
| |
| if (!handle_exception_in_java) { |
| env->ExceptionDescribe(); |
| } |
| |
| // We cannot use `ScopedJavaLocalRef` directly because that ends up calling |
| // env->GetObjectRefType() when DCHECK is on, and that call is not allowed |
| // with a pending exception according to the JNI spec. |
| jthrowable raw_throwable = env->ExceptionOccurred(); |
| // Now that we saved the reference to the throwable, clear the exception. |
| // |
| // We need to do this as early as possible to remove the risk that code below |
| // might accidentally call back into Java, which is not allowed when `env` |
| // has an exception set, per the JNI spec. (For example, LOG(FATAL) doesn't |
| // work with a JNI exception set, because it calls |
| // GetJavaStackTraceIfPresent()). |
| env->ExceptionClear(); |
| // The reference returned by `ExceptionOccurred()` is a local reference. |
| // `ExceptionClear()` merely removes the exception information from `env`; |
| // it doesn't delete the reference, which is why this call is valid. |
| auto throwable = ScopedJavaLocalRef<jthrowable>::Adopt(env, raw_throwable); |
| |
| if (!handle_exception_in_java) { |
| base::android::SetJavaException( |
| GetJavaExceptionInfo(env, throwable).c_str()); |
| LOG(FATAL) |
| << "Uncaught Java exception in native code. Please include the Java " |
| "exception stack from the Android log in your crash report."; |
| } |
| |
| // We don't need to call SetJavaException() in this branch because we |
| // expect handleException() to eventually call JavaExceptionReporter through |
| // the global uncaught exception handler. |
| |
| const std::string native_stack_trace = base::debug::StackTrace().ToString(); |
| LOG(ERROR) << "Native stack trace:" << std::endl << native_stack_trace; |
| |
| ScopedJavaLocalRef<jthrowable> secondary_exception = |
| Java_JniAndroid_handleException( |
| env, throwable, ConvertUTF8ToJavaString(env, native_stack_trace)); |
| |
| // Ideally handleException() should have terminated the process and we should |
| // not get here. This can happen in the case of OutOfMemoryError or if the |
| // app that embedded WebView installed an exception handler that does not |
| // terminate, or itself threw an exception. We cannot be confident that |
| // JavaExceptionReporter ran, so set the java exception explicitly. |
| base::android::SetJavaException( |
| GetJavaExceptionInfo( |
| env, secondary_exception ? secondary_exception : throwable) |
| .c_str()); |
| LOG(FATAL) |
| << "Uncaught Java exception in native code, and the Java uncaught " |
| "exception handler did not terminate the process. Please include the " |
| "Java exception stack from the Android log in your crash report."; |
| } |
| |
| std::string GetJavaExceptionInfo(JNIEnv* env, |
| const JavaRef<jthrowable>& throwable) { |
| ScopedJavaLocalRef<jstring> sanitized_exception_string = |
| Java_JniAndroid_sanitizedStacktraceForUnhandledException(env, throwable); |
| // Returns null when PiiElider results in an OutOfMemoryError. |
| return sanitized_exception_string |
| ? ConvertJavaStringToUTF8(sanitized_exception_string) |
| : "Unable to obtain Java stack trace due to OutOfMemoryError"; |
| } |
| |
| std::string GetJavaStackTraceIfPresent() { |
| JNIEnv* env = nullptr; |
| if (g_jvm) { |
| g_jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_2); |
| } |
| if (!env) { |
| // JNI has not been initialized on this thread. |
| return {}; |
| } |
| |
| if (HasException(env)) { |
| // This can happen if CheckException() is being re-entered, decided to |
| // LOG(FATAL) immediately, and LOG(FATAL) itself is calling us. In that case |
| // it is imperative that we don't try to call Java again. |
| return "Unable to retrieve Java caller stack trace as the exception " |
| "handler is being re-entered"; |
| } |
| |
| ScopedJavaLocalRef<jthrowable> throwable = |
| JNI_Throwable::Java_Throwable_Constructor(env); |
| std::string ret = GetJavaExceptionInfo(env, throwable); |
| // Strip the exception message and leave only the "at" lines. Example: |
| // java.lang.Throwable: |
| // {tab}at Clazz.method(Clazz.java:111) |
| // {tab}at ... |
| size_t newline_idx = ret.find('\n'); |
| if (newline_idx == std::string::npos) { |
| // There are no java frames. |
| return {}; |
| } |
| return ret.substr(newline_idx + 1); |
| } |
| |
| } // namespace android |
| } // namespace base |