extern int register_android_server_BluetoothService(JNIEnv* env);
extern int register_android_server_BluetoothEventLoop(JNIEnv *env);
extern int register_android_server_BluetoothA2dpService(JNIEnv* env);
+extern int register_android_server_Watchdog(JNIEnv* env);
extern int register_android_ddm_DdmHandleNativeHeap(JNIEnv *env);
extern int register_com_android_internal_os_ZygoteInit(JNIEnv* env);
extern int register_android_location_GpsLocationProvider(JNIEnv* env);
REG_JNI(register_android_server_BluetoothService),
REG_JNI(register_android_server_BluetoothEventLoop),
REG_JNI(register_android_server_BluetoothA2dpService),
+ REG_JNI(register_android_server_Watchdog),
REG_JNI(register_android_message_digest_sha1),
REG_JNI(register_android_ddm_DdmHandleNativeHeap),
REG_JNI(register_android_location_GpsLocationProvider),
--- /dev/null
+/*
+ ** Copyright 2010, The Android Open Source Project
+ **
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ **
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ **
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ */
+
+#define LOG_TAG "Watchdog_N"
+#include <utils/Log.h>
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <string.h>
+#include <errno.h>
+
+#include "jni.h"
+#include "JNIHelp.h"
+#include <android_runtime/AndroidRuntime.h>
+
+static void dumpOneStack(int tid, int outFd) {
+ char buf[64];
+
+ snprintf(buf, sizeof(buf), "/proc/%d/stack", tid);
+ int stackFd = open(buf, O_RDONLY);
+ if (stackFd >= 0) {
+ // header for readability
+ strncat(buf, ":\n", sizeof(buf) - strlen(buf) - 1);
+ write(outFd, buf, strlen(buf));
+
+ // copy the stack dump text
+ int nBytes;
+ while ((nBytes = read(stackFd, buf, sizeof(buf))) > 0) {
+ write(outFd, buf, nBytes);
+ }
+
+ // footer and done
+ write(outFd, "\n", 1);
+ close(stackFd);
+ } else {
+ LOGE("Unable to open stack of tid %d : %d (%s)", tid, errno, strerror(errno));
+ }
+}
+
+static void dumpKernelStacks(JNIEnv* env, jobject clazz, jstring pathStr) {
+ char buf[128];
+ DIR* taskdir;
+
+ LOGI("dumpKernelStacks");
+ if (!pathStr) {
+ jniThrowException(env, "java/lang/IllegalArgumentException", "Null path");
+ return;
+ }
+
+ const char *path = env->GetStringUTFChars(pathStr, NULL);
+
+ int outFd = open(path, O_WRONLY | O_APPEND | O_CREAT);
+ if (outFd < 0) {
+ LOGE("Unable to open stack dump file: %d (%s)", errno, strerror(errno));
+ goto done;
+ }
+
+ snprintf(buf, sizeof(buf), "\n----- begin pid %d kernel stacks -----\n", getpid());
+ write(outFd, buf, strlen(buf));
+
+ // look up the list of all threads in this process
+ snprintf(buf, sizeof(buf), "/proc/%d/task", getpid());
+ taskdir = opendir(buf);
+ if (taskdir != NULL) {
+ struct dirent * ent;
+ while ((ent = readdir(taskdir)) != NULL) {
+ int tid = atoi(ent->d_name);
+ if (tid > 0 && tid <= 65535) {
+ // dump each stack trace
+ dumpOneStack(tid, outFd);
+ }
+ }
+ closedir(taskdir);
+ }
+
+ snprintf(buf, sizeof(buf), "----- end pid %d kernel stacks -----\n", getpid());
+ write(outFd, buf, strlen(buf));
+
+ close(outFd);
+done:
+ env->ReleaseStringUTFChars(pathStr, path);
+}
+
+// ----------------------------------------
+
+namespace android {
+
+static const JNINativeMethod g_methods[] = {
+ { "native_dumpKernelStacks", "(Ljava/lang/String;)V", (void*)dumpKernelStacks },
+};
+
+int register_android_server_Watchdog(JNIEnv* env) {
+ return AndroidRuntime::registerNativeMethods(env, "com/android/server/Watchdog",
+ g_methods, NELEM(g_methods));
+}
+
+}
import android.util.Slog;
import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
// Set this to true to use debug default values.
static final boolean DB = false;
+ // Set this to true to have the watchdog record kernel thread stacks when it fires
+ static final boolean RECORD_KERNEL_THREADS = true;
+
static final int MONITOR = 2718;
static final int GLOBAL_PSS = 2719;
// The system's been hanging for a minute, another second or two won't hurt much.
SystemClock.sleep(2000);
+ // Pull our own kernel thread stacks as well if we're configured for that
+ if (RECORD_KERNEL_THREADS) {
+ dumpKernelStackTraces();
+ }
+
mActivity.addErrorToDropBox("watchdog", null, null, null, name, null, stack, null);
// Only kill the process if the debugger is not attached.
waitedHalf = false;
}
}
+
+ private File dumpKernelStackTraces() {
+ String tracesPath = SystemProperties.get("dalvik.vm.stack-trace-file", null);
+ if (tracesPath == null || tracesPath.length() == 0) {
+ return null;
+ }
+
+ native_dumpKernelStacks(tracesPath);
+ return new File(tracesPath);
+ }
+
+ private native void native_dumpKernelStacks(String tracesPath);
}