2 * Copyright (C) 2008 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define ATRACE_TAG ATRACE_TAG_DALVIK
28 #include <sys/types.h>
29 #include <sys/resource.h>
36 #if defined(HAVE_PRCTL)
37 #include <sys/prctl.h>
40 #if defined(WITH_SELF_VERIFICATION)
41 #include "interp/Jit.h" // need for self verification
44 #include <cutils/trace.h>
46 /* desktop Linux needs a little help with gettid() */
47 #if defined(HAVE_GETTID) && !defined(HAVE_ANDROID_OS)
49 # include <linux/unistd.h>
51 _syscall0(pid_t,gettid)
53 pid_t gettid() { return syscall(__NR_gettid);}
58 // Change this to enable logging on cgroup errors
59 #define ENABLE_CGROUP_ERR_LOGGING 0
61 // change this to ALOGV/ALOGD to debug thread activity
62 #define LOG_THREAD LOGVV
67 All threads are native pthreads. All threads, except the JDWP debugger
68 thread, are visible to code running in the VM and to the debugger. (We
69 don't want the debugger to try to manipulate the thread that listens for
70 instructions from the debugger.) Internal VM threads are in the "system"
71 ThreadGroup, all others are in the "main" ThreadGroup, per convention.
73 The GC only runs when all threads have been suspended. Threads are
74 expected to suspend themselves, using a "safe point" mechanism. We check
75 for a suspend request at certain points in the main interpreter loop,
76 and on requests coming in from native code (e.g. all JNI functions).
77 Certain debugger events may inspire threads to self-suspend.
79 Native methods must use JNI calls to modify object references to avoid
80 clashes with the GC. JNI doesn't provide a way for native code to access
81 arrays of objects as such -- code must always get/set individual entries --
82 so it should be possible to fully control access through JNI.
84 Internal native VM threads, such as the finalizer thread, must explicitly
85 check for suspension periodically. In most cases they will be sound
86 asleep on a condition variable, and won't notice the suspension anyway.
88 Threads may be suspended by the GC, debugger, or the SIGQUIT listener
89 thread. The debugger may suspend or resume individual threads, while the
90 GC always suspends all threads. Each thread has a "suspend count" that
91 is incremented on suspend requests and decremented on resume requests.
92 When the count is zero, the thread is runnable. This allows us to fulfill
93 a debugger requirement: if the debugger suspends a thread, the thread is
94 not allowed to run again until the debugger resumes it (or disconnects,
95 in which case we must resume all debugger-suspended threads).
97 Paused threads sleep on a condition variable, and are awoken en masse.
98 Certain "slow" VM operations, such as starting up a new thread, will be
99 done in a separate "VMWAIT" state, so that the rest of the VM doesn't
100 freeze up waiting for the operation to finish. Threads must check for
101 pending suspension when leaving VMWAIT.
103 Because threads suspend themselves while interpreting code or when native
104 code makes JNI calls, there is no risk of suspending while holding internal
105 VM locks. All threads can enter a suspended (or native-code-only) state.
106 Also, we don't have to worry about object references existing solely
107 in hardware registers.
109 We do, however, have to worry about objects that were allocated internally
110 and aren't yet visible to anything else in the VM. If we allocate an
111 object, and then go to sleep on a mutex after changing to a non-RUNNING
112 state (e.g. while trying to allocate a second object), the first object
113 could be garbage-collected out from under us while we sleep. To manage
114 this, we automatically add all allocated objects to an internal object
115 tracking list, and only remove them when we know we won't be suspended
116 before the object appears in the GC root set.
118 The debugger may choose to suspend or resume a single thread, which can
119 lead to application-level deadlocks; this is expected behavior. The VM
120 will only check for suspension of single threads when the debugger is
121 active (the java.lang.Thread calls for this are deprecated and hence are
122 not supported). Resumption of a single thread is handled by decrementing
123 the thread's suspend count and sending a broadcast signal to the condition
124 variable. (This will cause all threads to wake up and immediately go back
125 to sleep, which isn't tremendously efficient, but neither is having the
128 The debugger is not allowed to resume threads suspended by the GC. This
129 is trivially enforced by ignoring debugger requests while the GC is running
130 (the JDWP thread is suspended during GC).
132 The VM maintains a Thread struct for every pthread known to the VM. There
133 is a java/lang/Thread object associated with every Thread. At present,
134 there is no safe way to go from a Thread object to a Thread struct except by
135 locking and scanning the list; this is necessary because the lifetimes of
136 the two are not closely coupled. We may want to change this behavior,
137 though at present the only performance impact is on the debugger (see
138 threadObjToThread()). See also notes about dvmDetachCurrentThread().
141 Alternate implementation (signal-based):
143 Threads run without safe points -- zero overhead. The VM uses a signal
144 (e.g. pthread_kill(SIGUSR1)) to notify threads of suspension or resumption.
146 The trouble with using signals to suspend threads is that it means a thread
147 can be in the middle of an operation when garbage collection starts.
148 To prevent some sticky situations, we have to introduce critical sections
151 Critical sections temporarily block suspension for a given thread.
152 The thread must move to a non-blocked state (and self-suspend) after
153 finishing its current task. If the thread blocks on a resource held
154 by a suspended thread, we're hosed.
156 One approach is to require that no blocking operations, notably
157 acquisition of mutexes, can be performed within a critical section.
158 This is too limiting. For example, if thread A gets suspended while
159 holding the thread list lock, it will prevent the GC or debugger from
160 being able to safely access the thread list. We need to wrap the critical
161 section around the entire operation (enter critical, get lock, do stuff,
162 release lock, exit critical).
164 A better approach is to declare that certain resources can only be held
165 within critical sections. A thread that enters a critical section and
166 then gets blocked on the thread list lock knows that the thread it is
167 waiting for is also in a critical section, and will release the lock
168 before suspending itself. Eventually all threads will complete their
169 operations and self-suspend. For this to work, the VM must:
171 (1) Determine the set of resources that may be accessed from the GC or
172 debugger threads. The mutexes guarding those go into the "critical
174 (2) Ensure that no resource in the CRS can be acquired outside of a
175 critical section. This can be verified with an assert().
176 (3) Ensure that only resources in the CRS can be held while in a critical
177 section. This is harder to enforce.
179 If any of these conditions are not met, deadlock can ensue when grabbing
180 resources in the GC or debugger (#1) or waiting for threads to suspend
181 (#2,#3). (You won't actually deadlock in the GC, because if the semantics
182 above are followed you don't need to lock anything in the GC. The risk is
183 rather that the GC will access data structures in an intermediate state.)
185 This approach requires more care and awareness in the VM than
186 safe-pointing. Because the GC and debugger are fairly intrusive, there
187 really aren't any internal VM resources that aren't shared. Thus, the
188 enter/exit critical calls can be added to internal mutex wrappers, which
189 makes it easy to get #1 and #2 right.
191 An ordering should be established for all locks to avoid deadlocks.
193 Monitor locks, which are also implemented with pthread calls, should not
194 cause any problems here. Threads fighting over such locks will not be in
195 critical sections and can be suspended freely.
197 This can get tricky if we ever need exclusive access to VM and non-VM
198 resources at the same time. It's not clear if this is a real concern.
200 There are (at least) two ways to handle the incoming signals:
202 (a) Always accept signals. If we're in a critical section, the signal
203 handler just returns without doing anything (the "suspend level"
204 should have been incremented before the signal was sent). Otherwise,
205 if the "suspend level" is nonzero, we go to sleep.
206 (b) Block signals in critical sections. This ensures that we can't be
207 interrupted in a critical section, but requires pthread_sigmask()
208 calls on entry and exit.
210 This is a choice between blocking the message and blocking the messenger.
211 Because UNIX signals are unreliable (you can only know that you have been
212 signaled, not whether you were signaled once or 10 times), the choice is
213 not significant for correctness. The choice depends on the efficiency
214 of pthread_sigmask() and the desire to actually block signals. Either way,
215 it is best to ensure that there is only one indication of "blocked";
216 having two (i.e. block signals and set a flag, then only send a signal
217 if the flag isn't set) can lead to race conditions.
219 The signal handler must take care to copy registers onto the stack (via
220 setjmp), so that stack scans find all references. Because we have to scan
221 native stacks, "exact" GC is not possible with this approach.
223 Some other concerns with flinging signals around:
224 - Odd interactions with some debuggers (e.g. gdb on the Mac)
225 - Restrictions on some standard library calls during GC (e.g. don't
226 use printf on stdout to print GC debug messages)
229 #define kMaxThreadId ((1 << 16) - 1)
230 #define kMainThreadId 1
233 static Thread* allocThread(int interpStackSize);
234 static bool prepareThread(Thread* thread);
235 static void setThreadSelf(Thread* thread);
236 static void unlinkThread(Thread* thread);
237 static void freeThread(Thread* thread);
238 static void assignThreadId(Thread* thread);
239 static bool createFakeEntryFrame(Thread* thread);
240 static bool createFakeRunFrame(Thread* thread);
241 static void* interpThreadStart(void* arg);
242 static void* internalThreadStart(void* arg);
243 static void threadExitUncaughtException(Thread* thread, Object* group);
244 static void threadExitCheck(void* arg);
245 static void waitForThreadSuspend(Thread* self, Thread* thread);
248 * Initialize thread list and main thread's environment. We need to set
249 * up some basic stuff so that dvmThreadSelf() will work when we start
250 * loading classes (e.g. to check for exceptions).
252 bool dvmThreadStartup()
256 /* allocate a TLS slot */
257 if (pthread_key_create(&gDvm.pthreadKeySelf, threadExitCheck) != 0) {
258 ALOGE("ERROR: pthread_key_create failed");
262 /* test our pthread lib */
263 if (pthread_getspecific(gDvm.pthreadKeySelf) != NULL)
264 ALOGW("WARNING: newly-created pthread TLS slot is not NULL");
266 /* prep thread-related locks and conditions */
267 dvmInitMutex(&gDvm.threadListLock);
268 pthread_cond_init(&gDvm.threadStartCond, NULL);
269 pthread_cond_init(&gDvm.vmExitCond, NULL);
270 dvmInitMutex(&gDvm._threadSuspendLock);
271 dvmInitMutex(&gDvm.threadSuspendCountLock);
272 pthread_cond_init(&gDvm.threadSuspendCountCond, NULL);
275 * Dedicated monitor for Thread.sleep().
276 * TODO: change this to an Object* so we don't have to expose this
277 * call, and we interact better with JDWP monitor calls. Requires
278 * deferring the object creation to much later (e.g. final "main"
279 * thread prep) or until first use.
281 gDvm.threadSleepMon = dvmCreateMonitor(NULL);
283 gDvm.threadIdMap = dvmAllocBitVector(kMaxThreadId, false);
285 thread = allocThread(gDvm.mainThreadStackSize);
289 /* switch mode for when we run initializers */
290 thread->status = THREAD_RUNNING;
293 * We need to assign the threadId early so we can lock/notify
294 * object monitors. We'll set the "threadObj" field later.
296 prepareThread(thread);
297 gDvm.threadList = thread;
299 #ifdef COUNT_PRECISE_METHODS
300 gDvm.preciseMethods = dvmPointerSetAlloc(200);
307 * All threads should be stopped by now. Clean up some thread globals.
309 void dvmThreadShutdown()
311 if (gDvm.threadList != NULL) {
313 * If we walk through the thread list and try to free the
314 * lingering thread structures (which should only be for daemon
315 * threads), the daemon threads may crash if they execute before
316 * the process dies. Let them leak.
318 freeThread(gDvm.threadList);
319 gDvm.threadList = NULL;
322 dvmFreeBitVector(gDvm.threadIdMap);
324 dvmFreeMonitorList();
326 pthread_key_delete(gDvm.pthreadKeySelf);
331 * Grab the suspend count global lock.
333 static inline void lockThreadSuspendCount()
336 * Don't try to change to VMWAIT here. When we change back to RUNNING
337 * we have to check for a pending suspend, which results in grabbing
338 * this lock recursively. Doesn't work with "fast" pthread mutexes.
340 * This lock is always held for very brief periods, so as long as
341 * mutex ordering is respected we shouldn't stall.
343 dvmLockMutex(&gDvm.threadSuspendCountLock);
347 * Release the suspend count global lock.
349 static inline void unlockThreadSuspendCount()
351 dvmUnlockMutex(&gDvm.threadSuspendCountLock);
355 * Grab the thread list global lock.
357 * This is held while "suspend all" is trying to make everybody stop. If
358 * the shutdown is in progress, and somebody tries to grab the lock, they'll
359 * have to wait for the GC to finish. Therefore it's important that the
360 * thread not be in RUNNING mode.
362 * We don't have to check to see if we should be suspended once we have
363 * the lock. Nobody can suspend all threads without holding the thread list
364 * lock while they do it, so by definition there isn't a GC in progress.
366 * This function deliberately avoids the use of dvmChangeStatus(),
367 * which could grab threadSuspendCountLock. To avoid deadlock, threads
368 * are required to grab the thread list lock before the thread suspend
369 * count lock. (See comment in DvmGlobals.)
371 * TODO: consider checking for suspend after acquiring the lock, and
372 * backing off if set. As stated above, it can't happen during normal
373 * execution, but it *can* happen during shutdown when daemon threads
374 * are being suspended.
376 void dvmLockThreadList(Thread* self)
378 ThreadStatus oldStatus;
380 if (self == NULL) /* try to get it from TLS */
381 self = dvmThreadSelf();
384 oldStatus = self->status;
385 self->status = THREAD_VMWAIT;
387 /* happens during VM shutdown */
388 oldStatus = THREAD_UNDEFINED; // shut up gcc
391 dvmLockMutex(&gDvm.threadListLock);
394 self->status = oldStatus;
398 * Try to lock the thread list.
400 * Returns "true" if we locked it. This is a "fast" mutex, so if the
401 * current thread holds the lock this will fail.
403 bool dvmTryLockThreadList()
405 return (dvmTryLockMutex(&gDvm.threadListLock) == 0);
409 * Release the thread list global lock.
411 void dvmUnlockThreadList()
413 dvmUnlockMutex(&gDvm.threadListLock);
417 * Convert SuspendCause to a string.
419 static const char* getSuspendCauseStr(SuspendCause why)
422 case SUSPEND_NOT: return "NOT?";
423 case SUSPEND_FOR_GC: return "gc";
424 case SUSPEND_FOR_DEBUG: return "debug";
425 case SUSPEND_FOR_DEBUG_EVENT: return "debug-event";
426 case SUSPEND_FOR_STACK_DUMP: return "stack-dump";
427 case SUSPEND_FOR_VERIFY: return "verify";
428 case SUSPEND_FOR_HPROF: return "hprof";
429 #if defined(WITH_JIT)
430 case SUSPEND_FOR_TBL_RESIZE: return "table-resize";
431 case SUSPEND_FOR_IC_PATCH: return "inline-cache-patch";
432 case SUSPEND_FOR_CC_RESET: return "reset-code-cache";
433 case SUSPEND_FOR_REFRESH: return "refresh jit status";
435 default: return "UNKNOWN";
440 * Grab the "thread suspend" lock. This is required to prevent the
441 * GC and the debugger from simultaneously suspending all threads.
443 * If we fail to get the lock, somebody else is trying to suspend all
444 * threads -- including us. If we go to sleep on the lock we'll deadlock
445 * the VM. Loop until we get it or somebody puts us to sleep.
447 static void lockThreadSuspend(const char* who, SuspendCause why)
449 const int kSpinSleepTime = 3*1000*1000; /* 3s */
450 u8 startWhen = 0; // init req'd to placate gcc
455 cc = dvmTryLockMutex(&gDvm._threadSuspendLock);
457 Thread* self = dvmThreadSelf();
459 if (!dvmCheckSuspendPending(self)) {
461 * Could be that a resume-all is in progress, and something
462 * grabbed the CPU when the wakeup was broadcast. The thread
463 * performing the resume hasn't had a chance to release the
464 * thread suspend lock. (We release before the broadcast,
465 * so this should be a narrow window.)
467 * Could be we hit the window as a suspend was started,
468 * and the lock has been grabbed but the suspend counts
469 * haven't been incremented yet.
471 * Could be an unusual JNI thread-attach thing.
473 * Could be the debugger telling us to resume at roughly
474 * the same time we're posting an event.
476 * Could be two app threads both want to patch predicted
477 * chaining cells around the same time.
479 ALOGI("threadid=%d ODD: want thread-suspend lock (%s:%s),"
480 " it's held, no suspend pending",
481 self->threadId, who, getSuspendCauseStr(why));
483 /* we suspended; reset timeout */
487 /* give the lock-holder a chance to do some work */
489 startWhen = dvmGetRelativeTimeUsec();
490 if (!dvmIterativeSleep(sleepIter++, kSpinSleepTime, startWhen)) {
491 ALOGE("threadid=%d: couldn't get thread-suspend lock (%s:%s),"
493 self->threadId, who, getSuspendCauseStr(why));
494 /* threads are not suspended, thread dump could crash */
495 dvmDumpAllThreads(false);
504 * Release the "thread suspend" lock.
506 static inline void unlockThreadSuspend()
508 dvmUnlockMutex(&gDvm._threadSuspendLock);
513 * Kill any daemon threads that still exist. All of ours should be
514 * stopped, so these should be Thread objects or JNI-attached threads
515 * started by the application. Actively-running threads are likely
516 * to crash the process if they continue to execute while the VM
517 * shuts down, so we really need to kill or suspend them. (If we want
518 * the VM to restart within this process, we need to kill them, but that
519 * leaves open the possibility of orphaned resources.)
521 * Waiting for the thread to suspend may be unwise at this point, but
522 * if one of these is wedged in a critical section then we probably
523 * would've locked up on the last GC attempt.
525 * It's possible for this function to get called after a failed
526 * initialization, so be careful with assumptions about the environment.
528 * This will be called from whatever thread calls DestroyJavaVM, usually
529 * but not necessarily the main thread. It's likely, but not guaranteed,
530 * that the current thread has already been cleaned up.
532 void dvmSlayDaemons()
534 Thread* self = dvmThreadSelf(); // may be null
539 dvmLockThreadList(self);
542 threadId = self->threadId;
544 target = gDvm.threadList;
545 while (target != NULL) {
546 if (target == self) {
547 target = target->next;
551 if (!dvmGetFieldBoolean(target->threadObj,
552 gDvm.offJavaLangThread_daemon))
554 /* should never happen; suspend it with the rest */
555 ALOGW("threadid=%d: non-daemon id=%d still running at shutdown?!",
556 threadId, target->threadId);
559 std::string threadName(dvmGetThreadName(target));
560 ALOGV("threadid=%d: suspending daemon id=%d name='%s'",
561 threadId, target->threadId, threadName.c_str());
563 /* mark as suspended */
564 lockThreadSuspendCount();
565 dvmAddToSuspendCounts(target, 1, 0);
566 unlockThreadSuspendCount();
569 target = target->next;
572 //dvmDumpAllThreads(false);
575 * Unlock the thread list, relocking it later if necessary. It's
576 * possible a thread is in VMWAIT after calling dvmLockThreadList,
577 * and that function *doesn't* check for pending suspend after
578 * acquiring the lock. We want to let them finish their business
579 * and see the pending suspend before we continue here.
581 * There's no guarantee of mutex fairness, so this might not work.
582 * (The alternative is to have dvmLockThreadList check for suspend
583 * after acquiring the lock and back off, something we should consider.)
585 dvmUnlockThreadList();
588 bool complained = false;
592 dvmLockThreadList(self);
595 * Sleep for a bit until the threads have suspended. We're trying
596 * to exit, so don't wait for too long.
599 for (i = 0; i < 10; i++) {
600 bool allSuspended = true;
602 target = gDvm.threadList;
603 while (target != NULL) {
604 if (target == self) {
605 target = target->next;
609 if (target->status == THREAD_RUNNING) {
611 ALOGD("threadid=%d not ready yet", target->threadId);
612 allSuspended = false;
613 /* keep going so we log each running daemon once */
616 target = target->next;
620 ALOGV("threadid=%d: all daemons have suspended", threadId);
625 ALOGD("threadid=%d: waiting briefly for daemon suspension",
632 dvmUnlockThreadList();
635 #if 0 /* bad things happen if they come out of JNI or "spuriously" wake up */
637 * Abandon the threads and recover their resources.
639 target = gDvm.threadList;
640 while (target != NULL) {
641 Thread* nextTarget = target->next;
642 unlinkThread(target);
648 //dvmDumpAllThreads(true);
653 * Finish preparing the parts of the Thread struct required to support
656 bool dvmPrepMainForJni(JNIEnv* pEnv)
660 /* main thread is always first in list at this point */
661 self = gDvm.threadList;
662 assert(self->threadId == kMainThreadId);
664 /* create a "fake" JNI frame at the top of the main thread interp stack */
665 if (!createFakeEntryFrame(self))
668 /* fill these in, since they weren't ready at dvmCreateJNIEnv time */
669 dvmSetJniEnvThreadId(pEnv, self);
670 dvmSetThreadJNIEnv(self, (JNIEnv*) pEnv);
677 * Finish preparing the main thread, allocating some objects to represent
678 * it. As part of doing so, we finish initializing Thread and ThreadGroup.
679 * This will execute some interpreted code (e.g. class initializers).
681 bool dvmPrepMainThread()
687 StringObject* threadNameStr;
691 ALOGV("+++ finishing prep on main VM thread");
693 /* main thread is always first in list at this point */
694 thread = gDvm.threadList;
695 assert(thread->threadId == kMainThreadId);
698 * Make sure the classes are initialized. We have to do this before
699 * we create an instance of them.
701 if (!dvmInitClass(gDvm.classJavaLangClass)) {
702 ALOGE("'Class' class failed to initialize");
705 if (!dvmInitClass(gDvm.classJavaLangThreadGroup) ||
706 !dvmInitClass(gDvm.classJavaLangThread) ||
707 !dvmInitClass(gDvm.classJavaLangVMThread))
709 ALOGE("thread classes failed to initialize");
713 groupObj = dvmGetMainThreadGroup();
714 if (groupObj == NULL)
718 * Allocate and construct a Thread with the internal-creation
721 threadObj = dvmAllocObject(gDvm.classJavaLangThread, ALLOC_DEFAULT);
722 if (threadObj == NULL) {
723 ALOGE("unable to allocate main thread object");
726 dvmReleaseTrackedAlloc(threadObj, NULL);
728 threadNameStr = dvmCreateStringFromCstr("main");
729 if (threadNameStr == NULL)
731 dvmReleaseTrackedAlloc((Object*)threadNameStr, NULL);
733 init = dvmFindDirectMethodByDescriptor(gDvm.classJavaLangThread, "<init>",
734 "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
735 assert(init != NULL);
736 dvmCallMethod(thread, init, threadObj, &unused, groupObj, threadNameStr,
737 THREAD_NORM_PRIORITY, false);
738 if (dvmCheckException(thread)) {
739 ALOGE("exception thrown while constructing main thread object");
744 * Allocate and construct a VMThread.
746 vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
747 if (vmThreadObj == NULL) {
748 ALOGE("unable to allocate main vmthread object");
751 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
753 init = dvmFindDirectMethodByDescriptor(gDvm.classJavaLangVMThread, "<init>",
754 "(Ljava/lang/Thread;)V");
755 dvmCallMethod(thread, init, vmThreadObj, &unused, threadObj);
756 if (dvmCheckException(thread)) {
757 ALOGE("exception thrown while constructing main vmthread object");
761 /* set the VMThread.vmData field to our Thread struct */
762 assert(gDvm.offJavaLangVMThread_vmData != 0);
763 dvmSetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData, (u4)thread);
766 * Stuff the VMThread back into the Thread. From this point on, other
767 * Threads will see that this Thread is running (at least, they would,
768 * if there were any).
770 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread,
773 thread->threadObj = threadObj;
776 * Set the "context class loader" field in the system class loader.
778 * Retrieving the system class loader will cause invocation of
779 * ClassLoader.getSystemClassLoader(), which could conceivably call
780 * Thread.currentThread(), so we want the Thread to be fully configured
783 Object* systemLoader = dvmGetSystemClassLoader();
784 if (systemLoader == NULL) {
785 ALOGW("WARNING: system class loader is NULL (setting main ctxt)");
788 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_contextClassLoader,
790 dvmReleaseTrackedAlloc(systemLoader, NULL);
793 /* include self in non-daemon threads (mainly for AttachCurrentThread) */
794 gDvm.nonDaemonThreadCount++;
801 * Alloc and initialize a Thread struct.
803 * Does not create any objects, just stuff on the system (malloc) heap.
805 static Thread* allocThread(int interpStackSize)
810 thread = (Thread*) calloc(1, sizeof(Thread));
814 /* Check sizes and alignment */
815 assert((((uintptr_t)&thread->interpBreak.all) & 0x7) == 0);
816 assert(sizeof(thread->interpBreak) == sizeof(thread->interpBreak.all));
819 #if defined(WITH_SELF_VERIFICATION)
820 if (dvmSelfVerificationShadowSpaceAlloc(thread) == NULL)
824 assert(interpStackSize >= kMinStackSize && interpStackSize <=kMaxStackSize);
826 thread->status = THREAD_INITIALIZING;
829 * Allocate and initialize the interpreted code stack. We essentially
830 * "lose" the alloc pointer, which points at the bottom of the stack,
831 * but we can get it back later because we know how big the stack is.
833 * The stack must be aligned on a 4-byte boundary.
835 #ifdef MALLOC_INTERP_STACK
836 stackBottom = (u1*) malloc(interpStackSize);
837 if (stackBottom == NULL) {
838 #if defined(WITH_SELF_VERIFICATION)
839 dvmSelfVerificationShadowSpaceFree(thread);
844 memset(stackBottom, 0xc5, interpStackSize); // stop valgrind complaints
846 stackBottom = (u1*) mmap(NULL, interpStackSize, PROT_READ | PROT_WRITE,
847 MAP_PRIVATE | MAP_ANON, -1, 0);
848 if (stackBottom == MAP_FAILED) {
849 #if defined(WITH_SELF_VERIFICATION)
850 dvmSelfVerificationShadowSpaceFree(thread);
857 assert(((u4)stackBottom & 0x03) == 0); // looks like our malloc ensures this
858 thread->interpStackSize = interpStackSize;
859 thread->interpStackStart = stackBottom + interpStackSize;
860 thread->interpStackEnd = stackBottom + STACK_OVERFLOW_RESERVE;
862 #ifndef DVM_NO_ASM_INTERP
863 thread->mainHandlerTable = dvmAsmInstructionStart;
864 thread->altHandlerTable = dvmAsmAltInstructionStart;
865 thread->interpBreak.ctl.curHandlerTable = thread->mainHandlerTable;
868 /* give the thread code a chance to set things up */
869 dvmInitInterpStack(thread, interpStackSize);
871 /* One-time setup for interpreter/JIT state */
872 dvmInitInterpreterState(thread);
878 * Get a meaningful thread ID. At present this only has meaning under Linux,
879 * where getpid() and gettid() sometimes agree and sometimes don't depending
880 * on your thread model (try "export LD_ASSUME_KERNEL=2.4.19").
882 pid_t dvmGetSysThreadId()
892 * Finish initialization of a Thread struct.
894 * This must be called while executing in the new thread, but before the
895 * thread is added to the thread list.
897 * NOTE: The threadListLock must be held by the caller (needed for
900 static bool prepareThread(Thread* thread)
902 assignThreadId(thread);
903 thread->handle = pthread_self();
904 thread->systemTid = dvmGetSysThreadId();
906 //ALOGI("SYSTEM TID IS %d (pid is %d)", (int) thread->systemTid,
909 * If we were called by dvmAttachCurrentThread, the self value is
910 * already correctly established as "thread".
912 setThreadSelf(thread);
914 ALOGV("threadid=%d: interp stack at %p",
915 thread->threadId, thread->interpStackStart - thread->interpStackSize);
918 * Initialize invokeReq.
920 dvmInitMutex(&thread->invokeReq.lock);
921 pthread_cond_init(&thread->invokeReq.cv, NULL);
924 * Initialize our reference tracking tables.
926 * Most threads won't use jniMonitorRefTable, so we clear out the
927 * structure but don't call the init function (which allocs storage).
929 if (!thread->jniLocalRefTable.init(kJniLocalRefMin,
930 kJniLocalRefMax, kIndirectKindLocal)) {
933 if (!dvmInitReferenceTable(&thread->internalLocalRefTable,
934 kInternalRefDefault, kInternalRefMax))
937 memset(&thread->jniMonitorRefTable, 0, sizeof(thread->jniMonitorRefTable));
939 pthread_cond_init(&thread->waitCond, NULL);
940 dvmInitMutex(&thread->waitMutex);
942 /* Initialize safepoint callback mechanism */
943 dvmInitMutex(&thread->callbackMutex);
949 * Remove a thread from the internal list.
950 * Clear out the links to make it obvious that the thread is
951 * no longer on the list. Caller must hold gDvm.threadListLock.
953 static void unlinkThread(Thread* thread)
955 LOG_THREAD("threadid=%d: removing from list", thread->threadId);
956 if (thread == gDvm.threadList) {
957 assert(thread->prev == NULL);
958 gDvm.threadList = thread->next;
960 assert(thread->prev != NULL);
961 thread->prev->next = thread->next;
963 if (thread->next != NULL)
964 thread->next->prev = thread->prev;
965 thread->prev = thread->next = NULL;
969 * Free a Thread struct, and all the stuff allocated within.
971 static void freeThread(Thread* thread)
976 /* thread->threadId is zero at this point */
977 LOGVV("threadid=%d: freeing", thread->threadId);
979 if (thread->interpStackStart != NULL) {
980 u1* interpStackBottom;
982 interpStackBottom = thread->interpStackStart;
983 interpStackBottom -= thread->interpStackSize;
984 #ifdef MALLOC_INTERP_STACK
985 free(interpStackBottom);
987 if (munmap(interpStackBottom, thread->interpStackSize) != 0)
988 ALOGW("munmap(thread stack) failed");
992 thread->jniLocalRefTable.destroy();
993 dvmClearReferenceTable(&thread->internalLocalRefTable);
994 if (&thread->jniMonitorRefTable.table != NULL)
995 dvmClearReferenceTable(&thread->jniMonitorRefTable);
997 #if defined(WITH_SELF_VERIFICATION)
998 dvmSelfVerificationShadowSpaceFree(thread);
1004 * Like pthread_self(), but on a Thread*.
1006 Thread* dvmThreadSelf()
1008 return (Thread*) pthread_getspecific(gDvm.pthreadKeySelf);
1012 * Explore our sense of self. Stuffs the thread pointer into TLS.
1014 static void setThreadSelf(Thread* thread)
1018 cc = pthread_setspecific(gDvm.pthreadKeySelf, thread);
1021 * Sometimes this fails under Bionic with EINVAL during shutdown.
1022 * This can happen if the timing is just right, e.g. a thread
1023 * fails to attach during shutdown, but the "fail" path calls
1024 * here to ensure we clean up after ourselves.
1026 if (thread != NULL) {
1027 ALOGE("pthread_setspecific(%p) failed, err=%d", thread, cc);
1028 dvmAbort(); /* the world is fundamentally hosed */
1034 * This is associated with the pthreadKeySelf key. It's called by the
1035 * pthread library when a thread is exiting and the "self" pointer in TLS
1036 * is non-NULL, meaning the VM hasn't had a chance to clean up. In normal
1037 * operation this will not be called.
1039 * This is mainly of use to ensure that we don't leak resources if, for
1040 * example, a thread attaches itself to us with AttachCurrentThread and
1041 * then exits without notifying the VM.
1043 * We could do the detach here instead of aborting, but this will lead to
1044 * portability problems. Other implementations do not do this check and
1045 * will simply be unaware that the thread has exited, leading to resource
1046 * leaks (and, if this is a non-daemon thread, an infinite hang when the
1047 * VM tries to shut down).
1049 * Because some implementations may want to use the pthread destructor
1050 * to initiate the detach, and the ordering of destructors is not defined,
1051 * we want to iterate a couple of times to give those a chance to run.
1053 static void threadExitCheck(void* arg)
1055 const int kMaxCount = 2;
1057 Thread* self = (Thread*) arg;
1058 assert(self != NULL);
1060 ALOGV("threadid=%d: threadExitCheck(%p) count=%d",
1061 self->threadId, arg, self->threadExitCheckCount);
1063 if (self->status == THREAD_ZOMBIE) {
1064 ALOGW("threadid=%d: Weird -- shouldn't be in threadExitCheck",
1069 if (self->threadExitCheckCount < kMaxCount) {
1071 * Spin a couple of times to let other destructors fire.
1073 ALOGD("threadid=%d: thread exiting, not yet detached (count=%d)",
1074 self->threadId, self->threadExitCheckCount);
1075 self->threadExitCheckCount++;
1076 int cc = pthread_setspecific(gDvm.pthreadKeySelf, self);
1078 ALOGE("threadid=%d: unable to re-add thread to TLS",
1083 ALOGE("threadid=%d: native thread exited without detaching",
1091 * Assign the threadId. This needs to be a small integer so that our
1092 * "thin" locks fit in a small number of bits.
1094 * We reserve zero for use as an invalid ID.
1096 * This must be called with threadListLock held.
1098 static void assignThreadId(Thread* thread)
1101 * Find a small unique integer. threadIdMap is a vector of
1102 * kMaxThreadId bits; dvmAllocBit() returns the index of a
1103 * bit, meaning that it will always be < kMaxThreadId.
1105 int num = dvmAllocBit(gDvm.threadIdMap);
1107 ALOGE("Ran out of thread IDs");
1108 dvmAbort(); // TODO: make this a non-fatal error result
1111 thread->threadId = num + 1;
1113 assert(thread->threadId != 0);
1117 * Give back the thread ID.
1119 static void releaseThreadId(Thread* thread)
1121 assert(thread->threadId > 0);
1122 dvmClearBit(gDvm.threadIdMap, thread->threadId - 1);
1123 thread->threadId = 0;
1128 * Add a stack frame that makes it look like the native code in the main
1129 * thread was originally invoked from interpreted code. This gives us a
1130 * place to hang JNI local references. The VM spec says (v2 5.2) that the
1131 * VM begins by executing "main" in a class, so in a way this brings us
1132 * closer to the spec.
1134 static bool createFakeEntryFrame(Thread* thread)
1137 * Because we are creating a frame that represents application code, we
1138 * want to stuff the application class loader into the method's class
1139 * loader field, even though we're using the system class loader to
1140 * load it. This makes life easier over in JNI FindClass (though it
1141 * could bite us in other ways).
1143 * Unfortunately this is occurring too early in the initialization,
1144 * of necessity coming before JNI is initialized, and we're not quite
1145 * ready to set up the application class loader. Also, overwriting
1146 * the class' defining classloader pointer seems unwise.
1148 * Instead, we save a pointer to the method and explicitly check for
1149 * it in FindClass. The method is private so nobody else can call it.
1152 assert(thread->threadId == kMainThreadId); /* main thread only */
1154 if (!dvmPushJNIFrame(thread, gDvm.methDalvikSystemNativeStart_main))
1158 * Null out the "String[] args" argument.
1160 assert(gDvm.methDalvikSystemNativeStart_main->registersSize == 1);
1161 u4* framePtr = (u4*) thread->interpSave.curFrame;
1169 * Add a stack frame that makes it look like the native thread has been
1170 * executing interpreted code. This gives us a place to hang JNI local
1173 static bool createFakeRunFrame(Thread* thread)
1175 return dvmPushJNIFrame(thread, gDvm.methDalvikSystemNativeStart_run);
1179 * Helper function to set the name of the current thread
1181 static void setThreadName(const char *threadName)
1185 const char *s = threadName;
1187 if (*s == '.') hasDot = 1;
1188 else if (*s == '@') hasAt = 1;
1191 int len = s - threadName;
1192 if (len < 15 || hasAt || !hasDot) {
1195 s = threadName + len - 15;
1197 #if defined(HAVE_ANDROID_PTHREAD_SETNAME_NP)
1198 /* pthread_setname_np fails rather than truncating long strings */
1199 char buf[16]; // MAX_TASK_COMM_LEN=16 is hard-coded into bionic
1200 strncpy(buf, s, sizeof(buf)-1);
1201 buf[sizeof(buf)-1] = '\0';
1202 int err = pthread_setname_np(pthread_self(), buf);
1204 ALOGW("Unable to set the name of current thread to '%s': %s",
1205 buf, strerror(err));
1207 #elif defined(HAVE_PRCTL)
1208 prctl(PR_SET_NAME, (unsigned long) s, 0, 0, 0);
1210 ALOGD("No way to set current thread's name (%s)", s);
1215 * Create a thread as a result of java.lang.Thread.start().
1217 * We do have to worry about some concurrency problems, e.g. programs
1218 * that try to call Thread.start() on the same object from multiple threads.
1219 * (This will fail for all but one, but we have to make sure that it succeeds
1222 * Some of the complexity here arises from our desire to mimic the
1223 * Thread vs. VMThread class decomposition we inherited. We've been given
1224 * a Thread, and now we need to create a VMThread and then populate both
1225 * objects. We also need to create one of our internal Thread objects.
1227 * Pass in a stack size of 0 to get the default.
1229 * The "threadObj" reference must be pinned by the caller to prevent the GC
1230 * from moving it around (e.g. added to the tracked allocation list).
1232 bool dvmCreateInterpThread(Object* threadObj, int reqStackSize)
1234 assert(threadObj != NULL);
1236 Thread* self = dvmThreadSelf();
1238 if (reqStackSize == 0)
1239 stackSize = gDvm.stackSize;
1240 else if (reqStackSize < kMinStackSize)
1241 stackSize = kMinStackSize;
1242 else if (reqStackSize > kMaxStackSize)
1243 stackSize = kMaxStackSize;
1245 stackSize = reqStackSize;
1247 pthread_attr_t threadAttr;
1248 pthread_attr_init(&threadAttr);
1249 pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
1252 * To minimize the time spent in the critical section, we allocate the
1253 * vmThread object here.
1255 Object* vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
1256 if (vmThreadObj == NULL)
1259 Thread* newThread = allocThread(stackSize);
1260 if (newThread == NULL) {
1261 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1265 newThread->threadObj = threadObj;
1267 assert(newThread->status == THREAD_INITIALIZING);
1270 * We need to lock out other threads while we test and set the
1271 * "vmThread" field in java.lang.Thread, because we use that to determine
1272 * if this thread has been started before. We use the thread list lock
1273 * because it's handy and we're going to need to grab it again soon
1276 dvmLockThreadList(self);
1278 if (dvmGetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread) != NULL) {
1279 dvmUnlockThreadList();
1280 dvmThrowIllegalThreadStateException(
1281 "thread has already been started");
1282 freeThread(newThread);
1283 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1288 * There are actually three data structures: Thread (object), VMThread
1289 * (object), and Thread (C struct). All of them point to at least one
1292 * As soon as "VMThread.vmData" is assigned, other threads can start
1293 * making calls into us (e.g. setPriority).
1295 dvmSetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData, (u4)newThread);
1296 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread, vmThreadObj);
1299 * Thread creation might take a while, so release the lock.
1301 dvmUnlockThreadList();
1303 ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
1304 pthread_t threadHandle;
1305 int cc = pthread_create(&threadHandle, &threadAttr, interpThreadStart, newThread);
1306 pthread_attr_destroy(&threadAttr);
1307 dvmChangeStatus(self, oldStatus);
1311 * Failure generally indicates that we have exceeded system
1312 * resource limits. VirtualMachineError is probably too severe,
1313 * so use OutOfMemoryError.
1316 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread, NULL);
1318 ALOGE("pthread_create (stack size %d bytes) failed: %s", stackSize, strerror(cc));
1319 dvmThrowExceptionFmt(gDvm.exOutOfMemoryError,
1320 "pthread_create (stack size %d bytes) failed: %s",
1321 stackSize, strerror(cc));
1326 * We need to wait for the thread to start. Otherwise, depending on
1327 * the whims of the OS scheduler, we could return and the code in our
1328 * thread could try to do operations on the new thread before it had
1329 * finished starting.
1331 * The new thread will lock the thread list, change its state to
1332 * THREAD_STARTING, broadcast to gDvm.threadStartCond, and then sleep
1333 * on gDvm.threadStartCond (which uses the thread list lock). This
1334 * thread (the parent) will either see that the thread is already ready
1335 * after we grab the thread list lock, or will be awakened from the
1336 * condition variable on the broadcast.
1338 * We don't want to stall the rest of the VM while the new thread
1339 * starts, which can happen if the GC wakes up at the wrong moment.
1340 * So, we change our own status to VMWAIT, and self-suspend if
1341 * necessary after we finish adding the new thread.
1344 * We have to deal with an odd race with the GC/debugger suspension
1345 * mechanism when creating a new thread. The information about whether
1346 * or not a thread should be suspended is contained entirely within
1347 * the Thread struct; this is usually cleaner to deal with than having
1348 * one or more globally-visible suspension flags. The trouble is that
1349 * we could create the thread while the VM is trying to suspend all
1350 * threads. The suspend-count won't be nonzero for the new thread,
1351 * so dvmChangeStatus(THREAD_RUNNING) won't cause a suspension.
1353 * The easiest way to deal with this is to prevent the new thread from
1354 * running until the parent says it's okay. This results in the
1355 * following (correct) sequence of events for a "badly timed" GC
1356 * (where '-' is us, 'o' is the child, and '+' is some other thread):
1358 * - call pthread_create()
1359 * - lock thread list
1360 * - put self into THREAD_VMWAIT so GC doesn't wait for us
1361 * - sleep on condition var (mutex = thread list lock) until child starts
1362 * + GC triggered by another thread
1363 * + thread list locked; suspend counts updated; thread list unlocked
1364 * + loop waiting for all runnable threads to suspend
1365 * + success, start GC
1366 * o child thread wakes, signals condition var to wake parent
1367 * o child waits for parent ack on condition variable
1368 * - we wake up, locking thread list
1369 * - add child to thread list
1370 * - unlock thread list
1371 * - change our state back to THREAD_RUNNING; GC causes us to suspend
1372 * + GC finishes; all threads in thread list are resumed
1373 * - lock thread list
1374 * - set child to THREAD_VMWAIT, and signal it to start
1375 * - unlock thread list
1377 * o child changes state to THREAD_RUNNING
1379 * The above shows the GC starting up during thread creation, but if
1380 * it starts anywhere after VMThread.create() is called it will
1381 * produce the same series of events.
1383 * Once the child is in the thread list, it will be suspended and
1384 * resumed like any other thread. In the above scenario the resume-all
1385 * code will try to resume the new thread, which was never actually
1386 * suspended, and try to decrement the child's thread suspend count to -1.
1387 * We can catch this in the resume-all code.
1389 * Bouncing back and forth between threads like this adds a small amount
1390 * of scheduler overhead to thread startup.
1392 * One alternative to having the child wait for the parent would be
1393 * to have the child inherit the parents' suspension count. This
1394 * would work for a GC, since we can safely assume that the parent
1395 * thread didn't cause it, but we must only do so if the parent suspension
1396 * was caused by a suspend-all. If the parent was being asked to
1397 * suspend singly by the debugger, the child should not inherit the value.
1399 * We could also have a global "new thread suspend count" that gets
1400 * picked up by new threads before changing state to THREAD_RUNNING.
1401 * This would be protected by the thread list lock and set by a
1404 dvmLockThreadList(self);
1405 assert(self->status == THREAD_RUNNING);
1406 self->status = THREAD_VMWAIT;
1407 while (newThread->status != THREAD_STARTING)
1408 pthread_cond_wait(&gDvm.threadStartCond, &gDvm.threadListLock);
1410 LOG_THREAD("threadid=%d: adding to list", newThread->threadId);
1411 newThread->next = gDvm.threadList->next;
1412 if (newThread->next != NULL)
1413 newThread->next->prev = newThread;
1414 newThread->prev = gDvm.threadList;
1415 gDvm.threadList->next = newThread;
1417 /* Add any existing global modes to the interpBreak control */
1418 dvmInitializeInterpBreak(newThread);
1420 if (!dvmGetFieldBoolean(threadObj, gDvm.offJavaLangThread_daemon))
1421 gDvm.nonDaemonThreadCount++; // guarded by thread list lock
1423 dvmUnlockThreadList();
1425 /* change status back to RUNNING, self-suspending if necessary */
1426 dvmChangeStatus(self, THREAD_RUNNING);
1429 * Tell the new thread to start.
1431 * We must hold the thread list lock before messing with another thread.
1432 * In the general case we would also need to verify that newThread was
1433 * still in the thread list, but in our case the thread has not started
1434 * executing user code and therefore has not had a chance to exit.
1436 * We move it to VMWAIT, and it then shifts itself to RUNNING, which
1437 * comes with a suspend-pending check.
1439 dvmLockThreadList(self);
1441 assert(newThread->status == THREAD_STARTING);
1442 newThread->status = THREAD_VMWAIT;
1443 pthread_cond_broadcast(&gDvm.threadStartCond);
1445 dvmUnlockThreadList();
1447 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1451 freeThread(newThread);
1452 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1457 * pthread entry function for threads started from interpreted code.
1459 static void* interpThreadStart(void* arg)
1461 Thread* self = (Thread*) arg;
1463 std::string threadName(dvmGetThreadName(self));
1464 setThreadName(threadName.c_str());
1467 * Finish initializing the Thread struct.
1469 dvmLockThreadList(self);
1470 prepareThread(self);
1472 LOG_THREAD("threadid=%d: created from interp", self->threadId);
1475 * Change our status and wake our parent, who will add us to the
1476 * thread list and advance our state to VMWAIT.
1478 self->status = THREAD_STARTING;
1479 pthread_cond_broadcast(&gDvm.threadStartCond);
1482 * Wait until the parent says we can go. Assuming there wasn't a
1483 * suspend pending, this will happen immediately. When it completes,
1484 * we're full-fledged citizens of the VM.
1486 * We have to use THREAD_VMWAIT here rather than THREAD_RUNNING
1487 * because the pthread_cond_wait below needs to reacquire a lock that
1488 * suspend-all is also interested in. If we get unlucky, the parent could
1489 * change us to THREAD_RUNNING, then a GC could start before we get
1490 * signaled, and suspend-all will grab the thread list lock and then
1491 * wait for us to suspend. We'll be in the tail end of pthread_cond_wait
1492 * trying to get the lock.
1494 while (self->status != THREAD_VMWAIT)
1495 pthread_cond_wait(&gDvm.threadStartCond, &gDvm.threadListLock);
1497 dvmUnlockThreadList();
1500 * Add a JNI context.
1502 self->jniEnv = dvmCreateJNIEnv(self);
1505 * Change our state so the GC will wait for us from now on. If a GC is
1506 * in progress this call will suspend us.
1508 dvmChangeStatus(self, THREAD_RUNNING);
1511 * Notify the debugger & DDM. The debugger notification may cause
1512 * us to suspend ourselves (and others). The thread state may change
1513 * to VMWAIT briefly if network packets are sent.
1515 if (gDvm.debuggerConnected)
1516 dvmDbgPostThreadStart(self);
1519 * Set the system thread priority according to the Thread object's
1520 * priority level. We don't usually need to do this, because both the
1521 * Thread object and system thread priorities inherit from parents. The
1522 * tricky case is when somebody creates a Thread object, calls
1523 * setPriority(), and then starts the thread. We could manage this with
1524 * a "needs priority update" flag to avoid the redundant call.
1526 int priority = dvmGetFieldInt(self->threadObj,
1527 gDvm.offJavaLangThread_priority);
1528 dvmChangeThreadPriority(self, priority);
1531 * Execute the "run" method.
1533 * At this point our stack is empty, so somebody who comes looking for
1534 * stack traces right now won't have much to look at. This is normal.
1536 Method* run = self->threadObj->clazz->vtable[gDvm.voffJavaLangThread_run];
1539 ALOGV("threadid=%d: calling run()", self->threadId);
1540 assert(strcmp(run->name, "run") == 0);
1541 dvmCallMethod(self, run, self->threadObj, &unused);
1542 ALOGV("threadid=%d: exiting", self->threadId);
1545 * Remove the thread from various lists, report its death, and free
1548 dvmDetachCurrentThread();
1554 * The current thread is exiting with an uncaught exception. The
1555 * Java programming language allows the application to provide a
1556 * thread-exit-uncaught-exception handler for the VM, for a specific
1557 * Thread, and for all threads in a ThreadGroup.
1559 * Version 1.5 added the per-thread handler. We need to call
1560 * "uncaughtException" in the handler object, which is either the
1561 * ThreadGroup object or the Thread-specific handler.
1563 * This should only be called when an exception is pending. Before
1564 * returning, the exception will be cleared.
1566 static void threadExitUncaughtException(Thread* self, Object* group)
1570 Method* uncaughtHandler;
1572 ALOGW("threadid=%d: thread exiting with uncaught exception (group=%p)",
1573 self->threadId, group);
1574 assert(group != NULL);
1577 * Get a pointer to the exception, then clear out the one in the
1578 * thread. We don't want to have it set when executing interpreted code.
1580 exception = dvmGetException(self);
1581 assert(exception != NULL);
1582 dvmAddTrackedAlloc(exception, self);
1583 dvmClearException(self);
1586 * Get the Thread's "uncaughtHandler" object. Use it if non-NULL;
1587 * else use "group" (which is an instance of UncaughtExceptionHandler).
1588 * The ThreadGroup will handle it directly or call the default
1589 * uncaught exception handler.
1591 handlerObj = dvmGetFieldObject(self->threadObj,
1592 gDvm.offJavaLangThread_uncaughtHandler);
1593 if (handlerObj == NULL)
1597 * Find the "uncaughtException" method in this object. The method
1598 * was declared in the Thread.UncaughtExceptionHandler interface.
1600 uncaughtHandler = dvmFindVirtualMethodHierByDescriptor(handlerObj->clazz,
1601 "uncaughtException", "(Ljava/lang/Thread;Ljava/lang/Throwable;)V");
1603 if (uncaughtHandler != NULL) {
1604 //ALOGI("+++ calling %s.uncaughtException",
1605 // handlerObj->clazz->descriptor);
1607 dvmCallMethod(self, uncaughtHandler, handlerObj, &unused,
1608 self->threadObj, exception);
1610 /* should be impossible, but handle it anyway */
1611 ALOGW("WARNING: no 'uncaughtException' method in class %s",
1612 handlerObj->clazz->descriptor);
1613 dvmSetException(self, exception);
1614 dvmLogExceptionStackTrace();
1617 /* if the uncaught handler threw, clear it */
1618 dvmClearException(self);
1620 dvmReleaseTrackedAlloc(exception, self);
1622 /* Remove this thread's suspendCount from global suspendCount sum */
1623 lockThreadSuspendCount();
1624 dvmAddToSuspendCounts(self, -self->suspendCount, 0);
1625 unlockThreadSuspendCount();
1630 * Create an internal VM thread, for things like JDWP and finalizers.
1632 * The easiest way to do this is create a new thread and then use the
1633 * JNI AttachCurrentThread implementation.
1635 * This does not return until after the new thread has begun executing.
1637 bool dvmCreateInternalThread(pthread_t* pHandle, const char* name,
1638 InternalThreadStart func, void* funcArg)
1640 InternalStartArgs* pArgs;
1641 Object* systemGroup;
1642 volatile Thread* newThread = NULL;
1643 volatile int createStatus = 0;
1645 systemGroup = dvmGetSystemThreadGroup();
1646 if (systemGroup == NULL)
1649 pArgs = (InternalStartArgs*) malloc(sizeof(*pArgs));
1651 pArgs->funcArg = funcArg;
1652 pArgs->name = strdup(name); // storage will be owned by new thread
1653 pArgs->group = systemGroup;
1654 pArgs->isDaemon = true;
1655 pArgs->pThread = &newThread;
1656 pArgs->pCreateStatus = &createStatus;
1658 pthread_attr_t threadAttr;
1659 pthread_attr_init(&threadAttr);
1661 int cc = pthread_create(pHandle, &threadAttr, internalThreadStart, pArgs);
1662 pthread_attr_destroy(&threadAttr);
1664 ALOGE("internal thread creation failed: %s", strerror(cc));
1671 * Wait for the child to start. This gives us an opportunity to make
1672 * sure that the thread started correctly, and allows our caller to
1673 * assume that the thread has started running.
1675 * Because we aren't holding a lock across the thread creation, it's
1676 * possible that the child will already have completed its
1677 * initialization. Because the child only adjusts "createStatus" while
1678 * holding the thread list lock, the initial condition on the "while"
1679 * loop will correctly avoid the wait if this occurs.
1681 * It's also possible that we'll have to wait for the thread to finish
1682 * being created, and as part of allocating a Thread object it might
1683 * need to initiate a GC. We switch to VMWAIT while we pause.
1685 Thread* self = dvmThreadSelf();
1686 ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
1687 dvmLockThreadList(self);
1688 while (createStatus == 0)
1689 pthread_cond_wait(&gDvm.threadStartCond, &gDvm.threadListLock);
1691 if (newThread == NULL) {
1692 ALOGW("internal thread create failed (createStatus=%d)", createStatus);
1693 assert(createStatus < 0);
1694 /* don't free pArgs -- if pthread_create succeeded, child owns it */
1695 dvmUnlockThreadList();
1696 dvmChangeStatus(self, oldStatus);
1700 /* thread could be in any state now (except early init states) */
1701 //assert(newThread->status == THREAD_RUNNING);
1703 dvmUnlockThreadList();
1704 dvmChangeStatus(self, oldStatus);
1710 * pthread entry function for internally-created threads.
1712 * We are expected to free "arg" and its contents. If we're a daemon
1713 * thread, and we get cancelled abruptly when the VM shuts down, the
1714 * storage won't be freed. If this becomes a concern we can make a copy
1717 static void* internalThreadStart(void* arg)
1719 InternalStartArgs* pArgs = (InternalStartArgs*) arg;
1720 JavaVMAttachArgs jniArgs;
1722 jniArgs.version = JNI_VERSION_1_2;
1723 jniArgs.name = pArgs->name;
1724 jniArgs.group = reinterpret_cast<jobject>(pArgs->group);
1726 setThreadName(pArgs->name);
1728 /* use local jniArgs as stack top */
1729 if (dvmAttachCurrentThread(&jniArgs, pArgs->isDaemon)) {
1731 * Tell the parent of our success.
1733 * threadListLock is the mutex for threadStartCond.
1735 dvmLockThreadList(dvmThreadSelf());
1736 *pArgs->pCreateStatus = 1;
1737 *pArgs->pThread = dvmThreadSelf();
1738 pthread_cond_broadcast(&gDvm.threadStartCond);
1739 dvmUnlockThreadList();
1741 LOG_THREAD("threadid=%d: internal '%s'",
1742 dvmThreadSelf()->threadId, pArgs->name);
1745 (*pArgs->func)(pArgs->funcArg);
1747 /* detach ourselves */
1748 dvmDetachCurrentThread();
1751 * Tell the parent of our failure. We don't have a Thread struct,
1752 * so we can't be suspended, so we don't need to enter a critical
1755 dvmLockThreadList(dvmThreadSelf());
1756 *pArgs->pCreateStatus = -1;
1757 assert(*pArgs->pThread == NULL);
1758 pthread_cond_broadcast(&gDvm.threadStartCond);
1759 dvmUnlockThreadList();
1761 assert(*pArgs->pThread == NULL);
1770 * Attach the current thread to the VM.
1772 * Used for internally-created threads and JNI's AttachCurrentThread.
1774 bool dvmAttachCurrentThread(const JavaVMAttachArgs* pArgs, bool isDaemon)
1776 Thread* self = NULL;
1777 Object* threadObj = NULL;
1778 Object* vmThreadObj = NULL;
1779 StringObject* threadNameStr = NULL;
1783 /* allocate thread struct, and establish a basic sense of self */
1784 self = allocThread(gDvm.stackSize);
1787 setThreadSelf(self);
1790 * Finish our thread prep. We need to do this before adding ourselves
1791 * to the thread list or invoking any interpreted code. prepareThread()
1792 * requires that we hold the thread list lock.
1794 dvmLockThreadList(self);
1795 ok = prepareThread(self);
1796 dvmUnlockThreadList();
1800 self->jniEnv = dvmCreateJNIEnv(self);
1801 if (self->jniEnv == NULL)
1805 * Create a "fake" JNI frame at the top of the main thread interp stack.
1806 * It isn't really necessary for the internal threads, but it gives
1807 * the debugger something to show. It is essential for the JNI-attached
1810 if (!createFakeRunFrame(self))
1814 * The native side of the thread is ready; add it to the list. Once
1815 * it's on the list the thread is visible to the JDWP code and the GC.
1817 LOG_THREAD("threadid=%d: adding to list (attached)", self->threadId);
1819 dvmLockThreadList(self);
1821 self->next = gDvm.threadList->next;
1822 if (self->next != NULL)
1823 self->next->prev = self;
1824 self->prev = gDvm.threadList;
1825 gDvm.threadList->next = self;
1827 gDvm.nonDaemonThreadCount++;
1829 dvmUnlockThreadList();
1832 * Switch state from initializing to running.
1834 * It's possible that a GC began right before we added ourselves
1835 * to the thread list, and is still going. That means our thread
1836 * suspend count won't reflect the fact that we should be suspended.
1837 * To deal with this, we transition to VMWAIT, pulse the heap lock,
1838 * and then advance to RUNNING. That will ensure that we stall until
1841 * Once we're in RUNNING, we're like any other thread in the VM (except
1842 * for the lack of an initialized threadObj). We're then free to
1843 * allocate and initialize objects.
1845 assert(self->status == THREAD_INITIALIZING);
1846 dvmChangeStatus(self, THREAD_VMWAIT);
1847 dvmLockMutex(&gDvm.gcHeapLock);
1848 dvmUnlockMutex(&gDvm.gcHeapLock);
1849 dvmChangeStatus(self, THREAD_RUNNING);
1852 * Create Thread and VMThread objects.
1854 threadObj = dvmAllocObject(gDvm.classJavaLangThread, ALLOC_DEFAULT);
1855 vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
1856 if (threadObj == NULL || vmThreadObj == NULL)
1860 * This makes threadObj visible to the GC. We still have it in the
1861 * tracked allocation table, so it can't move around on us.
1863 self->threadObj = threadObj;
1864 dvmSetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData, (u4)self);
1867 * Create a string for the thread name.
1869 if (pArgs->name != NULL) {
1870 threadNameStr = dvmCreateStringFromCstr(pArgs->name);
1871 if (threadNameStr == NULL) {
1872 assert(dvmCheckException(dvmThreadSelf()));
1877 init = dvmFindDirectMethodByDescriptor(gDvm.classJavaLangThread, "<init>",
1878 "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
1880 assert(dvmCheckException(self));
1885 * Now we're ready to run some interpreted code.
1887 * We need to construct the Thread object and set the VMThread field.
1888 * Setting VMThread tells interpreted code that we're alive.
1890 * Call the (group, name, priority, daemon) constructor on the Thread.
1891 * This sets the thread's name and adds it to the specified group, and
1892 * provides values for priority and daemon (which are normally inherited
1893 * from the current thread).
1896 dvmCallMethod(self, init, threadObj, &unused, (Object*)pArgs->group,
1897 threadNameStr, os_getThreadPriorityFromSystem(), isDaemon);
1898 if (dvmCheckException(self)) {
1899 ALOGE("exception thrown while constructing attached thread object");
1904 * Set the VMThread field, which tells interpreted code that we're alive.
1906 * The risk of a thread start collision here is very low; somebody
1907 * would have to be deliberately polling the ThreadGroup list and
1908 * trying to start threads against anything it sees, which would
1909 * generally cause problems for all thread creation. However, for
1910 * correctness we test "vmThread" before setting it.
1912 * TODO: this still has a race, it's just smaller. Not sure this is
1913 * worth putting effort into fixing. Need to hold a lock while
1914 * fiddling with the field, or maybe initialize the Thread object in a
1915 * way that ensures another thread can't call start() on it.
1917 if (dvmGetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread) != NULL) {
1918 ALOGW("WOW: thread start hijack");
1919 dvmThrowIllegalThreadStateException(
1920 "thread has already been started");
1921 /* We don't want to free anything associated with the thread
1922 * because someone is obviously interested in it. Just let
1923 * it go and hope it will clean itself up when its finished.
1924 * This case should never happen anyway.
1926 * Since we're letting it live, we need to finish setting it up.
1927 * We just have to let the caller know that the intended operation
1930 * [ This seems strange -- stepping on the vmThread object that's
1931 * already present seems like a bad idea. TODO: figure this out. ]
1937 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread, vmThreadObj);
1939 /* we can now safely un-pin these */
1940 dvmReleaseTrackedAlloc(threadObj, self);
1941 dvmReleaseTrackedAlloc(vmThreadObj, self);
1942 dvmReleaseTrackedAlloc((Object*)threadNameStr, self);
1944 LOG_THREAD("threadid=%d: attached from native, name=%s",
1945 self->threadId, pArgs->name);
1947 /* tell the debugger & DDM */
1948 if (gDvm.debuggerConnected)
1949 dvmDbgPostThreadStart(self);
1954 dvmLockThreadList(self);
1957 gDvm.nonDaemonThreadCount--;
1958 dvmUnlockThreadList();
1959 /* fall through to "fail" */
1961 dvmReleaseTrackedAlloc(threadObj, self);
1962 dvmReleaseTrackedAlloc(vmThreadObj, self);
1963 dvmReleaseTrackedAlloc((Object*)threadNameStr, self);
1965 if (self->jniEnv != NULL) {
1966 dvmDestroyJNIEnv(self->jniEnv);
1967 self->jniEnv = NULL;
1971 setThreadSelf(NULL);
1976 * Detach the thread from the various data structures, notify other threads
1977 * that are waiting to "join" it, and free up all heap-allocated storage.
1979 * Used for all threads.
1981 * When we get here the interpreted stack should be empty. The JNI 1.6 spec
1982 * requires us to enforce this for the DetachCurrentThread call, probably
1983 * because it also says that DetachCurrentThread causes all monitors
1984 * associated with the thread to be released. (Because the stack is empty,
1985 * we only have to worry about explicit JNI calls to MonitorEnter.)
1988 * We might want to avoid freeing our internal Thread structure until the
1989 * associated Thread/VMThread objects get GCed. Our Thread is impossible to
1990 * get to once the thread shuts down, but there is a small possibility of
1991 * an operation starting in another thread before this thread halts, and
1992 * finishing much later (perhaps the thread got stalled by a weird OS bug).
1993 * We don't want something like Thread.isInterrupted() crawling through
1994 * freed storage. Can do with a Thread finalizer, or by creating a
1995 * dedicated ThreadObject class for java/lang/Thread and moving all of our
1998 void dvmDetachCurrentThread()
2000 Thread* self = dvmThreadSelf();
2005 * Make sure we're not detaching a thread that's still running. (This
2006 * could happen with an explicit JNI detach call.)
2008 * A thread created by interpreted code will finish with a depth of
2009 * zero, while a JNI-attached thread will have the synthetic "stack
2010 * starter" native method at the top.
2012 int curDepth = dvmComputeExactFrameDepth(self->interpSave.curFrame);
2013 if (curDepth != 0) {
2014 bool topIsNative = false;
2016 if (curDepth == 1) {
2017 /* not expecting a lingering break frame; just look at curFrame */
2018 assert(!dvmIsBreakFrame((u4*)self->interpSave.curFrame));
2019 StackSaveArea* ssa = SAVEAREA_FROM_FP(self->interpSave.curFrame);
2020 if (dvmIsNativeMethod(ssa->method))
2025 ALOGE("ERROR: detaching thread with interp frames (count=%d)",
2027 dvmDumpThread(self, false);
2032 group = dvmGetFieldObject(self->threadObj, gDvm.offJavaLangThread_group);
2033 LOG_THREAD("threadid=%d: detach (group=%p)", self->threadId, group);
2036 * Release any held monitors. Since there are no interpreted stack
2037 * frames, the only thing left are the monitors held by JNI MonitorEnter
2040 dvmReleaseJniMonitors(self);
2043 * Do some thread-exit uncaught exception processing if necessary.
2045 if (dvmCheckException(self))
2046 threadExitUncaughtException(self, group);
2049 * Remove the thread from the thread group.
2051 if (group != NULL) {
2052 Method* removeThread =
2053 group->clazz->vtable[gDvm.voffJavaLangThreadGroup_removeThread];
2055 dvmCallMethod(self, removeThread, group, &unused, self->threadObj);
2059 * Clear the vmThread reference in the Thread object. Interpreted code
2060 * will now see that this Thread is not running. As this may be the
2061 * only reference to the VMThread object that the VM knows about, we
2062 * have to create an internal reference to it first.
2064 vmThread = dvmGetFieldObject(self->threadObj,
2065 gDvm.offJavaLangThread_vmThread);
2066 dvmAddTrackedAlloc(vmThread, self);
2067 dvmSetFieldObject(self->threadObj, gDvm.offJavaLangThread_vmThread, NULL);
2069 /* clear out our struct Thread pointer, since it's going away */
2070 dvmSetFieldObject(vmThread, gDvm.offJavaLangVMThread_vmData, NULL);
2073 * Tell the debugger & DDM. This may cause the current thread or all
2074 * threads to suspend.
2076 * The JDWP spec is somewhat vague about when this happens, other than
2077 * that it's issued by the dying thread, which may still appear in
2078 * an "all threads" listing.
2080 if (gDvm.debuggerConnected)
2081 dvmDbgPostThreadDeath(self);
2084 * Thread.join() is implemented as an Object.wait() on the VMThread
2085 * object. Signal anyone who is waiting.
2087 dvmLockObject(self, vmThread);
2088 dvmObjectNotifyAll(self, vmThread);
2089 dvmUnlockObject(self, vmThread);
2091 dvmReleaseTrackedAlloc(vmThread, self);
2095 * We're done manipulating objects, so it's okay if the GC runs in
2096 * parallel with us from here out. It's important to do this if
2097 * profiling is enabled, since we can wait indefinitely.
2099 volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
2100 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
2101 android_atomic_release_store(THREAD_VMWAIT, addr);
2104 * If we're doing method trace profiling, we don't want threads to exit,
2105 * because if they do we'll end up reusing thread IDs. This complicates
2106 * analysis and makes it impossible to have reasonable output in the
2107 * "threads" section of the "key" file.
2109 * We need to do this after Thread.join() completes, or other threads
2110 * could get wedged. Since self->threadObj is still valid, the Thread
2111 * object will not get GCed even though we're no longer in the ThreadGroup
2112 * list (which is important since the profiling thread needs to get
2113 * the thread's name).
2115 MethodTraceState* traceState = &gDvm.methodTrace;
2117 dvmLockMutex(&traceState->startStopLock);
2118 if (traceState->traceEnabled) {
2119 ALOGI("threadid=%d: waiting for method trace to finish",
2121 while (traceState->traceEnabled) {
2122 dvmWaitCond(&traceState->threadExitCond,
2123 &traceState->startStopLock);
2126 dvmUnlockMutex(&traceState->startStopLock);
2128 dvmLockThreadList(self);
2131 * Lose the JNI context.
2133 dvmDestroyJNIEnv(self->jniEnv);
2134 self->jniEnv = NULL;
2136 self->status = THREAD_ZOMBIE;
2139 * Remove ourselves from the internal thread list.
2144 * If we're the last one standing, signal anybody waiting in
2145 * DestroyJavaVM that it's okay to exit.
2147 if (!dvmGetFieldBoolean(self->threadObj, gDvm.offJavaLangThread_daemon)) {
2148 gDvm.nonDaemonThreadCount--; // guarded by thread list lock
2150 if (gDvm.nonDaemonThreadCount == 0) {
2151 ALOGV("threadid=%d: last non-daemon thread", self->threadId);
2152 //dvmDumpAllThreads(false);
2153 // cond var guarded by threadListLock, which we already hold
2154 int cc = pthread_cond_signal(&gDvm.vmExitCond);
2156 ALOGE("pthread_cond_signal(&gDvm.vmExitCond) failed: %s", strerror(cc));
2162 ALOGV("threadid=%d: bye!", self->threadId);
2163 releaseThreadId(self);
2164 dvmUnlockThreadList();
2166 setThreadSelf(NULL);
2173 * Suspend a single thread. Do not use to suspend yourself.
2175 * This is used primarily for debugger/DDMS activity. Does not return
2176 * until the thread has suspended or is in a "safe" state (e.g. executing
2177 * native code outside the VM).
2179 * The thread list lock should be held before calling here -- it's not
2180 * entirely safe to hang on to a Thread* from another thread otherwise.
2181 * (We'd need to grab it here anyway to avoid clashing with a suspend-all.)
2183 void dvmSuspendThread(Thread* thread)
2185 assert(thread != NULL);
2186 assert(thread != dvmThreadSelf());
2187 //assert(thread->handle != dvmJdwpGetDebugThread(gDvm.jdwpState));
2189 lockThreadSuspendCount();
2190 dvmAddToSuspendCounts(thread, 1, 1);
2192 LOG_THREAD("threadid=%d: suspend++, now=%d",
2193 thread->threadId, thread->suspendCount);
2194 unlockThreadSuspendCount();
2196 waitForThreadSuspend(dvmThreadSelf(), thread);
2200 * Reduce the suspend count of a thread. If it hits zero, tell it to
2203 * Used primarily for debugger/DDMS activity. The thread in question
2204 * might have been suspended singly or as part of a suspend-all operation.
2206 * The thread list lock should be held before calling here -- it's not
2207 * entirely safe to hang on to a Thread* from another thread otherwise.
2208 * (We'd need to grab it here anyway to avoid clashing with a suspend-all.)
2210 void dvmResumeThread(Thread* thread)
2212 assert(thread != NULL);
2213 assert(thread != dvmThreadSelf());
2214 //assert(thread->handle != dvmJdwpGetDebugThread(gDvm.jdwpState));
2216 lockThreadSuspendCount();
2217 if (thread->suspendCount > 0) {
2218 dvmAddToSuspendCounts(thread, -1, -1);
2220 LOG_THREAD("threadid=%d: suspendCount already zero",
2224 LOG_THREAD("threadid=%d: suspend--, now=%d",
2225 thread->threadId, thread->suspendCount);
2227 if (thread->suspendCount == 0) {
2228 dvmBroadcastCond(&gDvm.threadSuspendCountCond);
2231 unlockThreadSuspendCount();
2235 * Suspend yourself, as a result of debugger activity.
2237 void dvmSuspendSelf(bool jdwpActivity)
2239 Thread* self = dvmThreadSelf();
2241 /* debugger thread must not suspend itself due to debugger activity! */
2242 assert(gDvm.jdwpState != NULL);
2243 if (self->handle == dvmJdwpGetDebugThread(gDvm.jdwpState)) {
2249 * Collisions with other suspends aren't really interesting. We want
2250 * to ensure that we're the only one fiddling with the suspend count
2253 lockThreadSuspendCount();
2254 dvmAddToSuspendCounts(self, 1, 1);
2257 * Suspend ourselves.
2259 assert(self->suspendCount > 0);
2260 self->status = THREAD_SUSPENDED;
2261 LOG_THREAD("threadid=%d: self-suspending (dbg)", self->threadId);
2264 * Tell JDWP that we've completed suspension. The JDWP thread can't
2265 * tell us to resume before we're fully asleep because we hold the
2266 * suspend count lock.
2268 * If we got here via waitForDebugger(), don't do this part.
2271 //ALOGI("threadid=%d: clearing wait-for-event (my handle=%08x)",
2272 // self->threadId, (int) self->handle);
2273 dvmJdwpClearWaitForEventThread(gDvm.jdwpState);
2276 while (self->suspendCount != 0) {
2277 dvmWaitCond(&gDvm.threadSuspendCountCond,
2278 &gDvm.threadSuspendCountLock);
2279 if (self->suspendCount != 0) {
2281 * The condition was signaled but we're still suspended. This
2282 * can happen if the debugger lets go while a SIGQUIT thread
2283 * dump event is pending (assuming SignalCatcher was resumed for
2284 * just long enough to try to grab the thread-suspend lock).
2286 ALOGD("threadid=%d: still suspended after undo (sc=%d dc=%d)",
2287 self->threadId, self->suspendCount, self->dbgSuspendCount);
2290 assert(self->suspendCount == 0 && self->dbgSuspendCount == 0);
2291 self->status = THREAD_RUNNING;
2292 LOG_THREAD("threadid=%d: self-reviving (dbg), status=%d",
2293 self->threadId, self->status);
2295 unlockThreadSuspendCount();
2299 * Dump the state of the current thread and that of another thread that
2300 * we think is wedged.
2302 static void dumpWedgedThread(Thread* thread)
2304 dvmDumpThread(dvmThreadSelf(), false);
2305 dvmPrintNativeBackTrace();
2307 // dumping a running thread is risky, but could be useful
2308 dvmDumpThread(thread, true);
2310 // stop now and get a core dump
2315 * If the thread is running at below-normal priority, temporarily elevate
2318 * Returns zero if no changes were made. Otherwise, returns bit flags
2319 * indicating what was changed, storing the previous values in the
2320 * provided locations.
2322 int dvmRaiseThreadPriorityIfNeeded(Thread* thread, int* pSavedThreadPrio,
2323 SchedPolicy* pSavedThreadPolicy)
2326 *pSavedThreadPrio = getpriority(PRIO_PROCESS, thread->systemTid);
2328 ALOGW("Unable to get priority for threadid=%d sysTid=%d",
2329 thread->threadId, thread->systemTid);
2332 if (get_sched_policy(thread->systemTid, pSavedThreadPolicy) != 0) {
2333 ALOGW("Unable to get policy for threadid=%d sysTid=%d",
2334 thread->threadId, thread->systemTid);
2338 int changeFlags = 0;
2341 * Change the priority if we're in the background group.
2343 if (*pSavedThreadPolicy == SP_BACKGROUND) {
2344 if (set_sched_policy(thread->systemTid, SP_FOREGROUND) != 0) {
2345 ALOGW("Couldn't set fg policy on tid %d", thread->systemTid);
2347 changeFlags |= kChangedPolicy;
2348 ALOGD("Temporarily moving tid %d to fg (was %d)",
2349 thread->systemTid, *pSavedThreadPolicy);
2354 * getpriority() returns the "nice" value, so larger numbers indicate
2355 * lower priority, with 0 being normal.
2357 if (*pSavedThreadPrio > 0) {
2358 const int kHigher = 0;
2359 if (setpriority(PRIO_PROCESS, thread->systemTid, kHigher) != 0) {
2360 ALOGW("Couldn't raise priority on tid %d to %d",
2361 thread->systemTid, kHigher);
2363 changeFlags |= kChangedPriority;
2364 ALOGD("Temporarily raised priority on tid %d (%d -> %d)",
2365 thread->systemTid, *pSavedThreadPrio, kHigher);
2373 * Reset the priority values for the thread in question.
2375 void dvmResetThreadPriority(Thread* thread, int changeFlags,
2376 int savedThreadPrio, SchedPolicy savedThreadPolicy)
2378 if ((changeFlags & kChangedPolicy) != 0) {
2379 if (set_sched_policy(thread->systemTid, savedThreadPolicy) != 0) {
2380 ALOGW("NOTE: couldn't reset tid %d to (%d)",
2381 thread->systemTid, savedThreadPolicy);
2383 ALOGD("Restored policy of %d to %d",
2384 thread->systemTid, savedThreadPolicy);
2388 if ((changeFlags & kChangedPriority) != 0) {
2389 if (setpriority(PRIO_PROCESS, thread->systemTid, savedThreadPrio) != 0)
2391 ALOGW("NOTE: couldn't reset priority on thread %d to %d",
2392 thread->systemTid, savedThreadPrio);
2394 ALOGD("Restored priority on %d to %d",
2395 thread->systemTid, savedThreadPrio);
2401 * Wait for another thread to see the pending suspension and stop running.
2402 * It can either suspend itself or go into a non-running state such as
2403 * VMWAIT or NATIVE in which it cannot interact with the GC.
2405 * If we're running at a higher priority, sched_yield() may not do anything,
2406 * so we need to sleep for "long enough" to guarantee that the other
2407 * thread has a chance to finish what it's doing. Sleeping for too short
2408 * a period (e.g. less than the resolution of the sleep clock) might cause
2409 * the scheduler to return immediately, so we want to start with a
2410 * "reasonable" value and expand.
2412 * This does not return until the other thread has stopped running.
2413 * Eventually we time out and the VM aborts.
2415 * This does not try to detect the situation where two threads are
2416 * waiting for each other to suspend. In normal use this is part of a
2417 * suspend-all, which implies that the suspend-all lock is held, or as
2418 * part of a debugger action in which the JDWP thread is always the one
2419 * doing the suspending. (We may need to re-evaluate this now that
2420 * getThreadStackTrace is implemented as suspend-snapshot-resume.)
2422 * TODO: track basic stats about time required to suspend VM.
2424 #define FIRST_SLEEP (250*1000) /* 0.25s */
2425 #define MORE_SLEEP (750*1000) /* 0.75s */
2426 static void waitForThreadSuspend(Thread* self, Thread* thread)
2428 const int kMaxRetries = 10;
2429 int spinSleepTime = FIRST_SLEEP;
2430 bool complained = false;
2431 int priChangeFlags = 0;
2432 int savedThreadPrio = -500;
2433 SchedPolicy savedThreadPolicy = SP_FOREGROUND;
2437 u8 startWhen = 0; // init req'd to placate gcc
2438 u8 firstStartWhen = 0;
2440 while (thread->status == THREAD_RUNNING) {
2441 if (sleepIter == 0) { // get current time on first iteration
2442 startWhen = dvmGetRelativeTimeUsec();
2443 if (firstStartWhen == 0) // first iteration of first attempt
2444 firstStartWhen = startWhen;
2447 * After waiting for a bit, check to see if the target thread is
2448 * running at a reduced priority. If so, bump it up temporarily
2449 * to give it more CPU time.
2451 if (retryCount == 2) {
2452 assert(thread->systemTid != 0);
2453 priChangeFlags = dvmRaiseThreadPriorityIfNeeded(thread,
2454 &savedThreadPrio, &savedThreadPolicy);
2458 #if defined (WITH_JIT)
2460 * If we're still waiting after the first timeout, unchain all
2462 * 1) There are new chains formed since the last unchain
2463 * 2) The top VM frame of the running thread is running JIT'ed code
2465 if (gDvmJit.pJitEntryTable && retryCount > 0 &&
2466 gDvmJit.hasNewChain && thread->inJitCodeCache) {
2467 ALOGD("JIT unchain all for threadid=%d", thread->threadId);
2473 * Sleep briefly. The iterative sleep call returns false if we've
2474 * exceeded the total time limit for this round of sleeping.
2476 if (!dvmIterativeSleep(sleepIter++, spinSleepTime, startWhen)) {
2477 if (spinSleepTime != FIRST_SLEEP) {
2478 ALOGW("threadid=%d: spin on suspend #%d threadid=%d (pcf=%d)",
2479 self->threadId, retryCount,
2480 thread->threadId, priChangeFlags);
2481 if (retryCount > 1) {
2482 /* stack trace logging is slow; skip on first iter */
2483 dumpWedgedThread(thread);
2488 // keep going; could be slow due to valgrind
2490 spinSleepTime = MORE_SLEEP;
2492 if (retryCount++ == kMaxRetries) {
2493 ALOGE("Fatal spin-on-suspend, dumping threads");
2494 dvmDumpAllThreads(false);
2496 /* log this after -- long traces will scroll off log */
2497 ALOGE("threadid=%d: stuck on threadid=%d, giving up",
2498 self->threadId, thread->threadId);
2500 /* try to get a debuggerd dump from the spinning thread */
2501 dvmNukeThread(thread);
2509 ALOGW("threadid=%d: spin on suspend resolved in %lld msec",
2511 (dvmGetRelativeTimeUsec() - firstStartWhen) / 1000);
2512 //dvmDumpThread(thread, false); /* suspended, so dump is safe */
2514 if (priChangeFlags != 0) {
2515 dvmResetThreadPriority(thread, priChangeFlags, savedThreadPrio,
2521 * Suspend all threads except the current one. This is used by the GC,
2522 * the debugger, and by any thread that hits a "suspend all threads"
2523 * debugger event (e.g. breakpoint or exception).
2525 * If thread N hits a "suspend all threads" breakpoint, we don't want it
2526 * to suspend the JDWP thread. For the GC, we do, because the debugger can
2527 * create objects and even execute arbitrary code. The "why" argument
2528 * allows the caller to say why the suspension is taking place.
2530 * This can be called when a global suspend has already happened, due to
2531 * various debugger gymnastics, so keeping an "everybody is suspended" flag
2534 * DO NOT grab any locks before calling here. We grab & release the thread
2535 * lock and suspend lock here (and we're not using recursive threads), and
2536 * we might have to self-suspend if somebody else beats us here.
2538 * We know the current thread is in the thread list, because we attach the
2539 * thread before doing anything that could cause VM suspension (like object
2542 void dvmSuspendAllThreads(SuspendCause why)
2544 Thread* self = dvmThreadSelf();
2550 * Start by grabbing the thread suspend lock. If we can't get it, most
2551 * likely somebody else is in the process of performing a suspend or
2552 * resume, so lockThreadSuspend() will cause us to self-suspend.
2554 * We keep the lock until all other threads are suspended.
2556 lockThreadSuspend("susp-all", why);
2558 LOG_THREAD("threadid=%d: SuspendAll starting", self->threadId);
2561 * This is possible if the current thread was in VMWAIT mode when a
2562 * suspend-all happened, and then decided to do its own suspend-all.
2563 * This can happen when a couple of threads have simultaneous events
2564 * of interest to the debugger.
2566 //assert(self->suspendCount == 0);
2569 * Increment everybody's suspend count (except our own).
2571 dvmLockThreadList(self);
2573 lockThreadSuspendCount();
2574 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2578 /* debugger events don't suspend JDWP thread */
2579 if ((why == SUSPEND_FOR_DEBUG || why == SUSPEND_FOR_DEBUG_EVENT) &&
2580 thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState))
2583 dvmAddToSuspendCounts(thread, 1,
2584 (why == SUSPEND_FOR_DEBUG ||
2585 why == SUSPEND_FOR_DEBUG_EVENT)
2588 unlockThreadSuspendCount();
2591 * Wait for everybody in THREAD_RUNNING state to stop. Other states
2592 * indicate the code is either running natively or sleeping quietly.
2593 * Any attempt to transition back to THREAD_RUNNING will cause a check
2594 * for suspension, so it should be impossible for anything to execute
2595 * interpreted code or modify objects (assuming native code plays nicely).
2597 * It's also okay if the thread transitions to a non-RUNNING state.
2599 * Note we released the threadSuspendCountLock before getting here,
2600 * so if another thread is fiddling with its suspend count (perhaps
2601 * self-suspending for the debugger) it won't block while we're waiting
2604 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2608 /* debugger events don't suspend JDWP thread */
2609 if ((why == SUSPEND_FOR_DEBUG || why == SUSPEND_FOR_DEBUG_EVENT) &&
2610 thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState))
2613 /* wait for the other thread to see the pending suspend */
2614 waitForThreadSuspend(self, thread);
2616 LOG_THREAD("threadid=%d: threadid=%d status=%d sc=%d dc=%d",
2617 self->threadId, thread->threadId, thread->status,
2618 thread->suspendCount, thread->dbgSuspendCount);
2621 dvmUnlockThreadList();
2622 unlockThreadSuspend();
2624 LOG_THREAD("threadid=%d: SuspendAll complete", self->threadId);
2628 * Resume all threads that are currently suspended.
2630 * The "why" must match with the previous suspend.
2632 void dvmResumeAllThreads(SuspendCause why)
2634 Thread* self = dvmThreadSelf();
2637 lockThreadSuspend("res-all", why); /* one suspend/resume at a time */
2638 LOG_THREAD("threadid=%d: ResumeAll starting", self->threadId);
2641 * Decrement the suspend counts for all threads. No need for atomic
2642 * writes, since nobody should be moving until we decrement the count.
2643 * We do need to hold the thread list because of JNI attaches.
2645 dvmLockThreadList(self);
2646 lockThreadSuspendCount();
2647 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2651 /* debugger events don't suspend JDWP thread */
2652 if ((why == SUSPEND_FOR_DEBUG || why == SUSPEND_FOR_DEBUG_EVENT) &&
2653 thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState))
2658 if (thread->suspendCount > 0) {
2659 dvmAddToSuspendCounts(thread, -1,
2660 (why == SUSPEND_FOR_DEBUG ||
2661 why == SUSPEND_FOR_DEBUG_EVENT)
2664 LOG_THREAD("threadid=%d: suspendCount already zero",
2668 unlockThreadSuspendCount();
2669 dvmUnlockThreadList();
2672 * In some ways it makes sense to continue to hold the thread-suspend
2673 * lock while we issue the wakeup broadcast. It allows us to complete
2674 * one operation before moving on to the next, which simplifies the
2675 * thread activity debug traces.
2677 * This approach caused us some difficulty under Linux, because the
2678 * condition variable broadcast not only made the threads runnable,
2679 * but actually caused them to execute, and it was a while before
2680 * the thread performing the wakeup had an opportunity to release the
2681 * thread-suspend lock.
2683 * This is a problem because, when a thread tries to acquire that
2684 * lock, it times out after 3 seconds. If at some point the thread
2685 * is told to suspend, the clock resets; but since the VM is still
2686 * theoretically mid-resume, there's no suspend pending. If, for
2687 * example, the GC was waking threads up while the SIGQUIT handler
2688 * was trying to acquire the lock, we would occasionally time out on
2689 * a busy system and SignalCatcher would abort.
2691 * We now perform the unlock before the wakeup broadcast. The next
2692 * suspend can't actually start until the broadcast completes and
2693 * returns, because we're holding the thread-suspend-count lock, but the
2694 * suspending thread is now able to make progress and we avoid the abort.
2696 * (Technically there is a narrow window between when we release
2697 * the thread-suspend lock and grab the thread-suspend-count lock.
2698 * This could cause us to send a broadcast to threads with nonzero
2699 * suspend counts, but this is expected and they'll all just fall
2700 * right back to sleep. It's probably safe to grab the suspend-count
2701 * lock before releasing thread-suspend, since we're still following
2702 * the correct order of acquisition, but it feels weird.)
2705 LOG_THREAD("threadid=%d: ResumeAll waking others", self->threadId);
2706 unlockThreadSuspend();
2709 * Broadcast a notification to all suspended threads, some or all of
2710 * which may choose to wake up. No need to wait for them.
2712 lockThreadSuspendCount();
2713 int cc = pthread_cond_broadcast(&gDvm.threadSuspendCountCond);
2715 ALOGE("pthread_cond_broadcast(&gDvm.threadSuspendCountCond) failed: %s", strerror(cc));
2718 unlockThreadSuspendCount();
2720 LOG_THREAD("threadid=%d: ResumeAll complete", self->threadId);
2724 * Undo any debugger suspensions. This is called when the debugger
2727 void dvmUndoDebuggerSuspensions()
2729 Thread* self = dvmThreadSelf();
2732 lockThreadSuspend("undo", SUSPEND_FOR_DEBUG);
2733 LOG_THREAD("threadid=%d: UndoDebuggerSusp starting", self->threadId);
2736 * Decrement the suspend counts for all threads. No need for atomic
2737 * writes, since nobody should be moving until we decrement the count.
2738 * We do need to hold the thread list because of JNI attaches.
2740 dvmLockThreadList(self);
2741 lockThreadSuspendCount();
2742 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2746 /* debugger events don't suspend JDWP thread */
2747 if (thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState)) {
2748 assert(thread->dbgSuspendCount == 0);
2752 assert(thread->suspendCount >= thread->dbgSuspendCount);
2753 dvmAddToSuspendCounts(thread, -thread->dbgSuspendCount,
2754 -thread->dbgSuspendCount);
2756 unlockThreadSuspendCount();
2757 dvmUnlockThreadList();
2760 * Broadcast a notification to all suspended threads, some or all of
2761 * which may choose to wake up. No need to wait for them.
2763 lockThreadSuspendCount();
2764 int cc = pthread_cond_broadcast(&gDvm.threadSuspendCountCond);
2766 ALOGE("pthread_cond_broadcast(&gDvm.threadSuspendCountCond) failed: %s", strerror(cc));
2769 unlockThreadSuspendCount();
2771 unlockThreadSuspend();
2773 LOG_THREAD("threadid=%d: UndoDebuggerSusp complete", self->threadId);
2777 * Determine if a thread is suspended.
2779 * As with all operations on foreign threads, the caller should hold
2780 * the thread list lock before calling.
2782 * If the thread is suspending or waking, these fields could be changing
2783 * out from under us (or the thread could change state right after we
2784 * examine it), making this generally unreliable. This is chiefly
2785 * intended for use by the debugger.
2787 bool dvmIsSuspended(const Thread* thread)
2790 * The thread could be:
2791 * (1) Running happily. status is RUNNING, suspendCount is zero.
2793 * (2) Pending suspend. status is RUNNING, suspendCount is nonzero.
2795 * (3) Suspended. suspendCount is nonzero, and status is !RUNNING.
2797 * (4) Waking up. suspendCount is zero, status is SUSPENDED
2798 * Return "false" (since it could change out from under us, unless
2799 * we hold suspendCountLock).
2802 return (thread->suspendCount != 0 &&
2803 thread->status != THREAD_RUNNING);
2807 * Wait until another thread self-suspends. This is specifically for
2808 * synchronization between the JDWP thread and a thread that has decided
2809 * to suspend itself after sending an event to the debugger.
2811 * Threads that encounter "suspend all" events work as well -- the thread
2812 * in question suspends everybody else and then itself.
2814 * We can't hold a thread lock here or in the caller, because we could
2815 * get here just before the to-be-waited-for-thread issues a "suspend all".
2816 * There's an opportunity for badness if the thread we're waiting for exits
2817 * and gets cleaned up, but since the thread in question is processing a
2818 * debugger event, that's not really a possibility. (To avoid deadlock,
2819 * it's important that we not be in THREAD_RUNNING while we wait.)
2821 void dvmWaitForSuspend(Thread* thread)
2823 Thread* self = dvmThreadSelf();
2825 LOG_THREAD("threadid=%d: waiting for threadid=%d to sleep",
2826 self->threadId, thread->threadId);
2828 assert(thread->handle != dvmJdwpGetDebugThread(gDvm.jdwpState));
2829 assert(thread != self);
2830 assert(self->status != THREAD_RUNNING);
2832 waitForThreadSuspend(self, thread);
2834 LOG_THREAD("threadid=%d: threadid=%d is now asleep",
2835 self->threadId, thread->threadId);
2839 * Check to see if we need to suspend ourselves. If so, go to sleep on
2840 * a condition variable.
2842 * Returns "true" if we suspended ourselves.
2844 static bool fullSuspendCheck(Thread* self)
2846 assert(self != NULL);
2847 assert(self->suspendCount >= 0);
2850 * Grab gDvm.threadSuspendCountLock. This gives us exclusive write
2851 * access to self->suspendCount.
2853 lockThreadSuspendCount(); /* grab gDvm.threadSuspendCountLock */
2855 bool needSuspend = (self->suspendCount != 0);
2857 LOG_THREAD("threadid=%d: self-suspending", self->threadId);
2858 ThreadStatus oldStatus = self->status; /* should be RUNNING */
2859 self->status = THREAD_SUSPENDED;
2861 ATRACE_BEGIN("DVM Suspend");
2862 while (self->suspendCount != 0) {
2864 * Wait for wakeup signal, releasing lock. The act of releasing
2865 * and re-acquiring the lock provides the memory barriers we
2866 * need for correct behavior on SMP.
2868 dvmWaitCond(&gDvm.threadSuspendCountCond,
2869 &gDvm.threadSuspendCountLock);
2872 assert(self->suspendCount == 0 && self->dbgSuspendCount == 0);
2873 self->status = oldStatus;
2874 LOG_THREAD("threadid=%d: self-reviving, status=%d",
2875 self->threadId, self->status);
2878 unlockThreadSuspendCount();
2884 * Check to see if a suspend is pending. If so, suspend the current
2885 * thread, and return "true" after we have been resumed.
2887 bool dvmCheckSuspendPending(Thread* self)
2889 assert(self != NULL);
2890 if (self->suspendCount == 0) {
2893 return fullSuspendCheck(self);
2898 * Update our status.
2900 * The "self" argument, which may be NULL, is accepted as an optimization.
2902 * Returns the old status.
2904 ThreadStatus dvmChangeStatus(Thread* self, ThreadStatus newStatus)
2906 ThreadStatus oldStatus;
2909 self = dvmThreadSelf();
2911 LOGVV("threadid=%d: (status %d -> %d)",
2912 self->threadId, self->status, newStatus);
2914 oldStatus = self->status;
2915 if (oldStatus == newStatus)
2918 if (newStatus == THREAD_RUNNING) {
2920 * Change our status to THREAD_RUNNING. The transition requires
2921 * that we check for pending suspension, because the VM considers
2922 * us to be "asleep" in all other states, and another thread could
2923 * be performing a GC now.
2925 * The order of operations is very significant here. One way to
2928 * GCing thread Our thread (in NATIVE)
2929 * ------------ ----------------------
2930 * check suspend count (== 0)
2931 * dvmSuspendAllThreads()
2932 * grab suspend-count lock
2933 * increment all suspend counts
2934 * release suspend-count lock
2935 * check thread state (== NATIVE)
2936 * all are suspended, begin GC
2937 * set state to RUNNING
2938 * (continue executing)
2940 * We can correct this by grabbing the suspend-count lock and
2941 * performing both of our operations (check suspend count, set
2942 * state) while holding it, now we need to grab a mutex on every
2943 * transition to RUNNING.
2945 * What we do instead is change the order of operations so that
2946 * the transition to RUNNING happens first. If we then detect
2947 * that the suspend count is nonzero, we switch to SUSPENDED.
2949 * Appropriate compiler and memory barriers are required to ensure
2950 * that the operations are observed in the expected order.
2952 * This does create a small window of opportunity where a GC in
2953 * progress could observe what appears to be a running thread (if
2954 * it happens to look between when we set to RUNNING and when we
2955 * switch to SUSPENDED). At worst this only affects assertions
2956 * and thread logging. (We could work around it with some sort
2957 * of intermediate "pre-running" state that is generally treated
2958 * as equivalent to running, but that doesn't seem worthwhile.)
2960 * We can also solve this by combining the "status" and "suspend
2961 * count" fields into a single 32-bit value. This trades the
2962 * store/load barrier on transition to RUNNING for an atomic RMW
2963 * op on all transitions and all suspend count updates (also, all
2964 * accesses to status or the thread count require bit-fiddling).
2965 * It also eliminates the brief transition through RUNNING when
2966 * the thread is supposed to be suspended. This is possibly faster
2967 * on SMP and slightly more correct, but less convenient.
2969 volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
2970 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
2971 android_atomic_acquire_store(newStatus, addr);
2972 if (self->suspendCount != 0) {
2973 fullSuspendCheck(self);
2977 * Not changing to THREAD_RUNNING. No additional work required.
2979 * We use a releasing store to ensure that, if we were RUNNING,
2980 * any updates we previously made to objects on the managed heap
2981 * will be observed before the state change.
2983 assert(newStatus != THREAD_SUSPENDED);
2984 volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
2985 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
2986 android_atomic_release_store(newStatus, addr);
2993 * Get a statically defined thread group from a field in the ThreadGroup
2994 * Class object. Expected arguments are "mMain" and "mSystem".
2996 static Object* getStaticThreadGroup(const char* fieldName)
2998 StaticField* groupField;
3001 groupField = dvmFindStaticField(gDvm.classJavaLangThreadGroup,
3002 fieldName, "Ljava/lang/ThreadGroup;");
3003 if (groupField == NULL) {
3004 ALOGE("java.lang.ThreadGroup does not have an '%s' field", fieldName);
3005 dvmThrowInternalError("bad definition for ThreadGroup");
3008 groupObj = dvmGetStaticFieldObject(groupField);
3009 if (groupObj == NULL) {
3010 ALOGE("java.lang.ThreadGroup.%s not initialized", fieldName);
3011 dvmThrowInternalError(NULL);
3017 Object* dvmGetSystemThreadGroup()
3019 return getStaticThreadGroup("mSystem");
3021 Object* dvmGetMainThreadGroup()
3023 return getStaticThreadGroup("mMain");
3027 * Given a VMThread object, return the associated Thread*.
3029 * NOTE: if the thread detaches, the struct Thread will disappear, and
3030 * we will be touching invalid data. For safety, lock the thread list
3031 * before calling this.
3033 Thread* dvmGetThreadFromThreadObject(Object* vmThreadObj)
3037 vmData = dvmGetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData);
3040 Thread* thread = gDvm.threadList;
3041 while (thread != NULL) {
3042 if ((Thread*)vmData == thread)
3045 thread = thread->next;
3048 if (thread == NULL) {
3049 ALOGW("WARNING: vmThreadObj=%p has thread=%p, not in thread list",
3050 vmThreadObj, (Thread*)vmData);
3055 return (Thread*) vmData;
3059 * Given a pthread handle, return the associated Thread*.
3060 * Caller must hold the thread list lock.
3062 * Returns NULL if the thread was not found.
3064 Thread* dvmGetThreadByHandle(pthread_t handle)
3067 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
3068 if (thread->handle == handle)
3075 * Given a threadId, return the associated Thread*.
3076 * Caller must hold the thread list lock.
3078 * Returns NULL if the thread was not found.
3080 Thread* dvmGetThreadByThreadId(u4 threadId)
3083 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
3084 if (thread->threadId == threadId)
3090 void dvmChangeThreadPriority(Thread* thread, int newPriority)
3092 os_changeThreadPriority(thread, newPriority);
3096 * Return true if the thread is on gDvm.threadList.
3097 * Caller should not hold gDvm.threadListLock.
3099 bool dvmIsOnThreadList(const Thread* thread)
3103 dvmLockThreadList(NULL);
3104 if (thread == gDvm.threadList) {
3107 ret = thread->prev != NULL || thread->next != NULL;
3109 dvmUnlockThreadList();
3115 * Dump a thread to the log file -- just calls dvmDumpThreadEx() with an
3118 void dvmDumpThread(Thread* thread, bool isRunning)
3120 DebugOutputTarget target;
3122 dvmCreateLogOutputTarget(&target, ANDROID_LOG_INFO, LOG_TAG);
3123 dvmDumpThreadEx(&target, thread, isRunning);
3127 * Try to get the scheduler group.
3129 * The data from /proc/<pid>/cgroup looks (something) like:
3130 * 2:cpu:/bg_non_interactive
3133 * We return the part on the "cpu" line after the '/', which will be an
3134 * empty string for the default cgroup. If the string is longer than
3135 * "bufLen", the string will be truncated.
3137 * On error, -1 is returned, and an error description will be stored in
3140 static int getSchedulerGroup(int tid, char* buf, size_t bufLen)
3142 #ifdef HAVE_ANDROID_OS
3147 snprintf(pathBuf, sizeof(pathBuf), "/proc/%d/cgroup", tid);
3148 if ((fp = fopen(pathBuf, "r")) == NULL) {
3149 snprintf(buf, bufLen, "[fopen-error:%d]", errno);
3153 while (fgets(lineBuf, sizeof(lineBuf) -1, fp) != NULL) {
3158 /* Junk the first field */
3159 subsys = strchr(lineBuf, ':');
3160 if (subsys == NULL) {
3164 if (strncmp(subsys, ":cpu:", 5) != 0) {
3165 /* Not the subsys we're looking for */
3169 grp = strchr(subsys, '/');
3173 grp++; /* Drop the leading '/' */
3176 grp[len-1] = '\0'; /* Drop the trailing '\n' */
3178 if (bufLen <= len) {
3181 strncpy(buf, grp, len);
3187 snprintf(buf, bufLen, "[no-cpu-subsys]");
3192 ALOGE("Bad cgroup data {%s}", lineBuf);
3193 snprintf(buf, bufLen, "[data-parse-failed]");
3198 snprintf(buf, bufLen, "[n/a]");
3204 * Convert ThreadStatus to a string.
3206 const char* dvmGetThreadStatusStr(ThreadStatus status)
3209 case THREAD_ZOMBIE: return "ZOMBIE";
3210 case THREAD_RUNNING: return "RUNNABLE";
3211 case THREAD_TIMED_WAIT: return "TIMED_WAIT";
3212 case THREAD_MONITOR: return "MONITOR";
3213 case THREAD_WAIT: return "WAIT";
3214 case THREAD_INITIALIZING: return "INITIALIZING";
3215 case THREAD_STARTING: return "STARTING";
3216 case THREAD_NATIVE: return "NATIVE";
3217 case THREAD_VMWAIT: return "VMWAIT";
3218 case THREAD_SUSPENDED: return "SUSPENDED";
3219 default: return "UNKNOWN";
3223 static void dumpSchedStat(const DebugOutputTarget* target, pid_t tid) {
3224 #ifdef HAVE_ANDROID_OS
3225 /* get some bits from /proc/self/stat */
3226 ProcStatData procStatData;
3227 if (!dvmGetThreadStats(&procStatData, tid)) {
3228 /* failed, use zeroed values */
3229 memset(&procStatData, 0, sizeof(procStatData));
3232 /* grab the scheduler stats for this thread */
3233 char schedstatBuf[64];
3234 snprintf(schedstatBuf, sizeof(schedstatBuf), "/proc/self/task/%d/schedstat", tid);
3235 int schedstatFd = open(schedstatBuf, O_RDONLY);
3236 strcpy(schedstatBuf, "0 0 0"); /* show this if open/read fails */
3237 if (schedstatFd >= 0) {
3239 bytes = read(schedstatFd, schedstatBuf, sizeof(schedstatBuf) - 1);
3242 schedstatBuf[bytes - 1] = '\0'; /* remove trailing newline */
3246 /* show what we got */
3247 dvmPrintDebugMessage(target,
3248 " | state=%c schedstat=( %s ) utm=%lu stm=%lu core=%d\n",
3249 procStatData.state, schedstatBuf, procStatData.utime,
3250 procStatData.stime, procStatData.processor);
3254 struct SchedulerStats {
3261 * Get scheduler statistics.
3263 static void getSchedulerStats(SchedulerStats* stats, pid_t tid) {
3264 struct sched_param sp;
3265 if (pthread_getschedparam(pthread_self(), &stats->policy, &sp) != 0) {
3266 ALOGW("Warning: pthread_getschedparam failed");
3268 stats->priority = -1;
3270 stats->priority = sp.sched_priority;
3272 if (getSchedulerGroup(tid, stats->group, sizeof(stats->group)) == 0 &&
3273 stats->group[0] == '\0') {
3274 strcpy(stats->group, "default");
3278 static bool shouldShowNativeStack(Thread* thread) {
3279 // In native code somewhere in the VM? That's interesting.
3280 if (thread->status == THREAD_VMWAIT) {
3284 // In an Object.wait variant? That's not interesting.
3285 if (thread->status == THREAD_TIMED_WAIT || thread->status == THREAD_WAIT) {
3289 // The Signal Catcher thread? That's not interesting.
3290 if (thread->status == THREAD_RUNNING) {
3294 // In some other native method? That's interesting.
3295 // We don't just check THREAD_NATIVE because native methods will be in
3296 // state THREAD_SUSPENDED if they're calling back into the VM, or THREAD_MONITOR
3297 // if they're blocked on a monitor, or one of the thread-startup states if
3298 // it's early enough in their life cycle (http://b/7432159).
3299 u4* fp = thread->interpSave.curFrame;
3301 // The thread has no managed frames, so native frames are all there is.
3304 const Method* currentMethod = SAVEAREA_FROM_FP(fp)->method;
3305 return currentMethod != NULL && dvmIsNativeMethod(currentMethod);
3309 * Print information about the specified thread.
3311 * Works best when the thread in question is "self" or has been suspended.
3312 * When dumping a separate thread that's still running, set "isRunning" to
3313 * use a more cautious thread dump function.
3315 void dvmDumpThreadEx(const DebugOutputTarget* target, Thread* thread,
3320 StringObject* nameStr;
3321 char* threadName = NULL;
3322 char* groupName = NULL;
3324 int priority; // java.lang.Thread priority
3327 * Get the java.lang.Thread object. This function gets called from
3328 * some weird debug contexts, so it's possible that there's a GC in
3329 * progress on some other thread. To decrease the chances of the
3330 * thread object being moved out from under us, we add the reference
3331 * to the tracked allocation list, which pins it in place.
3333 * If threadObj is NULL, the thread is still in the process of being
3334 * attached to the VM, and there's really nothing interesting to
3337 threadObj = thread->threadObj;
3338 if (threadObj == NULL) {
3339 ALOGI("Can't dump thread %d: threadObj not set", thread->threadId);
3342 dvmAddTrackedAlloc(threadObj, NULL);
3344 nameStr = (StringObject*) dvmGetFieldObject(threadObj,
3345 gDvm.offJavaLangThread_name);
3346 threadName = dvmCreateCstrFromString(nameStr);
3348 priority = dvmGetFieldInt(threadObj, gDvm.offJavaLangThread_priority);
3349 isDaemon = dvmGetFieldBoolean(threadObj, gDvm.offJavaLangThread_daemon);
3351 /* a null value for group is not expected, but deal with it anyway */
3352 groupObj = (Object*) dvmGetFieldObject(threadObj,
3353 gDvm.offJavaLangThread_group);
3354 if (groupObj != NULL) {
3355 nameStr = (StringObject*)
3356 dvmGetFieldObject(groupObj, gDvm.offJavaLangThreadGroup_name);
3357 groupName = dvmCreateCstrFromString(nameStr);
3359 if (groupName == NULL)
3360 groupName = strdup("(null; initializing?)");
3362 SchedulerStats schedStats;
3363 getSchedulerStats(&schedStats, thread->systemTid);
3365 dvmPrintDebugMessage(target,
3366 "\"%s\"%s prio=%d tid=%d %s%s\n",
3367 threadName, isDaemon ? " daemon" : "",
3368 priority, thread->threadId, dvmGetThreadStatusStr(thread->status),
3369 #if defined(WITH_JIT)
3370 thread->inJitCodeCache ? " JIT" : ""
3375 dvmPrintDebugMessage(target,
3376 " | group=\"%s\" sCount=%d dsCount=%d obj=%p self=%p\n",
3377 groupName, thread->suspendCount, thread->dbgSuspendCount,
3378 thread->threadObj, thread);
3379 dvmPrintDebugMessage(target,
3380 " | sysTid=%d nice=%d sched=%d/%d cgrp=%s handle=%d\n",
3381 thread->systemTid, getpriority(PRIO_PROCESS, thread->systemTid),
3382 schedStats.policy, schedStats.priority, schedStats.group, (int)thread->handle);
3384 dumpSchedStat(target, thread->systemTid);
3386 if (shouldShowNativeStack(thread)) {
3387 dvmDumpNativeStack(target, thread->systemTid);
3391 dvmDumpRunningThreadStack(target, thread);
3393 dvmDumpThreadStack(target, thread);
3395 dvmPrintDebugMessage(target, "\n");
3397 dvmReleaseTrackedAlloc(threadObj, NULL);
3402 std::string dvmGetThreadName(Thread* thread) {
3403 if (thread->threadObj == NULL) {
3404 ALOGW("threadObj is NULL, name not available");
3408 StringObject* nameObj = (StringObject*)
3409 dvmGetFieldObject(thread->threadObj, gDvm.offJavaLangThread_name);
3410 char* name = dvmCreateCstrFromString(nameObj);
3411 std::string result(name);
3416 #ifdef HAVE_ANDROID_OS
3418 * Dumps information about a non-Dalvik thread.
3420 static void dumpNativeThread(const DebugOutputTarget* target, pid_t tid) {
3422 snprintf(path, sizeof(path), "/proc/%d/comm", tid);
3424 int fd = open(path, O_RDONLY);
3428 n = read(fd, name, sizeof(name) - 1);
3431 if (n > 0 && name[n - 1] == '\n') {
3435 strcpy(name, "<no name>");
3440 SchedulerStats schedStats;
3441 getSchedulerStats(&schedStats, tid);
3443 dvmPrintDebugMessage(target,
3444 "\"%s\" sysTid=%d nice=%d sched=%d/%d cgrp=%s\n",
3445 name, tid, getpriority(PRIO_PROCESS, tid),
3446 schedStats.policy, schedStats.priority, schedStats.group);
3447 dumpSchedStat(target, tid);
3448 // Temporarily disabled collecting native stacks from non-Dalvik
3449 // threads because sometimes they misbehave.
3450 //dvmDumpNativeStack(target, tid);
3452 dvmPrintDebugMessage(target, "\n");
3456 * Returns true if the specified tid is a Dalvik thread.
3457 * Assumes the thread list lock is held.
3459 static bool isDalvikThread(pid_t tid) {
3460 for (Thread* thread = gDvm.threadList; thread != NULL; thread = thread->next) {
3461 if (thread->systemTid == tid) {
3470 * Dump all threads to the log file -- just calls dvmDumpAllThreadsEx() with
3473 void dvmDumpAllThreads(bool grabLock)
3475 DebugOutputTarget target;
3477 dvmCreateLogOutputTarget(&target, ANDROID_LOG_INFO, LOG_TAG);
3478 dvmDumpAllThreadsEx(&target, grabLock);
3482 * Print information about all known threads. Assumes they have been
3483 * suspended (or are in a non-interpreting state, e.g. WAIT or NATIVE).
3485 * If "grabLock" is true, we grab the thread lock list. This is important
3486 * to do unless the caller already holds the lock.
3488 void dvmDumpAllThreadsEx(const DebugOutputTarget* target, bool grabLock)
3492 dvmPrintDebugMessage(target, "DALVIK THREADS:\n");
3494 #ifdef HAVE_ANDROID_OS
3495 dvmPrintDebugMessage(target,
3496 "(mutexes: tll=%x tsl=%x tscl=%x ghl=%x)\n\n",
3497 gDvm.threadListLock.value,
3498 gDvm._threadSuspendLock.value,
3499 gDvm.threadSuspendCountLock.value,
3500 gDvm.gcHeapLock.value);
3504 dvmLockThreadList(dvmThreadSelf());
3506 thread = gDvm.threadList;
3507 while (thread != NULL) {
3508 dvmDumpThreadEx(target, thread, false);
3511 assert(thread->next == NULL || thread->next->prev == thread);
3513 thread = thread->next;
3516 #ifdef HAVE_ANDROID_OS
3517 DIR* d = opendir("/proc/self/task");
3519 dirent* entry = NULL;
3521 while ((entry = readdir(d)) != NULL) {
3523 pid_t tid = strtol(entry->d_name, &end, 10);
3524 if (!*end && !isDalvikThread(tid)) {
3526 dvmPrintDebugMessage(target, "NATIVE THREADS:\n");
3529 dumpNativeThread(target, tid);
3537 dvmUnlockThreadList();
3541 * Nuke the target thread from orbit.
3543 * The idea is to send a "crash" signal to the target thread so that
3544 * debuggerd will take notice and dump an appropriate stack trace.
3545 * Because of the way debuggerd works, we have to throw the same signal
3548 * This does not necessarily cause the entire process to stop, but once a
3549 * thread has been nuked the rest of the system is likely to be unstable.
3550 * This returns so that some limited set of additional operations may be
3551 * performed, but it's advisable (and expected) to call dvmAbort soon.
3552 * (This is NOT a way to simply cancel a thread.)
3554 void dvmNukeThread(Thread* thread)
3558 /* suppress the heapworker watchdog to assist anyone using a debugger */
3559 gDvm.nativeDebuggerActive = true;
3562 * Send the signals, separated by a brief interval to allow debuggerd
3563 * to work its magic. An uncommon signal like SIGFPE or SIGSTKFLT
3564 * can be used instead of SIGSEGV to avoid making it look like the
3565 * code actually crashed at the current point of execution.
3567 * (Observed behavior: with SIGFPE, debuggerd will dump the target
3568 * thread and then the thread that calls dvmAbort. With SIGSEGV,
3569 * you don't get the second stack trace; possibly something in the
3570 * kernel decides that a signal has already been sent and it's time
3571 * to just kill the process. The position in the current thread is
3572 * generally known, so the second dump is not useful.)
3574 * The target thread can continue to execute between the two signals.
3575 * (The first just causes debuggerd to attach to it.)
3578 #define SIG SIGSTKFLT
3579 #define SIGNAME "SIGSTKFLT"
3580 #elif defined(SIGEMT)
3582 #define SIGNAME "SIGEMT"
3584 #error No signal available for dvmNukeThread
3587 ALOGD("threadid=%d: sending two " SIGNAME "s to threadid=%d (tid=%d) to"
3588 " cause debuggerd dump",
3589 dvmThreadSelf()->threadId, thread->threadId, thread->systemTid);
3590 killResult = pthread_kill(thread->handle, SIG);
3591 if (killResult != 0) {
3592 ALOGD("NOTE: pthread_kill #1 failed: %s", strerror(killResult));
3594 usleep(2 * 1000 * 1000); // TODO: timed-wait until debuggerd attaches
3595 killResult = pthread_kill(thread->handle, SIG);
3596 if (killResult != 0) {
3597 ALOGD("NOTE: pthread_kill #2 failed: %s", strerror(killResult));
3599 ALOGD("Sent, pausing to let debuggerd run");
3600 usleep(8 * 1000 * 1000); // TODO: timed-wait until debuggerd finishes
3602 /* ignore SIGSEGV so the eventual dvmAbort() doesn't notify debuggerd */
3603 signal(SIGSEGV, SIG_IGN);
3604 ALOGD("Continuing");