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
EnableDebugger()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
50 // Even if Yama is on a non-privileged native debugger should
51 // be able to attach to the debuggable app.
52 if (prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0) == -1) {
53 // if Yama is off prctl(PR_SET_PTRACER) returns EINVAL - don't log in this
54 // case since it's expected behaviour.
55 if (errno != EINVAL) {
56 PLOG(ERROR) << "prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY) failed for pid " << getpid();
57 }
58 }
59 #endif
60 // We don't want core dumps, though, so set the core dump size to 0.
61 rlimit rl;
62 rl.rlim_cur = 0;
63 rl.rlim_max = RLIM_INFINITY;
64 if (setrlimit(RLIMIT_CORE, &rl) == -1) {
65 PLOG(ERROR) << "setrlimit(RLIMIT_CORE) failed for pid " << getpid();
66 }
67 }
68
EnableDebugFeatures(uint32_t debug_flags)69 static void EnableDebugFeatures(uint32_t debug_flags) {
70 // Must match values in com.android.internal.os.Zygote.
71 enum {
72 DEBUG_ENABLE_DEBUGGER = 1,
73 DEBUG_ENABLE_CHECKJNI = 1 << 1,
74 DEBUG_ENABLE_ASSERT = 1 << 2,
75 DEBUG_ENABLE_SAFEMODE = 1 << 3,
76 DEBUG_ENABLE_JNI_LOGGING = 1 << 4,
77 DEBUG_GENERATE_DEBUG_INFO = 1 << 5,
78 DEBUG_ALWAYS_JIT = 1 << 6,
79 DEBUG_NATIVE_DEBUGGABLE = 1 << 7,
80 };
81
82 Runtime* const runtime = Runtime::Current();
83 if ((debug_flags & DEBUG_ENABLE_CHECKJNI) != 0) {
84 JavaVMExt* vm = runtime->GetJavaVM();
85 if (!vm->IsCheckJniEnabled()) {
86 LOG(INFO) << "Late-enabling -Xcheck:jni";
87 vm->SetCheckJniEnabled(true);
88 // There's only one thread running at this point, so only one JNIEnv to fix up.
89 Thread::Current()->GetJniEnv()->SetCheckJniEnabled(true);
90 } else {
91 LOG(INFO) << "Not late-enabling -Xcheck:jni (already on)";
92 }
93 debug_flags &= ~DEBUG_ENABLE_CHECKJNI;
94 }
95
96 if ((debug_flags & DEBUG_ENABLE_JNI_LOGGING) != 0) {
97 gLogVerbosity.third_party_jni = true;
98 debug_flags &= ~DEBUG_ENABLE_JNI_LOGGING;
99 }
100
101 Dbg::SetJdwpAllowed((debug_flags & DEBUG_ENABLE_DEBUGGER) != 0);
102 if ((debug_flags & DEBUG_ENABLE_DEBUGGER) != 0) {
103 EnableDebugger();
104 }
105 debug_flags &= ~DEBUG_ENABLE_DEBUGGER;
106
107 const bool safe_mode = (debug_flags & DEBUG_ENABLE_SAFEMODE) != 0;
108 if (safe_mode) {
109 // Ensure that any (secondary) oat files will be interpreted.
110 runtime->AddCompilerOption("--compiler-filter=interpret-only");
111 runtime->SetSafeMode(true);
112 debug_flags &= ~DEBUG_ENABLE_SAFEMODE;
113 }
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 & DEBUG_ALWAYS_JIT) != 0) {
125 jit::JitOptions* jit_options = runtime->GetJITOptions();
126 CHECK(jit_options != nullptr);
127 jit_options->SetJitAtFirstUse();
128 debug_flags &= ~DEBUG_ALWAYS_JIT;
129 }
130
131 if ((debug_flags & DEBUG_NATIVE_DEBUGGABLE) != 0) {
132 runtime->AddCompilerOption("--debuggable");
133 runtime->AddCompilerOption("--generate-debug-info");
134 runtime->SetNativeDebuggable(true);
135 debug_flags &= ~DEBUG_NATIVE_DEBUGGABLE;
136 }
137
138 if (debug_flags != 0) {
139 LOG(ERROR) << StringPrintf("Unknown bits set in debug_flags: %#x", debug_flags);
140 }
141 }
142
ZygoteHooks_nativePreFork(JNIEnv * env,jclass)143 static jlong ZygoteHooks_nativePreFork(JNIEnv* env, jclass) {
144 Runtime* runtime = Runtime::Current();
145 CHECK(runtime->IsZygote()) << "runtime instance not started with -Xzygote";
146
147 runtime->PreZygoteFork();
148
149 if (Trace::GetMethodTracingMode() != TracingMode::kTracingInactive) {
150 // Tracing active, pause it.
151 Trace::Pause();
152 }
153
154 // Grab thread before fork potentially makes Thread::pthread_key_self_ unusable.
155 return reinterpret_cast<jlong>(ThreadForEnv(env));
156 }
157
ZygoteHooks_nativePostForkChild(JNIEnv * env,jclass,jlong token,jint debug_flags,jboolean is_system_server,jstring instruction_set)158 static void ZygoteHooks_nativePostForkChild(JNIEnv* env,
159 jclass,
160 jlong token,
161 jint debug_flags,
162 jboolean is_system_server,
163 jstring instruction_set) {
164 Thread* thread = reinterpret_cast<Thread*>(token);
165 // Our system thread ID, etc, has changed so reset Thread state.
166 thread->InitAfterFork();
167 EnableDebugFeatures(debug_flags);
168
169 // Update tracing.
170 if (Trace::GetMethodTracingMode() != TracingMode::kTracingInactive) {
171 Trace::TraceOutputMode output_mode = Trace::GetOutputMode();
172 Trace::TraceMode trace_mode = Trace::GetMode();
173 size_t buffer_size = Trace::GetBufferSize();
174
175 // Just drop it.
176 Trace::Abort();
177
178 // Only restart if it was streaming mode.
179 // TODO: Expose buffer size, so we can also do file mode.
180 if (output_mode == Trace::TraceOutputMode::kStreaming) {
181 const char* proc_name_cutils = get_process_name();
182 std::string proc_name;
183 if (proc_name_cutils != nullptr) {
184 proc_name = proc_name_cutils;
185 }
186 if (proc_name_cutils == nullptr || proc_name == "zygote" || proc_name == "zygote64") {
187 // Either no process name, or the name hasn't been changed, yet. Just use pid.
188 pid_t pid = getpid();
189 proc_name = StringPrintf("%u", static_cast<uint32_t>(pid));
190 }
191
192 std::string trace_file = StringPrintf("/data/misc/trace/%s.trace.bin", proc_name.c_str());
193 Trace::Start(trace_file.c_str(),
194 -1,
195 buffer_size,
196 0, // TODO: Expose flags.
197 output_mode,
198 trace_mode,
199 0); // TODO: Expose interval.
200 if (thread->IsExceptionPending()) {
201 ScopedObjectAccess soa(env);
202 thread->ClearException();
203 }
204 }
205 }
206
207 if (instruction_set != nullptr && !is_system_server) {
208 ScopedUtfChars isa_string(env, instruction_set);
209 InstructionSet isa = GetInstructionSetFromString(isa_string.c_str());
210 Runtime::NativeBridgeAction action = Runtime::NativeBridgeAction::kUnload;
211 if (isa != kNone && isa != kRuntimeISA) {
212 action = Runtime::NativeBridgeAction::kInitialize;
213 }
214 Runtime::Current()->InitNonZygoteOrPostFork(
215 env, is_system_server, action, isa_string.c_str());
216 } else {
217 Runtime::Current()->InitNonZygoteOrPostFork(
218 env, is_system_server, Runtime::NativeBridgeAction::kUnload, nullptr);
219 }
220 }
221
ZygoteHooks_startZygoteNoThreadCreation(JNIEnv * env ATTRIBUTE_UNUSED,jclass klass ATTRIBUTE_UNUSED)222 static void ZygoteHooks_startZygoteNoThreadCreation(JNIEnv* env ATTRIBUTE_UNUSED,
223 jclass klass ATTRIBUTE_UNUSED) {
224 Runtime::Current()->SetZygoteNoThreadSection(true);
225 }
226
ZygoteHooks_stopZygoteNoThreadCreation(JNIEnv * env ATTRIBUTE_UNUSED,jclass klass ATTRIBUTE_UNUSED)227 static void ZygoteHooks_stopZygoteNoThreadCreation(JNIEnv* env ATTRIBUTE_UNUSED,
228 jclass klass ATTRIBUTE_UNUSED) {
229 Runtime::Current()->SetZygoteNoThreadSection(false);
230 }
231
232 static JNINativeMethod gMethods[] = {
233 NATIVE_METHOD(ZygoteHooks, nativePreFork, "()J"),
234 NATIVE_METHOD(ZygoteHooks, nativePostForkChild, "(JIZLjava/lang/String;)V"),
235 NATIVE_METHOD(ZygoteHooks, startZygoteNoThreadCreation, "()V"),
236 NATIVE_METHOD(ZygoteHooks, stopZygoteNoThreadCreation, "()V"),
237 };
238
register_dalvik_system_ZygoteHooks(JNIEnv * env)239 void register_dalvik_system_ZygoteHooks(JNIEnv* env) {
240 REGISTER_NATIVE_METHODS("dalvik/system/ZygoteHooks");
241 }
242
243 } // namespace art
244