dalvik_system_VMDebug.cc revision cf58d4adf461eb9b8e84baa8019054c88cd8acc6 
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 <string.h>
18#include <unistd.h>
19
20#include "class_linker.h"
21#include "common_throws.h"
22#include "debugger.h"
23#include "gc/space/dlmalloc_space.h"
24#include "gc/space/large_object_space.h"
25#include "gc/space/space-inl.h"
26#include "hprof/hprof.h"
27#include "jni_internal.h"
28#include "mirror/class.h"
29#include "ScopedUtfChars.h"
30#include "scoped_thread_state_change.h"
31#include "toStringArray.h"
32#include "trace.h"
33
34namespace art {
35
36static jobjectArray VMDebug_getVmFeatureList(JNIEnv* env, jclass) {
37  std::vector<std::string> features;
38  features.push_back("method-trace-profiling");
39  features.push_back("method-trace-profiling-streaming");
40  features.push_back("method-sample-profiling");
41  features.push_back("hprof-heap-dump");
42  features.push_back("hprof-heap-dump-streaming");
43  return toStringArray(env, features);
44}
45
46static void VMDebug_startAllocCounting(JNIEnv*, jclass) {
47  Runtime::Current()->SetStatsEnabled(true);
48}
49
50static void VMDebug_stopAllocCounting(JNIEnv*, jclass) {
51  Runtime::Current()->SetStatsEnabled(false);
52}
53
54static jint VMDebug_getAllocCount(JNIEnv*, jclass, jint kind) {
55  return Runtime::Current()->GetStat(kind);
56}
57
58static void VMDebug_resetAllocCount(JNIEnv*, jclass, jint kinds) {
59  Runtime::Current()->ResetStats(kinds);
60}
61
62static void VMDebug_startMethodTracingDdmsImpl(JNIEnv*, jclass, jint bufferSize, jint flags,
63                                               jboolean samplingEnabled, jint intervalUs) {
64  Trace::Start("[DDMS]", -1, bufferSize, flags, true, samplingEnabled, intervalUs);
65}
66
67static void VMDebug_startMethodTracingFd(JNIEnv* env, jclass, jstring javaTraceFilename,
68                                         jobject javaFd, jint bufferSize, jint flags) {
69  int originalFd = jniGetFDFromFileDescriptor(env, javaFd);
70  if (originalFd < 0) {
71    return;
72  }
73
74  int fd = dup(originalFd);
75  if (fd < 0) {
76    ScopedObjectAccess soa(env);
77    ThrowLocation throw_location = soa.Self()->GetCurrentLocationForThrow();
78    soa.Self()->ThrowNewExceptionF(throw_location, "Ljava/lang/RuntimeException;",
79                                   "dup(%d) failed: %s", originalFd, strerror(errno));
80    return;
81  }
82
83  ScopedUtfChars traceFilename(env, javaTraceFilename);
84  if (traceFilename.c_str() == NULL) {
85    return;
86  }
87  Trace::Start(traceFilename.c_str(), fd, bufferSize, flags, false, false, 0);
88}
89
90static void VMDebug_startMethodTracingFilename(JNIEnv* env, jclass, jstring javaTraceFilename,
91                                               jint bufferSize, jint flags) {
92  ScopedUtfChars traceFilename(env, javaTraceFilename);
93  if (traceFilename.c_str() == NULL) {
94    return;
95  }
96  Trace::Start(traceFilename.c_str(), -1, bufferSize, flags, false, false, 0);
97}
98
99static jint VMDebug_getMethodTracingMode(JNIEnv*, jclass) {
100  return Trace::GetMethodTracingMode();
101}
102
103static void VMDebug_stopMethodTracing(JNIEnv*, jclass) {
104  Trace::Stop();
105}
106
107static void VMDebug_startEmulatorTracing(JNIEnv*, jclass) {
108  UNIMPLEMENTED(WARNING);
109  // dvmEmulatorTraceStart();
110}
111
112static void VMDebug_stopEmulatorTracing(JNIEnv*, jclass) {
113  UNIMPLEMENTED(WARNING);
114  // dvmEmulatorTraceStop();
115}
116
117static jboolean VMDebug_isDebuggerConnected(JNIEnv*, jclass) {
118  return Dbg::IsDebuggerActive();
119}
120
121static jboolean VMDebug_isDebuggingEnabled(JNIEnv*, jclass) {
122  return Dbg::IsJdwpConfigured();
123}
124
125static jlong VMDebug_lastDebuggerActivity(JNIEnv*, jclass) {
126  return Dbg::LastDebuggerActivity();
127}
128
129static void ThrowUnsupportedOperationException(JNIEnv* env) {
130  ScopedObjectAccess soa(env);
131  ThrowLocation throw_location = soa.Self()->GetCurrentLocationForThrow();
132  soa.Self()->ThrowNewException(throw_location, "Ljava/lang/UnsupportedOperationException;", NULL);
133}
134
135static void VMDebug_startInstructionCounting(JNIEnv* env, jclass) {
136  ThrowUnsupportedOperationException(env);
137}
138
139static void VMDebug_stopInstructionCounting(JNIEnv* env, jclass) {
140  ThrowUnsupportedOperationException(env);
141}
142
143static void VMDebug_getInstructionCount(JNIEnv* env, jclass, jintArray /*javaCounts*/) {
144  ThrowUnsupportedOperationException(env);
145}
146
147static void VMDebug_resetInstructionCount(JNIEnv* env, jclass) {
148  ThrowUnsupportedOperationException(env);
149}
150
151static void VMDebug_printLoadedClasses(JNIEnv* env, jclass, jint flags) {
152  ScopedObjectAccess soa(env);
153  return Runtime::Current()->GetClassLinker()->DumpAllClasses(flags);
154}
155
156static jint VMDebug_getLoadedClassCount(JNIEnv* env, jclass) {
157  ScopedObjectAccess soa(env);
158  return Runtime::Current()->GetClassLinker()->NumLoadedClasses();
159}
160
161/*
162 * Returns the thread-specific CPU-time clock value for the current thread,
163 * or -1 if the feature isn't supported.
164 */
165static jlong VMDebug_threadCpuTimeNanos(JNIEnv*, jclass) {
166  return ThreadCpuNanoTime();
167}
168
169/*
170 * static void dumpHprofData(String fileName, FileDescriptor fd)
171 *
172 * Cause "hprof" data to be dumped.  We can throw an IOException if an
173 * error occurs during file handling.
174 */
175static void VMDebug_dumpHprofData(JNIEnv* env, jclass, jstring javaFilename, jobject javaFd) {
176  // Only one of these may be NULL.
177  if (javaFilename == NULL && javaFd == NULL) {
178    ScopedObjectAccess soa(env);
179    ThrowNullPointerException(NULL, "fileName == null && fd == null");
180    return;
181  }
182
183  std::string filename;
184  if (javaFilename != NULL) {
185    ScopedUtfChars chars(env, javaFilename);
186    if (env->ExceptionCheck()) {
187      return;
188    }
189    filename = chars.c_str();
190  } else {
191    filename = "[fd]";
192  }
193
194  int fd = -1;
195  if (javaFd != NULL) {
196    fd = jniGetFDFromFileDescriptor(env, javaFd);
197    if (fd < 0) {
198      ScopedObjectAccess soa(env);
199      ThrowRuntimeException("Invalid file descriptor");
200      return;
201    }
202  }
203
204  hprof::DumpHeap(filename.c_str(), fd, false);
205}
206
207static void VMDebug_dumpHprofDataDdms(JNIEnv*, jclass) {
208  hprof::DumpHeap("[DDMS]", -1, true);
209}
210
211static void VMDebug_dumpReferenceTables(JNIEnv* env, jclass) {
212  ScopedObjectAccess soa(env);
213  LOG(INFO) << "--- reference table dump ---";
214
215  soa.Env()->DumpReferenceTables(LOG(INFO));
216  soa.Vm()->DumpReferenceTables(LOG(INFO));
217
218  LOG(INFO) << "---";
219}
220
221static void VMDebug_crash(JNIEnv*, jclass) {
222  LOG(FATAL) << "Crashing runtime on request";
223}
224
225static void VMDebug_infopoint(JNIEnv*, jclass, jint id) {
226  LOG(INFO) << "VMDebug infopoint " << id << " hit";
227}
228
229static jlong VMDebug_countInstancesOfClass(JNIEnv* env, jclass, jclass javaClass,
230                                           jboolean countAssignable) {
231  ScopedObjectAccess soa(env);
232  mirror::Class* c = soa.Decode<mirror::Class*>(javaClass);
233  if (c == NULL) {
234    return 0;
235  }
236  std::vector<mirror::Class*> classes;
237  classes.push_back(c);
238  uint64_t count = 0;
239  Runtime::Current()->GetHeap()->CountInstances(classes, countAssignable, &count);
240  return count;
241}
242
243// We export the VM internal per-heap-space size/alloc/free metrics
244// for the zygote space, alloc space (application heap), and the large
245// object space for dumpsys meminfo. The other memory region data such
246// as PSS, private/shared dirty/shared data are available via
247// /proc/<pid>/smaps.
248static void VMDebug_getHeapSpaceStats(JNIEnv* env, jclass, jlongArray data) {
249  jlong* arr = reinterpret_cast<jlong*>(env->GetPrimitiveArrayCritical(data, 0));
250  if (arr == NULL || env->GetArrayLength(data) < 9) {
251    return;
252  }
253
254  size_t allocSize = 0;
255  size_t allocUsed = 0;
256  size_t zygoteSize = 0;
257  size_t zygoteUsed = 0;
258  size_t largeObjectsSize = 0;
259  size_t largeObjectsUsed = 0;
260
261  gc::Heap* heap = Runtime::Current()->GetHeap();
262  const std::vector<gc::space::ContinuousSpace*>& continuous_spaces = heap->GetContinuousSpaces();
263  const std::vector<gc::space::DiscontinuousSpace*>& discontinuous_spaces = heap->GetDiscontinuousSpaces();
264  typedef std::vector<gc::space::ContinuousSpace*>::const_iterator It;
265  for (It it = continuous_spaces.begin(), end = continuous_spaces.end(); it != end; ++it) {
266    gc::space::ContinuousSpace* space = *it;
267    if (space->IsImageSpace()) {
268      // Currently don't include the image space.
269    } else if (space->IsZygoteSpace()) {
270      gc::space::MallocSpace* malloc_space = space->AsMallocSpace();
271      zygoteSize += malloc_space->GetFootprint();
272      zygoteUsed += malloc_space->GetBytesAllocated();
273    } else {
274      // This is the alloc space.
275      gc::space::MallocSpace* malloc_space = space->AsMallocSpace();
276      allocSize += malloc_space->GetFootprint();
277      allocUsed += malloc_space->GetBytesAllocated();
278    }
279  }
280  typedef std::vector<gc::space::DiscontinuousSpace*>::const_iterator It2;
281  for (It2 it = discontinuous_spaces.begin(), end = discontinuous_spaces.end(); it != end; ++it) {
282    gc::space::DiscontinuousSpace* space = *it;
283    if (space->IsLargeObjectSpace()) {
284      largeObjectsSize += space->AsLargeObjectSpace()->GetBytesAllocated();
285      largeObjectsUsed += largeObjectsSize;
286    }
287  }
288
289  size_t allocFree = allocSize - allocUsed;
290  size_t zygoteFree = zygoteSize - zygoteUsed;
291  size_t largeObjectsFree = largeObjectsSize - largeObjectsUsed;
292
293  int j = 0;
294  arr[j++] = allocSize;
295  arr[j++] = allocUsed;
296  arr[j++] = allocFree;
297  arr[j++] = zygoteSize;
298  arr[j++] = zygoteUsed;
299  arr[j++] = zygoteFree;
300  arr[j++] = largeObjectsSize;
301  arr[j++] = largeObjectsUsed;
302  arr[j++] = largeObjectsFree;
303  env->ReleasePrimitiveArrayCritical(data, arr, 0);
304}
305
306static JNINativeMethod gMethods[] = {
307  NATIVE_METHOD(VMDebug, countInstancesOfClass, "(Ljava/lang/Class;Z)J"),
308  NATIVE_METHOD(VMDebug, crash, "()V"),
309  NATIVE_METHOD(VMDebug, dumpHprofData, "(Ljava/lang/String;Ljava/io/FileDescriptor;)V"),
310  NATIVE_METHOD(VMDebug, dumpHprofDataDdms, "()V"),
311  NATIVE_METHOD(VMDebug, dumpReferenceTables, "()V"),
312  NATIVE_METHOD(VMDebug, getAllocCount, "(I)I"),
313  NATIVE_METHOD(VMDebug, getHeapSpaceStats, "([J)V"),
314  NATIVE_METHOD(VMDebug, getInstructionCount, "([I)V"),
315  NATIVE_METHOD(VMDebug, getLoadedClassCount, "()I"),
316  NATIVE_METHOD(VMDebug, getVmFeatureList, "()[Ljava/lang/String;"),
317  NATIVE_METHOD(VMDebug, infopoint, "(I)V"),
318  NATIVE_METHOD(VMDebug, isDebuggerConnected, "()Z"),
319  NATIVE_METHOD(VMDebug, isDebuggingEnabled, "()Z"),
320  NATIVE_METHOD(VMDebug, getMethodTracingMode, "()I"),
321  NATIVE_METHOD(VMDebug, lastDebuggerActivity, "()J"),
322  NATIVE_METHOD(VMDebug, printLoadedClasses, "(I)V"),
323  NATIVE_METHOD(VMDebug, resetAllocCount, "(I)V"),
324  NATIVE_METHOD(VMDebug, resetInstructionCount, "()V"),
325  NATIVE_METHOD(VMDebug, startAllocCounting, "()V"),
326  NATIVE_METHOD(VMDebug, startEmulatorTracing, "()V"),
327  NATIVE_METHOD(VMDebug, startInstructionCounting, "()V"),
328  NATIVE_METHOD(VMDebug, startMethodTracingDdmsImpl, "(IIZI)V"),
329  NATIVE_METHOD(VMDebug, startMethodTracingFd, "(Ljava/lang/String;Ljava/io/FileDescriptor;II)V"),
330  NATIVE_METHOD(VMDebug, startMethodTracingFilename, "(Ljava/lang/String;II)V"),
331  NATIVE_METHOD(VMDebug, stopAllocCounting, "()V"),
332  NATIVE_METHOD(VMDebug, stopEmulatorTracing, "()V"),
333  NATIVE_METHOD(VMDebug, stopInstructionCounting, "()V"),
334  NATIVE_METHOD(VMDebug, stopMethodTracing, "()V"),
335  NATIVE_METHOD(VMDebug, threadCpuTimeNanos, "()J"),
336};
337
338void register_dalvik_system_VMDebug(JNIEnv* env) {
339  REGISTER_NATIVE_METHODS("dalvik/system/VMDebug");
340}
341
342}  // namespace art
343