1 /* 2 * Copyright (C) 2008 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 "dalvik_system_ZygoteHooks.h" 18 19 #include <stdlib.h> 20 21 #include <cutils/process_name.h> 22 23 #include "arch/instruction_set.h" 24 #include "debugger.h" 25 #include "java_vm_ext.h" 26 #include "jit/jit.h" 27 #include "jni_internal.h" 28 #include "JNIHelp.h" 29 #include "scoped_thread_state_change.h" 30 #include "ScopedUtfChars.h" 31 #include "thread-inl.h" 32 #include "trace.h" 33 34 #if defined(__linux__) 35 #include <sys/prctl.h> 36 #endif 37 38 #include <sys/resource.h> 39 40 namespace art { 41 42 static void EnableDebugger() { 43 #if defined(__linux__) 44 // To let a non-privileged gdbserver attach to this 45 // process, we must set our dumpable flag. 46 if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) == -1) { 47 PLOG(ERROR) << "prctl(PR_SET_DUMPABLE) failed for pid " << getpid(); 48 } 49 #endif 50 // We don't want core dumps, though, so set the core dump size to 0. 51 rlimit rl; 52 rl.rlim_cur = 0; 53 rl.rlim_max = RLIM_INFINITY; 54 if (setrlimit(RLIMIT_CORE, &rl) == -1) { 55 PLOG(ERROR) << "setrlimit(RLIMIT_CORE) failed for pid " << getpid(); 56 } 57 } 58 59 static void EnableDebugFeatures(uint32_t debug_flags) { 60 // Must match values in com.android.internal.os.Zygote. 61 enum { 62 DEBUG_ENABLE_DEBUGGER = 1, 63 DEBUG_ENABLE_CHECKJNI = 1 << 1, 64 DEBUG_ENABLE_ASSERT = 1 << 2, 65 DEBUG_ENABLE_SAFEMODE = 1 << 3, 66 DEBUG_ENABLE_JNI_LOGGING = 1 << 4, 67 DEBUG_ENABLE_JIT = 1 << 5, 68 DEBUG_GENERATE_DEBUG_INFO = 1 << 6, 69 }; 70 71 Runtime* const runtime = Runtime::Current(); 72 if ((debug_flags & DEBUG_ENABLE_CHECKJNI) != 0) { 73 JavaVMExt* vm = runtime->GetJavaVM(); 74 if (!vm->IsCheckJniEnabled()) { 75 LOG(INFO) << "Late-enabling -Xcheck:jni"; 76 vm->SetCheckJniEnabled(true); 77 // There's only one thread running at this point, so only one JNIEnv to fix up. 78 Thread::Current()->GetJniEnv()->SetCheckJniEnabled(true); 79 } else { 80 LOG(INFO) << "Not late-enabling -Xcheck:jni (already on)"; 81 } 82 debug_flags &= ~DEBUG_ENABLE_CHECKJNI; 83 } 84 85 if ((debug_flags & DEBUG_ENABLE_JNI_LOGGING) != 0) { 86 gLogVerbosity.third_party_jni = true; 87 debug_flags &= ~DEBUG_ENABLE_JNI_LOGGING; 88 } 89 90 Dbg::SetJdwpAllowed((debug_flags & DEBUG_ENABLE_DEBUGGER) != 0); 91 if ((debug_flags & DEBUG_ENABLE_DEBUGGER) != 0) { 92 EnableDebugger(); 93 } 94 debug_flags &= ~DEBUG_ENABLE_DEBUGGER; 95 96 const bool safe_mode = (debug_flags & DEBUG_ENABLE_SAFEMODE) != 0; 97 if (safe_mode) { 98 // Ensure that any (secondary) oat files will be interpreted. 99 runtime->AddCompilerOption("--compiler-filter=interpret-only"); 100 debug_flags &= ~DEBUG_ENABLE_SAFEMODE; 101 } 102 103 bool use_jit = false; 104 if ((debug_flags & DEBUG_ENABLE_JIT) != 0) { 105 if (safe_mode) { 106 LOG(INFO) << "Not enabling JIT due to safe mode"; 107 } else { 108 use_jit = true; 109 LOG(INFO) << "Late-enabling JIT"; 110 } 111 debug_flags &= ~DEBUG_ENABLE_JIT; 112 } 113 runtime->GetJITOptions()->SetUseJIT(use_jit); 114 115 const bool generate_debug_info = (debug_flags & DEBUG_GENERATE_DEBUG_INFO) != 0; 116 if (generate_debug_info) { 117 runtime->AddCompilerOption("--generate-debug-info"); 118 debug_flags &= ~DEBUG_GENERATE_DEBUG_INFO; 119 } 120 121 // This is for backwards compatibility with Dalvik. 122 debug_flags &= ~DEBUG_ENABLE_ASSERT; 123 124 if (debug_flags != 0) { 125 LOG(ERROR) << StringPrintf("Unknown bits set in debug_flags: %#x", debug_flags); 126 } 127 } 128 129 static jlong ZygoteHooks_nativePreFork(JNIEnv* env, jclass) { 130 Runtime* runtime = Runtime::Current(); 131 CHECK(runtime->IsZygote()) << "runtime instance not started with -Xzygote"; 132 133 runtime->PreZygoteFork(); 134 135 if (Trace::GetMethodTracingMode() != TracingMode::kTracingInactive) { 136 // Tracing active, pause it. 137 Trace::Pause(); 138 } 139 140 // Grab thread before fork potentially makes Thread::pthread_key_self_ unusable. 141 return reinterpret_cast<jlong>(ThreadForEnv(env)); 142 } 143 144 static void ZygoteHooks_nativePostForkChild(JNIEnv* env, jclass, jlong token, jint debug_flags, 145 jstring instruction_set) { 146 Thread* thread = reinterpret_cast<Thread*>(token); 147 // Our system thread ID, etc, has changed so reset Thread state. 148 thread->InitAfterFork(); 149 EnableDebugFeatures(debug_flags); 150 151 // Update tracing. 152 if (Trace::GetMethodTracingMode() != TracingMode::kTracingInactive) { 153 Trace::TraceOutputMode output_mode = Trace::GetOutputMode(); 154 Trace::TraceMode trace_mode = Trace::GetMode(); 155 size_t buffer_size = Trace::GetBufferSize(); 156 157 // Just drop it. 158 Trace::Abort(); 159 160 // Only restart if it was streaming mode. 161 // TODO: Expose buffer size, so we can also do file mode. 162 if (output_mode == Trace::TraceOutputMode::kStreaming) { 163 const char* proc_name_cutils = get_process_name(); 164 std::string proc_name; 165 if (proc_name_cutils != nullptr) { 166 proc_name = proc_name_cutils; 167 } 168 if (proc_name_cutils == nullptr || proc_name == "zygote" || proc_name == "zygote64") { 169 // Either no process name, or the name hasn't been changed, yet. Just use pid. 170 pid_t pid = getpid(); 171 proc_name = StringPrintf("%u", static_cast<uint32_t>(pid)); 172 } 173 174 std::string profiles_dir(GetDalvikCache("profiles", false /* create_if_absent */)); 175 if (!profiles_dir.empty()) { 176 std::string trace_file = StringPrintf("%s/%s.trace.bin", profiles_dir.c_str(), 177 proc_name.c_str()); 178 Trace::Start(trace_file.c_str(), 179 -1, 180 buffer_size, 181 0, // TODO: Expose flags. 182 output_mode, 183 trace_mode, 184 0); // TODO: Expose interval. 185 if (thread->IsExceptionPending()) { 186 ScopedObjectAccess soa(env); 187 thread->ClearException(); 188 } 189 } else { 190 LOG(ERROR) << "Profiles dir is empty?!?!"; 191 } 192 } 193 } 194 195 if (instruction_set != nullptr) { 196 ScopedUtfChars isa_string(env, instruction_set); 197 InstructionSet isa = GetInstructionSetFromString(isa_string.c_str()); 198 Runtime::NativeBridgeAction action = Runtime::NativeBridgeAction::kUnload; 199 if (isa != kNone && isa != kRuntimeISA) { 200 action = Runtime::NativeBridgeAction::kInitialize; 201 } 202 Runtime::Current()->DidForkFromZygote(env, action, isa_string.c_str()); 203 } else { 204 Runtime::Current()->DidForkFromZygote(env, Runtime::NativeBridgeAction::kUnload, nullptr); 205 } 206 } 207 208 static JNINativeMethod gMethods[] = { 209 NATIVE_METHOD(ZygoteHooks, nativePreFork, "()J"), 210 NATIVE_METHOD(ZygoteHooks, nativePostForkChild, "(JILjava/lang/String;)V"), 211 }; 212 213 void register_dalvik_system_ZygoteHooks(JNIEnv* env) { 214 REGISTER_NATIVE_METHODS("dalvik/system/ZygoteHooks"); 215 } 216 217 } // namespace art 218
