1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define ATRACE_TAG ATRACE_TAG_DALVIK
18
19 /*
20 * Thread support.
21 */
22 #include "Dalvik.h"
23 #include "os/os.h"
24
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <sys/time.h>
28 #include <sys/types.h>
29 #include <sys/resource.h>
30 #include <sys/mman.h>
31 #include <signal.h>
32 #include <dirent.h>
33 #include <errno.h>
34 #include <fcntl.h>
35
36 #if defined(HAVE_PRCTL)
37 #include <sys/prctl.h>
38 #endif
39
40 #if defined(WITH_SELF_VERIFICATION)
41 #include "interp/Jit.h" // need for self verification
42 #endif
43
44 #include <cutils/trace.h>
45
46 /* desktop Linux needs a little help with gettid() */
47 #if defined(HAVE_GETTID) && !defined(HAVE_ANDROID_OS)
48 #define __KERNEL__
49 # include <linux/unistd.h>
50 #ifdef _syscall0
51 _syscall0(pid_t,gettid)
52 #else
53 pid_t gettid() { return syscall(__NR_gettid);}
54 #endif
55 #undef __KERNEL__
56 #endif
57
58 // Change this to enable logging on cgroup errors
59 #define ENABLE_CGROUP_ERR_LOGGING 0
60
61 // change this to ALOGV/ALOGD to debug thread activity
62 #define LOG_THREAD LOGVV
63
64 /*
65 Notes on Threading
66
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.
72
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.
78
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.
83
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.
87
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).
96
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.
102
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.
108
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.
117
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
126 debugger attached.)
127
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).
131
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().
139 */
140 /*
141 Alternate implementation (signal-based):
142
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.
145
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
149 to the VM code.
150
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.
155
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).
163
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:
170
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
173 resource set" (CRS).
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.
178
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.)
184
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.
190
191 An ordering should be established for all locks to avoid deadlocks.
192
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.
196
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.
199
200 There are (at least) two ways to handle the incoming signals:
201
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.
209
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.
218
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.
222
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)
227 */
228
229 #define kMaxThreadId ((1 << 16) - 1)
230 #define kMainThreadId 1
231
232
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);
246
247 /*
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).
251 */
dvmThreadStartup()252 bool dvmThreadStartup()
253 {
254 Thread* thread;
255
256 /* allocate a TLS slot */
257 if (pthread_key_create(&gDvm.pthreadKeySelf, threadExitCheck) != 0) {
258 ALOGE("ERROR: pthread_key_create failed");
259 return false;
260 }
261
262 /* test our pthread lib */
263 if (pthread_getspecific(gDvm.pthreadKeySelf) != NULL)
264 ALOGW("WARNING: newly-created pthread TLS slot is not NULL");
265
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);
273
274 /*
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.
280 */
281 gDvm.threadSleepMon = dvmCreateMonitor(NULL);
282
283 gDvm.threadIdMap = dvmAllocBitVector(kMaxThreadId, false);
284
285 thread = allocThread(gDvm.mainThreadStackSize);
286 if (thread == NULL)
287 return false;
288
289 /* switch mode for when we run initializers */
290 thread->status = THREAD_RUNNING;
291
292 /*
293 * We need to assign the threadId early so we can lock/notify
294 * object monitors. We'll set the "threadObj" field later.
295 */
296 prepareThread(thread);
297 gDvm.threadList = thread;
298
299 #ifdef COUNT_PRECISE_METHODS
300 gDvm.preciseMethods = dvmPointerSetAlloc(200);
301 #endif
302
303 return true;
304 }
305
306 /*
307 * All threads should be stopped by now. Clean up some thread globals.
308 */
dvmThreadShutdown()309 void dvmThreadShutdown()
310 {
311 if (gDvm.threadList != NULL) {
312 /*
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.
317 */
318 freeThread(gDvm.threadList);
319 gDvm.threadList = NULL;
320 }
321
322 dvmFreeBitVector(gDvm.threadIdMap);
323
324 dvmFreeMonitorList();
325
326 pthread_key_delete(gDvm.pthreadKeySelf);
327 }
328
329
330 /*
331 * Grab the suspend count global lock.
332 */
lockThreadSuspendCount()333 static inline void lockThreadSuspendCount()
334 {
335 /*
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.
339 *
340 * This lock is always held for very brief periods, so as long as
341 * mutex ordering is respected we shouldn't stall.
342 */
343 dvmLockMutex(&gDvm.threadSuspendCountLock);
344 }
345
346 /*
347 * Release the suspend count global lock.
348 */
unlockThreadSuspendCount()349 static inline void unlockThreadSuspendCount()
350 {
351 dvmUnlockMutex(&gDvm.threadSuspendCountLock);
352 }
353
354 /*
355 * Grab the thread list global lock.
356 *
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.
361 *
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.
365 *
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.)
370 *
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.
375 */
dvmLockThreadList(Thread * self)376 void dvmLockThreadList(Thread* self)
377 {
378 ThreadStatus oldStatus;
379
380 if (self == NULL) /* try to get it from TLS */
381 self = dvmThreadSelf();
382
383 if (self != NULL) {
384 oldStatus = self->status;
385 self->status = THREAD_VMWAIT;
386 } else {
387 /* happens during VM shutdown */
388 oldStatus = THREAD_UNDEFINED; // shut up gcc
389 }
390
391 dvmLockMutex(&gDvm.threadListLock);
392
393 if (self != NULL)
394 self->status = oldStatus;
395 }
396
397 /*
398 * Try to lock the thread list.
399 *
400 * Returns "true" if we locked it. This is a "fast" mutex, so if the
401 * current thread holds the lock this will fail.
402 */
dvmTryLockThreadList()403 bool dvmTryLockThreadList()
404 {
405 return (dvmTryLockMutex(&gDvm.threadListLock) == 0);
406 }
407
408 /*
409 * Release the thread list global lock.
410 */
dvmUnlockThreadList()411 void dvmUnlockThreadList()
412 {
413 dvmUnlockMutex(&gDvm.threadListLock);
414 }
415
416 /*
417 * Convert SuspendCause to a string.
418 */
getSuspendCauseStr(SuspendCause why)419 static const char* getSuspendCauseStr(SuspendCause why)
420 {
421 switch (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";
434 #endif
435 default: return "UNKNOWN";
436 }
437 }
438
439 /*
440 * Grab the "thread suspend" lock. This is required to prevent the
441 * GC and the debugger from simultaneously suspending all threads.
442 *
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.
446 */
lockThreadSuspend(const char * who,SuspendCause why)447 static void lockThreadSuspend(const char* who, SuspendCause why)
448 {
449 const int kSpinSleepTime = 3*1000*1000; /* 3s */
450 u8 startWhen = 0; // init req'd to placate gcc
451 int sleepIter = 0;
452 int cc;
453
454 do {
455 cc = dvmTryLockMutex(&gDvm._threadSuspendLock);
456 if (cc != 0) {
457 Thread* self = dvmThreadSelf();
458
459 if (!dvmCheckSuspendPending(self)) {
460 /*
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.)
466 *
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.
470 *
471 * Could be an unusual JNI thread-attach thing.
472 *
473 * Could be the debugger telling us to resume at roughly
474 * the same time we're posting an event.
475 *
476 * Could be two app threads both want to patch predicted
477 * chaining cells around the same time.
478 */
479 ALOGI("threadid=%d ODD: want thread-suspend lock (%s:%s),"
480 " it's held, no suspend pending",
481 self->threadId, who, getSuspendCauseStr(why));
482 } else {
483 /* we suspended; reset timeout */
484 sleepIter = 0;
485 }
486
487 /* give the lock-holder a chance to do some work */
488 if (sleepIter == 0)
489 startWhen = dvmGetRelativeTimeUsec();
490 if (!dvmIterativeSleep(sleepIter++, kSpinSleepTime, startWhen)) {
491 ALOGE("threadid=%d: couldn't get thread-suspend lock (%s:%s),"
492 " bailing",
493 self->threadId, who, getSuspendCauseStr(why));
494 /* threads are not suspended, thread dump could crash */
495 dvmDumpAllThreads(false);
496 dvmAbort();
497 }
498 }
499 } while (cc != 0);
500 assert(cc == 0);
501 }
502
503 /*
504 * Release the "thread suspend" lock.
505 */
unlockThreadSuspend()506 static inline void unlockThreadSuspend()
507 {
508 dvmUnlockMutex(&gDvm._threadSuspendLock);
509 }
510
511
512 /*
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.)
520 *
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.
524 *
525 * It's possible for this function to get called after a failed
526 * initialization, so be careful with assumptions about the environment.
527 *
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.
531 */
dvmSlayDaemons()532 void dvmSlayDaemons()
533 {
534 Thread* self = dvmThreadSelf(); // may be null
535 Thread* target;
536 int threadId = 0;
537 bool doWait = false;
538
539 dvmLockThreadList(self);
540
541 if (self != NULL)
542 threadId = self->threadId;
543
544 target = gDvm.threadList;
545 while (target != NULL) {
546 if (target == self) {
547 target = target->next;
548 continue;
549 }
550
551 if (!dvmGetFieldBoolean(target->threadObj,
552 gDvm.offJavaLangThread_daemon))
553 {
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);
557 }
558
559 std::string threadName(dvmGetThreadName(target));
560 ALOGV("threadid=%d: suspending daemon id=%d name='%s'",
561 threadId, target->threadId, threadName.c_str());
562
563 /* mark as suspended */
564 lockThreadSuspendCount();
565 dvmAddToSuspendCounts(target, 1, 0);
566 unlockThreadSuspendCount();
567 doWait = true;
568
569 target = target->next;
570 }
571
572 //dvmDumpAllThreads(false);
573
574 /*
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.
580 *
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.)
584 */
585 dvmUnlockThreadList();
586
587 if (doWait) {
588 bool complained = false;
589
590 usleep(200 * 1000);
591
592 dvmLockThreadList(self);
593
594 /*
595 * Sleep for a bit until the threads have suspended. We're trying
596 * to exit, so don't wait for too long.
597 */
598 int i;
599 for (i = 0; i < 10; i++) {
600 bool allSuspended = true;
601
602 target = gDvm.threadList;
603 while (target != NULL) {
604 if (target == self) {
605 target = target->next;
606 continue;
607 }
608
609 if (target->status == THREAD_RUNNING) {
610 if (!complained)
611 ALOGD("threadid=%d not ready yet", target->threadId);
612 allSuspended = false;
613 /* keep going so we log each running daemon once */
614 }
615
616 target = target->next;
617 }
618
619 if (allSuspended) {
620 ALOGV("threadid=%d: all daemons have suspended", threadId);
621 break;
622 } else {
623 if (!complained) {
624 complained = true;
625 ALOGD("threadid=%d: waiting briefly for daemon suspension",
626 threadId);
627 }
628 }
629
630 usleep(200 * 1000);
631 }
632 dvmUnlockThreadList();
633 }
634
635 #if 0 /* bad things happen if they come out of JNI or "spuriously" wake up */
636 /*
637 * Abandon the threads and recover their resources.
638 */
639 target = gDvm.threadList;
640 while (target != NULL) {
641 Thread* nextTarget = target->next;
642 unlinkThread(target);
643 freeThread(target);
644 target = nextTarget;
645 }
646 #endif
647
648 //dvmDumpAllThreads(true);
649 }
650
651
652 /*
653 * Finish preparing the parts of the Thread struct required to support
654 * JNI registration.
655 */
dvmPrepMainForJni(JNIEnv * pEnv)656 bool dvmPrepMainForJni(JNIEnv* pEnv)
657 {
658 Thread* self;
659
660 /* main thread is always first in list at this point */
661 self = gDvm.threadList;
662 assert(self->threadId == kMainThreadId);
663
664 /* create a "fake" JNI frame at the top of the main thread interp stack */
665 if (!createFakeEntryFrame(self))
666 return false;
667
668 /* fill these in, since they weren't ready at dvmCreateJNIEnv time */
669 dvmSetJniEnvThreadId(pEnv, self);
670 dvmSetThreadJNIEnv(self, (JNIEnv*) pEnv);
671
672 return true;
673 }
674
675
676 /*
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).
680 */
dvmPrepMainThread()681 bool dvmPrepMainThread()
682 {
683 Thread* thread;
684 Object* groupObj;
685 Object* threadObj;
686 Object* vmThreadObj;
687 StringObject* threadNameStr;
688 Method* init;
689 JValue unused;
690
691 ALOGV("+++ finishing prep on main VM thread");
692
693 /* main thread is always first in list at this point */
694 thread = gDvm.threadList;
695 assert(thread->threadId == kMainThreadId);
696
697 /*
698 * Make sure the classes are initialized. We have to do this before
699 * we create an instance of them.
700 */
701 if (!dvmInitClass(gDvm.classJavaLangClass)) {
702 ALOGE("'Class' class failed to initialize");
703 return false;
704 }
705 if (!dvmInitClass(gDvm.classJavaLangThreadGroup) ||
706 !dvmInitClass(gDvm.classJavaLangThread) ||
707 !dvmInitClass(gDvm.classJavaLangVMThread))
708 {
709 ALOGE("thread classes failed to initialize");
710 return false;
711 }
712
713 groupObj = dvmGetMainThreadGroup();
714 if (groupObj == NULL)
715 return false;
716
717 /*
718 * Allocate and construct a Thread with the internal-creation
719 * constructor.
720 */
721 threadObj = dvmAllocObject(gDvm.classJavaLangThread, ALLOC_DEFAULT);
722 if (threadObj == NULL) {
723 ALOGE("unable to allocate main thread object");
724 return false;
725 }
726 dvmReleaseTrackedAlloc(threadObj, NULL);
727
728 threadNameStr = dvmCreateStringFromCstr("main");
729 if (threadNameStr == NULL)
730 return false;
731 dvmReleaseTrackedAlloc((Object*)threadNameStr, NULL);
732
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");
740 return false;
741 }
742
743 /*
744 * Allocate and construct a VMThread.
745 */
746 vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
747 if (vmThreadObj == NULL) {
748 ALOGE("unable to allocate main vmthread object");
749 return false;
750 }
751 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
752
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");
758 return false;
759 }
760
761 /* set the VMThread.vmData field to our Thread struct */
762 assert(gDvm.offJavaLangVMThread_vmData != 0);
763 dvmSetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData, (u4)thread);
764
765 /*
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).
769 */
770 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread,
771 vmThreadObj);
772
773 thread->threadObj = threadObj;
774
775 /*
776 * Set the "context class loader" field in the system class loader.
777 *
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
781 * before we do this.
782 */
783 Object* systemLoader = dvmGetSystemClassLoader();
784 if (systemLoader == NULL) {
785 ALOGW("WARNING: system class loader is NULL (setting main ctxt)");
786 /* keep going? */
787 } else {
788 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_contextClassLoader,
789 systemLoader);
790 dvmReleaseTrackedAlloc(systemLoader, NULL);
791 }
792
793 /* include self in non-daemon threads (mainly for AttachCurrentThread) */
794 gDvm.nonDaemonThreadCount++;
795
796 return true;
797 }
798
799
800 /*
801 * Alloc and initialize a Thread struct.
802 *
803 * Does not create any objects, just stuff on the system (malloc) heap.
804 */
allocThread(int interpStackSize)805 static Thread* allocThread(int interpStackSize)
806 {
807 Thread* thread;
808 u1* stackBottom;
809
810 thread = (Thread*) calloc(1, sizeof(Thread));
811 if (thread == NULL)
812 return NULL;
813
814 /* Check sizes and alignment */
815 assert((((uintptr_t)&thread->interpBreak.all) & 0x7) == 0);
816 assert(sizeof(thread->interpBreak) == sizeof(thread->interpBreak.all));
817
818
819 #if defined(WITH_SELF_VERIFICATION)
820 if (dvmSelfVerificationShadowSpaceAlloc(thread) == NULL)
821 return NULL;
822 #endif
823
824 assert(interpStackSize >= kMinStackSize && interpStackSize <=kMaxStackSize);
825
826 thread->status = THREAD_INITIALIZING;
827
828 /*
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.
832 *
833 * The stack must be aligned on a 4-byte boundary.
834 */
835 #ifdef MALLOC_INTERP_STACK
836 stackBottom = (u1*) malloc(interpStackSize);
837 if (stackBottom == NULL) {
838 #if defined(WITH_SELF_VERIFICATION)
839 dvmSelfVerificationShadowSpaceFree(thread);
840 #endif
841 free(thread);
842 return NULL;
843 }
844 memset(stackBottom, 0xc5, interpStackSize); // stop valgrind complaints
845 #else
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);
851 #endif
852 free(thread);
853 return NULL;
854 }
855 #endif
856
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;
861
862 #ifndef DVM_NO_ASM_INTERP
863 thread->mainHandlerTable = dvmAsmInstructionStart;
864 thread->altHandlerTable = dvmAsmAltInstructionStart;
865 thread->interpBreak.ctl.curHandlerTable = thread->mainHandlerTable;
866 #endif
867
868 /* give the thread code a chance to set things up */
869 dvmInitInterpStack(thread, interpStackSize);
870
871 /* One-time setup for interpreter/JIT state */
872 dvmInitInterpreterState(thread);
873
874 return thread;
875 }
876
877 /*
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").
881 */
dvmGetSysThreadId()882 pid_t dvmGetSysThreadId()
883 {
884 #ifdef HAVE_GETTID
885 return gettid();
886 #else
887 return getpid();
888 #endif
889 }
890
891 /*
892 * Finish initialization of a Thread struct.
893 *
894 * This must be called while executing in the new thread, but before the
895 * thread is added to the thread list.
896 *
897 * NOTE: The threadListLock must be held by the caller (needed for
898 * assignThreadId()).
899 */
prepareThread(Thread * thread)900 static bool prepareThread(Thread* thread)
901 {
902 assignThreadId(thread);
903 thread->handle = pthread_self();
904 thread->systemTid = dvmGetSysThreadId();
905
906 //ALOGI("SYSTEM TID IS %d (pid is %d)", (int) thread->systemTid,
907 // (int) getpid());
908 /*
909 * If we were called by dvmAttachCurrentThread, the self value is
910 * already correctly established as "thread".
911 */
912 setThreadSelf(thread);
913
914 ALOGV("threadid=%d: interp stack at %p",
915 thread->threadId, thread->interpStackStart - thread->interpStackSize);
916
917 /*
918 * Initialize invokeReq.
919 */
920 dvmInitMutex(&thread->invokeReq.lock);
921 pthread_cond_init(&thread->invokeReq.cv, NULL);
922
923 /*
924 * Initialize our reference tracking tables.
925 *
926 * Most threads won't use jniMonitorRefTable, so we clear out the
927 * structure but don't call the init function (which allocs storage).
928 */
929 if (!thread->jniLocalRefTable.init(kJniLocalRefMin,
930 kJniLocalRefMax, kIndirectKindLocal)) {
931 return false;
932 }
933 if (!dvmInitReferenceTable(&thread->internalLocalRefTable,
934 kInternalRefDefault, kInternalRefMax))
935 return false;
936
937 memset(&thread->jniMonitorRefTable, 0, sizeof(thread->jniMonitorRefTable));
938
939 pthread_cond_init(&thread->waitCond, NULL);
940 dvmInitMutex(&thread->waitMutex);
941
942 /* Initialize safepoint callback mechanism */
943 dvmInitMutex(&thread->callbackMutex);
944
945 return true;
946 }
947
948 /*
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.
952 */
unlinkThread(Thread * thread)953 static void unlinkThread(Thread* thread)
954 {
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;
959 } else {
960 assert(thread->prev != NULL);
961 thread->prev->next = thread->next;
962 }
963 if (thread->next != NULL)
964 thread->next->prev = thread->prev;
965 thread->prev = thread->next = NULL;
966 }
967
968 /*
969 * Free a Thread struct, and all the stuff allocated within.
970 */
freeThread(Thread * thread)971 static void freeThread(Thread* thread)
972 {
973 if (thread == NULL)
974 return;
975
976 /* thread->threadId is zero at this point */
977 LOGVV("threadid=%d: freeing", thread->threadId);
978
979 if (thread->interpStackStart != NULL) {
980 u1* interpStackBottom;
981
982 interpStackBottom = thread->interpStackStart;
983 interpStackBottom -= thread->interpStackSize;
984 #ifdef MALLOC_INTERP_STACK
985 free(interpStackBottom);
986 #else
987 if (munmap(interpStackBottom, thread->interpStackSize) != 0)
988 ALOGW("munmap(thread stack) failed");
989 #endif
990 }
991
992 thread->jniLocalRefTable.destroy();
993 dvmClearReferenceTable(&thread->internalLocalRefTable);
994 if (&thread->jniMonitorRefTable.table != NULL)
995 dvmClearReferenceTable(&thread->jniMonitorRefTable);
996
997 #if defined(WITH_SELF_VERIFICATION)
998 dvmSelfVerificationShadowSpaceFree(thread);
999 #endif
1000 free(thread->stackTraceSample);
1001 free(thread);
1002 }
1003
1004 /*
1005 * Like pthread_self(), but on a Thread*.
1006 */
dvmThreadSelf()1007 Thread* dvmThreadSelf()
1008 {
1009 return (Thread*) pthread_getspecific(gDvm.pthreadKeySelf);
1010 }
1011
1012 /*
1013 * Explore our sense of self. Stuffs the thread pointer into TLS.
1014 */
setThreadSelf(Thread * thread)1015 static void setThreadSelf(Thread* thread)
1016 {
1017 int cc;
1018
1019 cc = pthread_setspecific(gDvm.pthreadKeySelf, thread);
1020 if (cc != 0) {
1021 /*
1022 * Sometimes this fails under Bionic with EINVAL during shutdown.
1023 * This can happen if the timing is just right, e.g. a thread
1024 * fails to attach during shutdown, but the "fail" path calls
1025 * here to ensure we clean up after ourselves.
1026 */
1027 if (thread != NULL) {
1028 ALOGE("pthread_setspecific(%p) failed, err=%d", thread, cc);
1029 dvmAbort(); /* the world is fundamentally hosed */
1030 }
1031 }
1032 }
1033
1034 /*
1035 * This is associated with the pthreadKeySelf key. It's called by the
1036 * pthread library when a thread is exiting and the "self" pointer in TLS
1037 * is non-NULL, meaning the VM hasn't had a chance to clean up. In normal
1038 * operation this will not be called.
1039 *
1040 * This is mainly of use to ensure that we don't leak resources if, for
1041 * example, a thread attaches itself to us with AttachCurrentThread and
1042 * then exits without notifying the VM.
1043 *
1044 * We could do the detach here instead of aborting, but this will lead to
1045 * portability problems. Other implementations do not do this check and
1046 * will simply be unaware that the thread has exited, leading to resource
1047 * leaks (and, if this is a non-daemon thread, an infinite hang when the
1048 * VM tries to shut down).
1049 *
1050 * Because some implementations may want to use the pthread destructor
1051 * to initiate the detach, and the ordering of destructors is not defined,
1052 * we want to iterate a couple of times to give those a chance to run.
1053 */
threadExitCheck(void * arg)1054 static void threadExitCheck(void* arg)
1055 {
1056 const int kMaxCount = 2;
1057
1058 Thread* self = (Thread*) arg;
1059 assert(self != NULL);
1060
1061 ALOGV("threadid=%d: threadExitCheck(%p) count=%d",
1062 self->threadId, arg, self->threadExitCheckCount);
1063
1064 if (self->status == THREAD_ZOMBIE) {
1065 ALOGW("threadid=%d: Weird -- shouldn't be in threadExitCheck",
1066 self->threadId);
1067 return;
1068 }
1069
1070 if (self->threadExitCheckCount < kMaxCount) {
1071 /*
1072 * Spin a couple of times to let other destructors fire.
1073 */
1074 ALOGD("threadid=%d: thread exiting, not yet detached (count=%d)",
1075 self->threadId, self->threadExitCheckCount);
1076 self->threadExitCheckCount++;
1077 int cc = pthread_setspecific(gDvm.pthreadKeySelf, self);
1078 if (cc != 0) {
1079 ALOGE("threadid=%d: unable to re-add thread to TLS",
1080 self->threadId);
1081 dvmAbort();
1082 }
1083 } else {
1084 ALOGE("threadid=%d: native thread exited without detaching",
1085 self->threadId);
1086 dvmAbort();
1087 }
1088 }
1089
1090
1091 /*
1092 * Assign the threadId. This needs to be a small integer so that our
1093 * "thin" locks fit in a small number of bits.
1094 *
1095 * We reserve zero for use as an invalid ID.
1096 *
1097 * This must be called with threadListLock held.
1098 */
assignThreadId(Thread * thread)1099 static void assignThreadId(Thread* thread)
1100 {
1101 /*
1102 * Find a small unique integer. threadIdMap is a vector of
1103 * kMaxThreadId bits; dvmAllocBit() returns the index of a
1104 * bit, meaning that it will always be < kMaxThreadId.
1105 */
1106 int num = dvmAllocBit(gDvm.threadIdMap);
1107 if (num < 0) {
1108 ALOGE("Ran out of thread IDs");
1109 dvmAbort(); // TODO: make this a non-fatal error result
1110 }
1111
1112 thread->threadId = num + 1;
1113
1114 assert(thread->threadId != 0);
1115 }
1116
1117 /*
1118 * Give back the thread ID.
1119 */
releaseThreadId(Thread * thread)1120 static void releaseThreadId(Thread* thread)
1121 {
1122 assert(thread->threadId > 0);
1123 dvmClearBit(gDvm.threadIdMap, thread->threadId - 1);
1124 thread->threadId = 0;
1125 }
1126
1127
1128 /*
1129 * Add a stack frame that makes it look like the native code in the main
1130 * thread was originally invoked from interpreted code. This gives us a
1131 * place to hang JNI local references. The VM spec says (v2 5.2) that the
1132 * VM begins by executing "main" in a class, so in a way this brings us
1133 * closer to the spec.
1134 */
createFakeEntryFrame(Thread * thread)1135 static bool createFakeEntryFrame(Thread* thread)
1136 {
1137 /*
1138 * Because we are creating a frame that represents application code, we
1139 * want to stuff the application class loader into the method's class
1140 * loader field, even though we're using the system class loader to
1141 * load it. This makes life easier over in JNI FindClass (though it
1142 * could bite us in other ways).
1143 *
1144 * Unfortunately this is occurring too early in the initialization,
1145 * of necessity coming before JNI is initialized, and we're not quite
1146 * ready to set up the application class loader. Also, overwriting
1147 * the class' defining classloader pointer seems unwise.
1148 *
1149 * Instead, we save a pointer to the method and explicitly check for
1150 * it in FindClass. The method is private so nobody else can call it.
1151 */
1152
1153 assert(thread->threadId == kMainThreadId); /* main thread only */
1154
1155 if (!dvmPushJNIFrame(thread, gDvm.methDalvikSystemNativeStart_main))
1156 return false;
1157
1158 /*
1159 * Null out the "String[] args" argument.
1160 */
1161 assert(gDvm.methDalvikSystemNativeStart_main->registersSize == 1);
1162 u4* framePtr = (u4*) thread->interpSave.curFrame;
1163 framePtr[0] = 0;
1164
1165 return true;
1166 }
1167
1168
1169 /*
1170 * Add a stack frame that makes it look like the native thread has been
1171 * executing interpreted code. This gives us a place to hang JNI local
1172 * references.
1173 */
createFakeRunFrame(Thread * thread)1174 static bool createFakeRunFrame(Thread* thread)
1175 {
1176 return dvmPushJNIFrame(thread, gDvm.methDalvikSystemNativeStart_run);
1177 }
1178
1179 /*
1180 * Helper function to set the name of the current thread
1181 */
setThreadName(const char * threadName)1182 static void setThreadName(const char *threadName)
1183 {
1184 int hasAt = 0;
1185 int hasDot = 0;
1186 const char *s = threadName;
1187 while (*s) {
1188 if (*s == '.') hasDot = 1;
1189 else if (*s == '@') hasAt = 1;
1190 s++;
1191 }
1192 int len = s - threadName;
1193 if (len < 15 || hasAt || !hasDot) {
1194 s = threadName;
1195 } else {
1196 s = threadName + len - 15;
1197 }
1198 #if defined(HAVE_ANDROID_PTHREAD_SETNAME_NP)
1199 /* pthread_setname_np fails rather than truncating long strings */
1200 char buf[16]; // MAX_TASK_COMM_LEN=16 is hard-coded into bionic
1201 strncpy(buf, s, sizeof(buf)-1);
1202 buf[sizeof(buf)-1] = '\0';
1203 int err = pthread_setname_np(pthread_self(), buf);
1204 if (err != 0) {
1205 ALOGW("Unable to set the name of current thread to '%s': %s",
1206 buf, strerror(err));
1207 }
1208 #elif defined(HAVE_PRCTL)
1209 prctl(PR_SET_NAME, (unsigned long) s, 0, 0, 0);
1210 #else
1211 ALOGD("No way to set current thread's name (%s)", s);
1212 #endif
1213 }
1214
1215 /*
1216 * Create a thread as a result of java.lang.Thread.start().
1217 *
1218 * We do have to worry about some concurrency problems, e.g. programs
1219 * that try to call Thread.start() on the same object from multiple threads.
1220 * (This will fail for all but one, but we have to make sure that it succeeds
1221 * for exactly one.)
1222 *
1223 * Some of the complexity here arises from our desire to mimic the
1224 * Thread vs. VMThread class decomposition we inherited. We've been given
1225 * a Thread, and now we need to create a VMThread and then populate both
1226 * objects. We also need to create one of our internal Thread objects.
1227 *
1228 * Pass in a stack size of 0 to get the default.
1229 *
1230 * The "threadObj" reference must be pinned by the caller to prevent the GC
1231 * from moving it around (e.g. added to the tracked allocation list).
1232 */
dvmCreateInterpThread(Object * threadObj,int reqStackSize)1233 bool dvmCreateInterpThread(Object* threadObj, int reqStackSize)
1234 {
1235 assert(threadObj != NULL);
1236
1237 Thread* self = dvmThreadSelf();
1238 int stackSize;
1239 if (reqStackSize == 0)
1240 stackSize = gDvm.stackSize;
1241 else if (reqStackSize < kMinStackSize)
1242 stackSize = kMinStackSize;
1243 else if (reqStackSize > kMaxStackSize)
1244 stackSize = kMaxStackSize;
1245 else
1246 stackSize = reqStackSize;
1247
1248 pthread_attr_t threadAttr;
1249 pthread_attr_init(&threadAttr);
1250 pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
1251
1252 /*
1253 * To minimize the time spent in the critical section, we allocate the
1254 * vmThread object here.
1255 */
1256 Object* vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
1257 if (vmThreadObj == NULL)
1258 return false;
1259
1260 Thread* newThread = allocThread(stackSize);
1261 if (newThread == NULL) {
1262 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1263 return false;
1264 }
1265
1266 newThread->threadObj = threadObj;
1267
1268 assert(newThread->status == THREAD_INITIALIZING);
1269
1270 /*
1271 * We need to lock out other threads while we test and set the
1272 * "vmThread" field in java.lang.Thread, because we use that to determine
1273 * if this thread has been started before. We use the thread list lock
1274 * because it's handy and we're going to need to grab it again soon
1275 * anyway.
1276 */
1277 dvmLockThreadList(self);
1278
1279 if (dvmGetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread) != NULL) {
1280 dvmUnlockThreadList();
1281 dvmThrowIllegalThreadStateException(
1282 "thread has already been started");
1283 freeThread(newThread);
1284 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1285 return false;
1286 }
1287
1288 /*
1289 * There are actually three data structures: Thread (object), VMThread
1290 * (object), and Thread (C struct). All of them point to at least one
1291 * other.
1292 *
1293 * As soon as "VMThread.vmData" is assigned, other threads can start
1294 * making calls into us (e.g. setPriority).
1295 */
1296 dvmSetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData, (u4)newThread);
1297 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread, vmThreadObj);
1298
1299 /*
1300 * Thread creation might take a while, so release the lock.
1301 */
1302 dvmUnlockThreadList();
1303
1304 ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
1305 pthread_t threadHandle;
1306 int cc = pthread_create(&threadHandle, &threadAttr, interpThreadStart, newThread);
1307 pthread_attr_destroy(&threadAttr);
1308 dvmChangeStatus(self, oldStatus);
1309
1310 if (cc != 0) {
1311 /*
1312 * Failure generally indicates that we have exceeded system
1313 * resource limits. VirtualMachineError is probably too severe,
1314 * so use OutOfMemoryError.
1315 */
1316
1317 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread, NULL);
1318
1319 ALOGE("pthread_create (stack size %d bytes) failed: %s", stackSize, strerror(cc));
1320 dvmThrowExceptionFmt(gDvm.exOutOfMemoryError,
1321 "pthread_create (stack size %d bytes) failed: %s",
1322 stackSize, strerror(cc));
1323 goto fail;
1324 }
1325
1326 /*
1327 * We need to wait for the thread to start. Otherwise, depending on
1328 * the whims of the OS scheduler, we could return and the code in our
1329 * thread could try to do operations on the new thread before it had
1330 * finished starting.
1331 *
1332 * The new thread will lock the thread list, change its state to
1333 * THREAD_STARTING, broadcast to gDvm.threadStartCond, and then sleep
1334 * on gDvm.threadStartCond (which uses the thread list lock). This
1335 * thread (the parent) will either see that the thread is already ready
1336 * after we grab the thread list lock, or will be awakened from the
1337 * condition variable on the broadcast.
1338 *
1339 * We don't want to stall the rest of the VM while the new thread
1340 * starts, which can happen if the GC wakes up at the wrong moment.
1341 * So, we change our own status to VMWAIT, and self-suspend if
1342 * necessary after we finish adding the new thread.
1343 *
1344 *
1345 * We have to deal with an odd race with the GC/debugger suspension
1346 * mechanism when creating a new thread. The information about whether
1347 * or not a thread should be suspended is contained entirely within
1348 * the Thread struct; this is usually cleaner to deal with than having
1349 * one or more globally-visible suspension flags. The trouble is that
1350 * we could create the thread while the VM is trying to suspend all
1351 * threads. The suspend-count won't be nonzero for the new thread,
1352 * so dvmChangeStatus(THREAD_RUNNING) won't cause a suspension.
1353 *
1354 * The easiest way to deal with this is to prevent the new thread from
1355 * running until the parent says it's okay. This results in the
1356 * following (correct) sequence of events for a "badly timed" GC
1357 * (where '-' is us, 'o' is the child, and '+' is some other thread):
1358 *
1359 * - call pthread_create()
1360 * - lock thread list
1361 * - put self into THREAD_VMWAIT so GC doesn't wait for us
1362 * - sleep on condition var (mutex = thread list lock) until child starts
1363 * + GC triggered by another thread
1364 * + thread list locked; suspend counts updated; thread list unlocked
1365 * + loop waiting for all runnable threads to suspend
1366 * + success, start GC
1367 * o child thread wakes, signals condition var to wake parent
1368 * o child waits for parent ack on condition variable
1369 * - we wake up, locking thread list
1370 * - add child to thread list
1371 * - unlock thread list
1372 * - change our state back to THREAD_RUNNING; GC causes us to suspend
1373 * + GC finishes; all threads in thread list are resumed
1374 * - lock thread list
1375 * - set child to THREAD_VMWAIT, and signal it to start
1376 * - unlock thread list
1377 * o child resumes
1378 * o child changes state to THREAD_RUNNING
1379 *
1380 * The above shows the GC starting up during thread creation, but if
1381 * it starts anywhere after VMThread.create() is called it will
1382 * produce the same series of events.
1383 *
1384 * Once the child is in the thread list, it will be suspended and
1385 * resumed like any other thread. In the above scenario the resume-all
1386 * code will try to resume the new thread, which was never actually
1387 * suspended, and try to decrement the child's thread suspend count to -1.
1388 * We can catch this in the resume-all code.
1389 *
1390 * Bouncing back and forth between threads like this adds a small amount
1391 * of scheduler overhead to thread startup.
1392 *
1393 * One alternative to having the child wait for the parent would be
1394 * to have the child inherit the parents' suspension count. This
1395 * would work for a GC, since we can safely assume that the parent
1396 * thread didn't cause it, but we must only do so if the parent suspension
1397 * was caused by a suspend-all. If the parent was being asked to
1398 * suspend singly by the debugger, the child should not inherit the value.
1399 *
1400 * We could also have a global "new thread suspend count" that gets
1401 * picked up by new threads before changing state to THREAD_RUNNING.
1402 * This would be protected by the thread list lock and set by a
1403 * suspend-all.
1404 */
1405 dvmLockThreadList(self);
1406 assert(self->status == THREAD_RUNNING);
1407 self->status = THREAD_VMWAIT;
1408 while (newThread->status != THREAD_STARTING)
1409 pthread_cond_wait(&gDvm.threadStartCond, &gDvm.threadListLock);
1410
1411 LOG_THREAD("threadid=%d: adding to list", newThread->threadId);
1412 newThread->next = gDvm.threadList->next;
1413 if (newThread->next != NULL)
1414 newThread->next->prev = newThread;
1415 newThread->prev = gDvm.threadList;
1416 gDvm.threadList->next = newThread;
1417
1418 /* Add any existing global modes to the interpBreak control */
1419 dvmInitializeInterpBreak(newThread);
1420
1421 if (!dvmGetFieldBoolean(threadObj, gDvm.offJavaLangThread_daemon))
1422 gDvm.nonDaemonThreadCount++; // guarded by thread list lock
1423
1424 dvmUnlockThreadList();
1425
1426 /* change status back to RUNNING, self-suspending if necessary */
1427 dvmChangeStatus(self, THREAD_RUNNING);
1428
1429 /*
1430 * Tell the new thread to start.
1431 *
1432 * We must hold the thread list lock before messing with another thread.
1433 * In the general case we would also need to verify that newThread was
1434 * still in the thread list, but in our case the thread has not started
1435 * executing user code and therefore has not had a chance to exit.
1436 *
1437 * We move it to VMWAIT, and it then shifts itself to RUNNING, which
1438 * comes with a suspend-pending check.
1439 */
1440 dvmLockThreadList(self);
1441
1442 assert(newThread->status == THREAD_STARTING);
1443 newThread->status = THREAD_VMWAIT;
1444 pthread_cond_broadcast(&gDvm.threadStartCond);
1445
1446 dvmUnlockThreadList();
1447
1448 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1449 return true;
1450
1451 fail:
1452 freeThread(newThread);
1453 dvmReleaseTrackedAlloc(vmThreadObj, NULL);
1454 return false;
1455 }
1456
1457 /*
1458 * pthread entry function for threads started from interpreted code.
1459 */
interpThreadStart(void * arg)1460 static void* interpThreadStart(void* arg)
1461 {
1462 Thread* self = (Thread*) arg;
1463
1464 std::string threadName(dvmGetThreadName(self));
1465 setThreadName(threadName.c_str());
1466
1467 /*
1468 * Finish initializing the Thread struct.
1469 */
1470 dvmLockThreadList(self);
1471 prepareThread(self);
1472
1473 LOG_THREAD("threadid=%d: created from interp", self->threadId);
1474
1475 /*
1476 * Change our status and wake our parent, who will add us to the
1477 * thread list and advance our state to VMWAIT.
1478 */
1479 self->status = THREAD_STARTING;
1480 pthread_cond_broadcast(&gDvm.threadStartCond);
1481
1482 /*
1483 * Wait until the parent says we can go. Assuming there wasn't a
1484 * suspend pending, this will happen immediately. When it completes,
1485 * we're full-fledged citizens of the VM.
1486 *
1487 * We have to use THREAD_VMWAIT here rather than THREAD_RUNNING
1488 * because the pthread_cond_wait below needs to reacquire a lock that
1489 * suspend-all is also interested in. If we get unlucky, the parent could
1490 * change us to THREAD_RUNNING, then a GC could start before we get
1491 * signaled, and suspend-all will grab the thread list lock and then
1492 * wait for us to suspend. We'll be in the tail end of pthread_cond_wait
1493 * trying to get the lock.
1494 */
1495 while (self->status != THREAD_VMWAIT)
1496 pthread_cond_wait(&gDvm.threadStartCond, &gDvm.threadListLock);
1497
1498 dvmUnlockThreadList();
1499
1500 /*
1501 * Add a JNI context.
1502 */
1503 self->jniEnv = dvmCreateJNIEnv(self);
1504
1505 /*
1506 * Change our state so the GC will wait for us from now on. If a GC is
1507 * in progress this call will suspend us.
1508 */
1509 dvmChangeStatus(self, THREAD_RUNNING);
1510
1511 /*
1512 * Notify the debugger & DDM. The debugger notification may cause
1513 * us to suspend ourselves (and others). The thread state may change
1514 * to VMWAIT briefly if network packets are sent.
1515 */
1516 if (gDvm.debuggerConnected)
1517 dvmDbgPostThreadStart(self);
1518
1519 /*
1520 * Set the system thread priority according to the Thread object's
1521 * priority level. We don't usually need to do this, because both the
1522 * Thread object and system thread priorities inherit from parents. The
1523 * tricky case is when somebody creates a Thread object, calls
1524 * setPriority(), and then starts the thread. We could manage this with
1525 * a "needs priority update" flag to avoid the redundant call.
1526 */
1527 int priority = dvmGetFieldInt(self->threadObj,
1528 gDvm.offJavaLangThread_priority);
1529 dvmChangeThreadPriority(self, priority);
1530
1531 /*
1532 * Execute the "run" method.
1533 *
1534 * At this point our stack is empty, so somebody who comes looking for
1535 * stack traces right now won't have much to look at. This is normal.
1536 */
1537 Method* run = self->threadObj->clazz->vtable[gDvm.voffJavaLangThread_run];
1538 JValue unused;
1539
1540 ALOGV("threadid=%d: calling run()", self->threadId);
1541 assert(strcmp(run->name, "run") == 0);
1542 dvmCallMethod(self, run, self->threadObj, &unused);
1543 ALOGV("threadid=%d: exiting", self->threadId);
1544
1545 /*
1546 * Remove the thread from various lists, report its death, and free
1547 * its resources.
1548 */
1549 dvmDetachCurrentThread();
1550
1551 return NULL;
1552 }
1553
1554 /*
1555 * The current thread is exiting with an uncaught exception. The
1556 * Java programming language allows the application to provide a
1557 * thread-exit-uncaught-exception handler for the VM, for a specific
1558 * Thread, and for all threads in a ThreadGroup.
1559 *
1560 * Version 1.5 added the per-thread handler. We need to call
1561 * "uncaughtException" in the handler object, which is either the
1562 * ThreadGroup object or the Thread-specific handler.
1563 *
1564 * This should only be called when an exception is pending. Before
1565 * returning, the exception will be cleared.
1566 */
threadExitUncaughtException(Thread * self,Object * group)1567 static void threadExitUncaughtException(Thread* self, Object* group)
1568 {
1569 Object* exception;
1570 Object* handlerObj;
1571 Method* uncaughtHandler;
1572
1573 ALOGW("threadid=%d: thread exiting with uncaught exception (group=%p)",
1574 self->threadId, group);
1575 assert(group != NULL);
1576
1577 /*
1578 * Get a pointer to the exception, then clear out the one in the
1579 * thread. We don't want to have it set when executing interpreted code.
1580 */
1581 exception = dvmGetException(self);
1582 assert(exception != NULL);
1583 dvmAddTrackedAlloc(exception, self);
1584 dvmClearException(self);
1585
1586 /*
1587 * Get the Thread's "uncaughtHandler" object. Use it if non-NULL;
1588 * else use "group" (which is an instance of UncaughtExceptionHandler).
1589 * The ThreadGroup will handle it directly or call the default
1590 * uncaught exception handler.
1591 */
1592 handlerObj = dvmGetFieldObject(self->threadObj,
1593 gDvm.offJavaLangThread_uncaughtHandler);
1594 if (handlerObj == NULL)
1595 handlerObj = group;
1596
1597 /*
1598 * Find the "uncaughtException" method in this object. The method
1599 * was declared in the Thread.UncaughtExceptionHandler interface.
1600 */
1601 uncaughtHandler = dvmFindVirtualMethodHierByDescriptor(handlerObj->clazz,
1602 "uncaughtException", "(Ljava/lang/Thread;Ljava/lang/Throwable;)V");
1603
1604 if (uncaughtHandler != NULL) {
1605 //ALOGI("+++ calling %s.uncaughtException",
1606 // handlerObj->clazz->descriptor);
1607 JValue unused;
1608 dvmCallMethod(self, uncaughtHandler, handlerObj, &unused,
1609 self->threadObj, exception);
1610 } else {
1611 /* should be impossible, but handle it anyway */
1612 ALOGW("WARNING: no 'uncaughtException' method in class %s",
1613 handlerObj->clazz->descriptor);
1614 dvmSetException(self, exception);
1615 dvmLogExceptionStackTrace();
1616 }
1617
1618 /* if the uncaught handler threw, clear it */
1619 dvmClearException(self);
1620
1621 dvmReleaseTrackedAlloc(exception, self);
1622
1623 /* Remove this thread's suspendCount from global suspendCount sum */
1624 lockThreadSuspendCount();
1625 dvmAddToSuspendCounts(self, -self->suspendCount, 0);
1626 unlockThreadSuspendCount();
1627 }
1628
1629
1630 /*
1631 * Create an internal VM thread, for things like JDWP and finalizers.
1632 *
1633 * The easiest way to do this is create a new thread and then use the
1634 * JNI AttachCurrentThread implementation.
1635 *
1636 * This does not return until after the new thread has begun executing.
1637 */
dvmCreateInternalThread(pthread_t * pHandle,const char * name,InternalThreadStart func,void * funcArg)1638 bool dvmCreateInternalThread(pthread_t* pHandle, const char* name,
1639 InternalThreadStart func, void* funcArg)
1640 {
1641 InternalStartArgs* pArgs;
1642 Object* systemGroup;
1643 volatile Thread* newThread = NULL;
1644 volatile int createStatus = 0;
1645
1646 systemGroup = dvmGetSystemThreadGroup();
1647 if (systemGroup == NULL)
1648 return false;
1649
1650 pArgs = (InternalStartArgs*) malloc(sizeof(*pArgs));
1651 pArgs->func = func;
1652 pArgs->funcArg = funcArg;
1653 pArgs->name = strdup(name); // storage will be owned by new thread
1654 pArgs->group = systemGroup;
1655 pArgs->isDaemon = true;
1656 pArgs->pThread = &newThread;
1657 pArgs->pCreateStatus = &createStatus;
1658
1659 pthread_attr_t threadAttr;
1660 pthread_attr_init(&threadAttr);
1661
1662 int cc = pthread_create(pHandle, &threadAttr, internalThreadStart, pArgs);
1663 pthread_attr_destroy(&threadAttr);
1664 if (cc != 0) {
1665 ALOGE("internal thread creation failed: %s", strerror(cc));
1666 free(pArgs->name);
1667 free(pArgs);
1668 return false;
1669 }
1670
1671 /*
1672 * Wait for the child to start. This gives us an opportunity to make
1673 * sure that the thread started correctly, and allows our caller to
1674 * assume that the thread has started running.
1675 *
1676 * Because we aren't holding a lock across the thread creation, it's
1677 * possible that the child will already have completed its
1678 * initialization. Because the child only adjusts "createStatus" while
1679 * holding the thread list lock, the initial condition on the "while"
1680 * loop will correctly avoid the wait if this occurs.
1681 *
1682 * It's also possible that we'll have to wait for the thread to finish
1683 * being created, and as part of allocating a Thread object it might
1684 * need to initiate a GC. We switch to VMWAIT while we pause.
1685 */
1686 Thread* self = dvmThreadSelf();
1687 ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
1688 dvmLockThreadList(self);
1689 while (createStatus == 0)
1690 pthread_cond_wait(&gDvm.threadStartCond, &gDvm.threadListLock);
1691
1692 if (newThread == NULL) {
1693 ALOGW("internal thread create failed (createStatus=%d)", createStatus);
1694 assert(createStatus < 0);
1695 /* don't free pArgs -- if pthread_create succeeded, child owns it */
1696 dvmUnlockThreadList();
1697 dvmChangeStatus(self, oldStatus);
1698 return false;
1699 }
1700
1701 /* thread could be in any state now (except early init states) */
1702 //assert(newThread->status == THREAD_RUNNING);
1703
1704 dvmUnlockThreadList();
1705 dvmChangeStatus(self, oldStatus);
1706
1707 return true;
1708 }
1709
1710 /*
1711 * pthread entry function for internally-created threads.
1712 *
1713 * We are expected to free "arg" and its contents. If we're a daemon
1714 * thread, and we get cancelled abruptly when the VM shuts down, the
1715 * storage won't be freed. If this becomes a concern we can make a copy
1716 * on the stack.
1717 */
internalThreadStart(void * arg)1718 static void* internalThreadStart(void* arg)
1719 {
1720 InternalStartArgs* pArgs = (InternalStartArgs*) arg;
1721 JavaVMAttachArgs jniArgs;
1722
1723 jniArgs.version = JNI_VERSION_1_2;
1724 jniArgs.name = pArgs->name;
1725 jniArgs.group = reinterpret_cast<jobject>(pArgs->group);
1726
1727 setThreadName(pArgs->name);
1728
1729 /* use local jniArgs as stack top */
1730 if (dvmAttachCurrentThread(&jniArgs, pArgs->isDaemon)) {
1731 /*
1732 * Tell the parent of our success.
1733 *
1734 * threadListLock is the mutex for threadStartCond.
1735 */
1736 dvmLockThreadList(dvmThreadSelf());
1737 *pArgs->pCreateStatus = 1;
1738 *pArgs->pThread = dvmThreadSelf();
1739 pthread_cond_broadcast(&gDvm.threadStartCond);
1740 dvmUnlockThreadList();
1741
1742 LOG_THREAD("threadid=%d: internal '%s'",
1743 dvmThreadSelf()->threadId, pArgs->name);
1744
1745 /* execute */
1746 (*pArgs->func)(pArgs->funcArg);
1747
1748 /* detach ourselves */
1749 dvmDetachCurrentThread();
1750 } else {
1751 /*
1752 * Tell the parent of our failure. We don't have a Thread struct,
1753 * so we can't be suspended, so we don't need to enter a critical
1754 * section.
1755 */
1756 dvmLockThreadList(dvmThreadSelf());
1757 *pArgs->pCreateStatus = -1;
1758 assert(*pArgs->pThread == NULL);
1759 pthread_cond_broadcast(&gDvm.threadStartCond);
1760 dvmUnlockThreadList();
1761
1762 assert(*pArgs->pThread == NULL);
1763 }
1764
1765 free(pArgs->name);
1766 free(pArgs);
1767 return NULL;
1768 }
1769
1770 /*
1771 * Attach the current thread to the VM.
1772 *
1773 * Used for internally-created threads and JNI's AttachCurrentThread.
1774 */
dvmAttachCurrentThread(const JavaVMAttachArgs * pArgs,bool isDaemon)1775 bool dvmAttachCurrentThread(const JavaVMAttachArgs* pArgs, bool isDaemon)
1776 {
1777 Thread* self = NULL;
1778 Object* threadObj = NULL;
1779 Object* vmThreadObj = NULL;
1780 StringObject* threadNameStr = NULL;
1781 Method* init;
1782 bool ok, ret;
1783
1784 /* allocate thread struct, and establish a basic sense of self */
1785 self = allocThread(gDvm.stackSize);
1786 if (self == NULL)
1787 goto fail;
1788 setThreadSelf(self);
1789
1790 /*
1791 * Finish our thread prep. We need to do this before adding ourselves
1792 * to the thread list or invoking any interpreted code. prepareThread()
1793 * requires that we hold the thread list lock.
1794 */
1795 dvmLockThreadList(self);
1796 ok = prepareThread(self);
1797 dvmUnlockThreadList();
1798 if (!ok)
1799 goto fail;
1800
1801 self->jniEnv = dvmCreateJNIEnv(self);
1802 if (self->jniEnv == NULL)
1803 goto fail;
1804
1805 /*
1806 * Create a "fake" JNI frame at the top of the main thread interp stack.
1807 * It isn't really necessary for the internal threads, but it gives
1808 * the debugger something to show. It is essential for the JNI-attached
1809 * threads.
1810 */
1811 if (!createFakeRunFrame(self))
1812 goto fail;
1813
1814 /*
1815 * The native side of the thread is ready; add it to the list. Once
1816 * it's on the list the thread is visible to the JDWP code and the GC.
1817 */
1818 LOG_THREAD("threadid=%d: adding to list (attached)", self->threadId);
1819
1820 dvmLockThreadList(self);
1821
1822 self->next = gDvm.threadList->next;
1823 if (self->next != NULL)
1824 self->next->prev = self;
1825 self->prev = gDvm.threadList;
1826 gDvm.threadList->next = self;
1827 if (!isDaemon)
1828 gDvm.nonDaemonThreadCount++;
1829
1830 dvmUnlockThreadList();
1831
1832 /*
1833 * Switch state from initializing to running.
1834 *
1835 * It's possible that a GC began right before we added ourselves
1836 * to the thread list, and is still going. That means our thread
1837 * suspend count won't reflect the fact that we should be suspended.
1838 * To deal with this, we transition to VMWAIT, pulse the heap lock,
1839 * and then advance to RUNNING. That will ensure that we stall until
1840 * the GC completes.
1841 *
1842 * Once we're in RUNNING, we're like any other thread in the VM (except
1843 * for the lack of an initialized threadObj). We're then free to
1844 * allocate and initialize objects.
1845 */
1846 assert(self->status == THREAD_INITIALIZING);
1847 dvmChangeStatus(self, THREAD_VMWAIT);
1848 dvmLockMutex(&gDvm.gcHeapLock);
1849 dvmUnlockMutex(&gDvm.gcHeapLock);
1850 dvmChangeStatus(self, THREAD_RUNNING);
1851
1852 /*
1853 * Create Thread and VMThread objects.
1854 */
1855 threadObj = dvmAllocObject(gDvm.classJavaLangThread, ALLOC_DEFAULT);
1856 vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
1857 if (threadObj == NULL || vmThreadObj == NULL)
1858 goto fail_unlink;
1859
1860 /*
1861 * This makes threadObj visible to the GC. We still have it in the
1862 * tracked allocation table, so it can't move around on us.
1863 */
1864 self->threadObj = threadObj;
1865 dvmSetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData, (u4)self);
1866
1867 /*
1868 * Create a string for the thread name.
1869 */
1870 if (pArgs->name != NULL) {
1871 threadNameStr = dvmCreateStringFromCstr(pArgs->name);
1872 if (threadNameStr == NULL) {
1873 assert(dvmCheckException(dvmThreadSelf()));
1874 goto fail_unlink;
1875 }
1876 }
1877
1878 init = dvmFindDirectMethodByDescriptor(gDvm.classJavaLangThread, "<init>",
1879 "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
1880 if (init == NULL) {
1881 assert(dvmCheckException(self));
1882 goto fail_unlink;
1883 }
1884
1885 /*
1886 * Now we're ready to run some interpreted code.
1887 *
1888 * We need to construct the Thread object and set the VMThread field.
1889 * Setting VMThread tells interpreted code that we're alive.
1890 *
1891 * Call the (group, name, priority, daemon) constructor on the Thread.
1892 * This sets the thread's name and adds it to the specified group, and
1893 * provides values for priority and daemon (which are normally inherited
1894 * from the current thread).
1895 */
1896 JValue unused;
1897 dvmCallMethod(self, init, threadObj, &unused, (Object*)pArgs->group,
1898 threadNameStr, os_getThreadPriorityFromSystem(), isDaemon);
1899 if (dvmCheckException(self)) {
1900 ALOGE("exception thrown while constructing attached thread object");
1901 goto fail_unlink;
1902 }
1903
1904 /*
1905 * Set the VMThread field, which tells interpreted code that we're alive.
1906 *
1907 * The risk of a thread start collision here is very low; somebody
1908 * would have to be deliberately polling the ThreadGroup list and
1909 * trying to start threads against anything it sees, which would
1910 * generally cause problems for all thread creation. However, for
1911 * correctness we test "vmThread" before setting it.
1912 *
1913 * TODO: this still has a race, it's just smaller. Not sure this is
1914 * worth putting effort into fixing. Need to hold a lock while
1915 * fiddling with the field, or maybe initialize the Thread object in a
1916 * way that ensures another thread can't call start() on it.
1917 */
1918 if (dvmGetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread) != NULL) {
1919 ALOGW("WOW: thread start hijack");
1920 dvmThrowIllegalThreadStateException(
1921 "thread has already been started");
1922 /* We don't want to free anything associated with the thread
1923 * because someone is obviously interested in it. Just let
1924 * it go and hope it will clean itself up when its finished.
1925 * This case should never happen anyway.
1926 *
1927 * Since we're letting it live, we need to finish setting it up.
1928 * We just have to let the caller know that the intended operation
1929 * has failed.
1930 *
1931 * [ This seems strange -- stepping on the vmThread object that's
1932 * already present seems like a bad idea. TODO: figure this out. ]
1933 */
1934 ret = false;
1935 } else {
1936 ret = true;
1937 }
1938 dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread, vmThreadObj);
1939
1940 /* we can now safely un-pin these */
1941 dvmReleaseTrackedAlloc(threadObj, self);
1942 dvmReleaseTrackedAlloc(vmThreadObj, self);
1943 dvmReleaseTrackedAlloc((Object*)threadNameStr, self);
1944
1945 LOG_THREAD("threadid=%d: attached from native, name=%s",
1946 self->threadId, pArgs->name);
1947
1948 /* tell the debugger & DDM */
1949 if (gDvm.debuggerConnected)
1950 dvmDbgPostThreadStart(self);
1951
1952 return ret;
1953
1954 fail_unlink:
1955 dvmLockThreadList(self);
1956 unlinkThread(self);
1957 if (!isDaemon)
1958 gDvm.nonDaemonThreadCount--;
1959 dvmUnlockThreadList();
1960 /* fall through to "fail" */
1961 fail:
1962 dvmReleaseTrackedAlloc(threadObj, self);
1963 dvmReleaseTrackedAlloc(vmThreadObj, self);
1964 dvmReleaseTrackedAlloc((Object*)threadNameStr, self);
1965 if (self != NULL) {
1966 if (self->jniEnv != NULL) {
1967 dvmDestroyJNIEnv(self->jniEnv);
1968 self->jniEnv = NULL;
1969 }
1970 freeThread(self);
1971 }
1972 setThreadSelf(NULL);
1973 return false;
1974 }
1975
1976 /*
1977 * Detach the thread from the various data structures, notify other threads
1978 * that are waiting to "join" it, and free up all heap-allocated storage.
1979 *
1980 * Used for all threads.
1981 *
1982 * When we get here the interpreted stack should be empty. The JNI 1.6 spec
1983 * requires us to enforce this for the DetachCurrentThread call, probably
1984 * because it also says that DetachCurrentThread causes all monitors
1985 * associated with the thread to be released. (Because the stack is empty,
1986 * we only have to worry about explicit JNI calls to MonitorEnter.)
1987 *
1988 * THOUGHT:
1989 * We might want to avoid freeing our internal Thread structure until the
1990 * associated Thread/VMThread objects get GCed. Our Thread is impossible to
1991 * get to once the thread shuts down, but there is a small possibility of
1992 * an operation starting in another thread before this thread halts, and
1993 * finishing much later (perhaps the thread got stalled by a weird OS bug).
1994 * We don't want something like Thread.isInterrupted() crawling through
1995 * freed storage. Can do with a Thread finalizer, or by creating a
1996 * dedicated ThreadObject class for java/lang/Thread and moving all of our
1997 * state into that.
1998 */
dvmDetachCurrentThread()1999 void dvmDetachCurrentThread()
2000 {
2001 Thread* self = dvmThreadSelf();
2002 Object* vmThread;
2003 Object* group;
2004
2005 /*
2006 * Make sure we're not detaching a thread that's still running. (This
2007 * could happen with an explicit JNI detach call.)
2008 *
2009 * A thread created by interpreted code will finish with a depth of
2010 * zero, while a JNI-attached thread will have the synthetic "stack
2011 * starter" native method at the top.
2012 */
2013 int curDepth = dvmComputeExactFrameDepth(self->interpSave.curFrame);
2014 if (curDepth != 0) {
2015 bool topIsNative = false;
2016
2017 if (curDepth == 1) {
2018 /* not expecting a lingering break frame; just look at curFrame */
2019 assert(!dvmIsBreakFrame((u4*)self->interpSave.curFrame));
2020 StackSaveArea* ssa = SAVEAREA_FROM_FP(self->interpSave.curFrame);
2021 if (dvmIsNativeMethod(ssa->method))
2022 topIsNative = true;
2023 }
2024
2025 if (!topIsNative) {
2026 ALOGE("ERROR: detaching thread with interp frames (count=%d)",
2027 curDepth);
2028 dvmDumpThread(self, false);
2029 dvmAbort();
2030 }
2031 }
2032
2033 group = dvmGetFieldObject(self->threadObj, gDvm.offJavaLangThread_group);
2034 LOG_THREAD("threadid=%d: detach (group=%p)", self->threadId, group);
2035
2036 /*
2037 * Release any held monitors. Since there are no interpreted stack
2038 * frames, the only thing left are the monitors held by JNI MonitorEnter
2039 * calls.
2040 */
2041 dvmReleaseJniMonitors(self);
2042
2043 /*
2044 * Do some thread-exit uncaught exception processing if necessary.
2045 */
2046 if (dvmCheckException(self))
2047 threadExitUncaughtException(self, group);
2048
2049 /*
2050 * Remove the thread from the thread group.
2051 */
2052 if (group != NULL) {
2053 Method* removeThread =
2054 group->clazz->vtable[gDvm.voffJavaLangThreadGroup_removeThread];
2055 JValue unused;
2056 dvmCallMethod(self, removeThread, group, &unused, self->threadObj);
2057 }
2058
2059 /*
2060 * Clear the vmThread reference in the Thread object. Interpreted code
2061 * will now see that this Thread is not running. As this may be the
2062 * only reference to the VMThread object that the VM knows about, we
2063 * have to create an internal reference to it first.
2064 */
2065 vmThread = dvmGetFieldObject(self->threadObj,
2066 gDvm.offJavaLangThread_vmThread);
2067 dvmAddTrackedAlloc(vmThread, self);
2068 dvmSetFieldObject(self->threadObj, gDvm.offJavaLangThread_vmThread, NULL);
2069
2070 /* clear out our struct Thread pointer, since it's going away */
2071 dvmSetFieldObject(vmThread, gDvm.offJavaLangVMThread_vmData, NULL);
2072
2073 /*
2074 * Tell the debugger & DDM. This may cause the current thread or all
2075 * threads to suspend.
2076 *
2077 * The JDWP spec is somewhat vague about when this happens, other than
2078 * that it's issued by the dying thread, which may still appear in
2079 * an "all threads" listing.
2080 */
2081 if (gDvm.debuggerConnected)
2082 dvmDbgPostThreadDeath(self);
2083
2084 /*
2085 * Thread.join() is implemented as an Object.wait() on the VMThread
2086 * object. Signal anyone who is waiting.
2087 */
2088 dvmLockObject(self, vmThread);
2089 dvmObjectNotifyAll(self, vmThread);
2090 dvmUnlockObject(self, vmThread);
2091
2092 dvmReleaseTrackedAlloc(vmThread, self);
2093 vmThread = NULL;
2094
2095 /*
2096 * We're done manipulating objects, so it's okay if the GC runs in
2097 * parallel with us from here out. It's important to do this if
2098 * profiling is enabled, since we can wait indefinitely.
2099 */
2100 volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
2101 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
2102 android_atomic_release_store(THREAD_VMWAIT, addr);
2103
2104 /*
2105 * If we're doing method trace profiling, we don't want threads to exit,
2106 * because if they do we'll end up reusing thread IDs. This complicates
2107 * analysis and makes it impossible to have reasonable output in the
2108 * "threads" section of the "key" file.
2109 *
2110 * We need to do this after Thread.join() completes, or other threads
2111 * could get wedged. Since self->threadObj is still valid, the Thread
2112 * object will not get GCed even though we're no longer in the ThreadGroup
2113 * list (which is important since the profiling thread needs to get
2114 * the thread's name).
2115 */
2116 MethodTraceState* traceState = &gDvm.methodTrace;
2117
2118 dvmLockMutex(&traceState->startStopLock);
2119 if (traceState->traceEnabled) {
2120 ALOGI("threadid=%d: waiting for method trace to finish",
2121 self->threadId);
2122 while (traceState->traceEnabled) {
2123 dvmWaitCond(&traceState->threadExitCond,
2124 &traceState->startStopLock);
2125 }
2126 }
2127 dvmUnlockMutex(&traceState->startStopLock);
2128
2129 dvmLockThreadList(self);
2130
2131 /*
2132 * Lose the JNI context.
2133 */
2134 dvmDestroyJNIEnv(self->jniEnv);
2135 self->jniEnv = NULL;
2136
2137 self->status = THREAD_ZOMBIE;
2138
2139 /*
2140 * Remove ourselves from the internal thread list.
2141 */
2142 unlinkThread(self);
2143
2144 /*
2145 * If we're the last one standing, signal anybody waiting in
2146 * DestroyJavaVM that it's okay to exit.
2147 */
2148 if (!dvmGetFieldBoolean(self->threadObj, gDvm.offJavaLangThread_daemon)) {
2149 gDvm.nonDaemonThreadCount--; // guarded by thread list lock
2150
2151 if (gDvm.nonDaemonThreadCount == 0) {
2152 ALOGV("threadid=%d: last non-daemon thread", self->threadId);
2153 //dvmDumpAllThreads(false);
2154 // cond var guarded by threadListLock, which we already hold
2155 int cc = pthread_cond_signal(&gDvm.vmExitCond);
2156 if (cc != 0) {
2157 ALOGE("pthread_cond_signal(&gDvm.vmExitCond) failed: %s", strerror(cc));
2158 dvmAbort();
2159 }
2160 }
2161 }
2162
2163 ALOGV("threadid=%d: bye!", self->threadId);
2164 releaseThreadId(self);
2165 dvmUnlockThreadList();
2166
2167 setThreadSelf(NULL);
2168
2169 freeThread(self);
2170 }
2171
2172
2173 /*
2174 * Suspend a single thread. Do not use to suspend yourself.
2175 *
2176 * This is used primarily for debugger/DDMS activity. Does not return
2177 * until the thread has suspended or is in a "safe" state (e.g. executing
2178 * native code outside the VM).
2179 *
2180 * The thread list lock should be held before calling here -- it's not
2181 * entirely safe to hang on to a Thread* from another thread otherwise.
2182 * (We'd need to grab it here anyway to avoid clashing with a suspend-all.)
2183 */
dvmSuspendThread(Thread * thread)2184 void dvmSuspendThread(Thread* thread)
2185 {
2186 assert(thread != NULL);
2187 assert(thread != dvmThreadSelf());
2188 //assert(thread->handle != dvmJdwpGetDebugThread(gDvm.jdwpState));
2189
2190 lockThreadSuspendCount();
2191 dvmAddToSuspendCounts(thread, 1, 1);
2192
2193 LOG_THREAD("threadid=%d: suspend++, now=%d",
2194 thread->threadId, thread->suspendCount);
2195 unlockThreadSuspendCount();
2196
2197 waitForThreadSuspend(dvmThreadSelf(), thread);
2198 }
2199
2200 /*
2201 * Reduce the suspend count of a thread. If it hits zero, tell it to
2202 * resume.
2203 *
2204 * Used primarily for debugger/DDMS activity. The thread in question
2205 * might have been suspended singly or as part of a suspend-all operation.
2206 *
2207 * The thread list lock should be held before calling here -- it's not
2208 * entirely safe to hang on to a Thread* from another thread otherwise.
2209 * (We'd need to grab it here anyway to avoid clashing with a suspend-all.)
2210 */
dvmResumeThread(Thread * thread)2211 void dvmResumeThread(Thread* thread)
2212 {
2213 assert(thread != NULL);
2214 assert(thread != dvmThreadSelf());
2215 //assert(thread->handle != dvmJdwpGetDebugThread(gDvm.jdwpState));
2216
2217 lockThreadSuspendCount();
2218 if (thread->suspendCount > 0) {
2219 dvmAddToSuspendCounts(thread, -1, -1);
2220 } else {
2221 LOG_THREAD("threadid=%d: suspendCount already zero",
2222 thread->threadId);
2223 }
2224
2225 LOG_THREAD("threadid=%d: suspend--, now=%d",
2226 thread->threadId, thread->suspendCount);
2227
2228 if (thread->suspendCount == 0) {
2229 dvmBroadcastCond(&gDvm.threadSuspendCountCond);
2230 }
2231
2232 unlockThreadSuspendCount();
2233 }
2234
2235 /*
2236 * Suspend yourself, as a result of debugger activity.
2237 */
dvmSuspendSelf(bool jdwpActivity)2238 void dvmSuspendSelf(bool jdwpActivity)
2239 {
2240 Thread* self = dvmThreadSelf();
2241
2242 /* debugger thread must not suspend itself due to debugger activity! */
2243 assert(gDvm.jdwpState != NULL);
2244 if (self->handle == dvmJdwpGetDebugThread(gDvm.jdwpState)) {
2245 assert(false);
2246 return;
2247 }
2248
2249 /*
2250 * Collisions with other suspends aren't really interesting. We want
2251 * to ensure that we're the only one fiddling with the suspend count
2252 * though.
2253 */
2254 lockThreadSuspendCount();
2255 dvmAddToSuspendCounts(self, 1, 1);
2256
2257 /*
2258 * Suspend ourselves.
2259 */
2260 assert(self->suspendCount > 0);
2261 self->status = THREAD_SUSPENDED;
2262 LOG_THREAD("threadid=%d: self-suspending (dbg)", self->threadId);
2263
2264 /*
2265 * Tell JDWP that we've completed suspension. The JDWP thread can't
2266 * tell us to resume before we're fully asleep because we hold the
2267 * suspend count lock.
2268 *
2269 * If we got here via waitForDebugger(), don't do this part.
2270 */
2271 if (jdwpActivity) {
2272 //ALOGI("threadid=%d: clearing wait-for-event (my handle=%08x)",
2273 // self->threadId, (int) self->handle);
2274 dvmJdwpClearWaitForEventThread(gDvm.jdwpState);
2275 }
2276
2277 while (self->suspendCount != 0) {
2278 dvmWaitCond(&gDvm.threadSuspendCountCond,
2279 &gDvm.threadSuspendCountLock);
2280 if (self->suspendCount != 0) {
2281 /*
2282 * The condition was signaled but we're still suspended. This
2283 * can happen if the debugger lets go while a SIGQUIT thread
2284 * dump event is pending (assuming SignalCatcher was resumed for
2285 * just long enough to try to grab the thread-suspend lock).
2286 */
2287 ALOGD("threadid=%d: still suspended after undo (sc=%d dc=%d)",
2288 self->threadId, self->suspendCount, self->dbgSuspendCount);
2289 }
2290 }
2291 assert(self->suspendCount == 0 && self->dbgSuspendCount == 0);
2292 self->status = THREAD_RUNNING;
2293 LOG_THREAD("threadid=%d: self-reviving (dbg), status=%d",
2294 self->threadId, self->status);
2295
2296 unlockThreadSuspendCount();
2297 }
2298
2299 /*
2300 * Dump the state of the current thread and that of another thread that
2301 * we think is wedged.
2302 */
dumpWedgedThread(Thread * thread)2303 static void dumpWedgedThread(Thread* thread)
2304 {
2305 dvmDumpThread(dvmThreadSelf(), false);
2306 dvmPrintNativeBackTrace();
2307
2308 // dumping a running thread is risky, but could be useful
2309 dvmDumpThread(thread, true);
2310
2311 // stop now and get a core dump
2312 //abort();
2313 }
2314
2315 /*
2316 * If the thread is running at below-normal priority, temporarily elevate
2317 * it to "normal".
2318 *
2319 * Returns zero if no changes were made. Otherwise, returns bit flags
2320 * indicating what was changed, storing the previous values in the
2321 * provided locations.
2322 */
dvmRaiseThreadPriorityIfNeeded(Thread * thread,int * pSavedThreadPrio,SchedPolicy * pSavedThreadPolicy)2323 int dvmRaiseThreadPriorityIfNeeded(Thread* thread, int* pSavedThreadPrio,
2324 SchedPolicy* pSavedThreadPolicy)
2325 {
2326 errno = 0;
2327 *pSavedThreadPrio = getpriority(PRIO_PROCESS, thread->systemTid);
2328 if (errno != 0) {
2329 ALOGW("Unable to get priority for threadid=%d sysTid=%d",
2330 thread->threadId, thread->systemTid);
2331 return 0;
2332 }
2333 if (get_sched_policy(thread->systemTid, pSavedThreadPolicy) != 0) {
2334 ALOGW("Unable to get policy for threadid=%d sysTid=%d",
2335 thread->threadId, thread->systemTid);
2336 return 0;
2337 }
2338
2339 int changeFlags = 0;
2340
2341 /*
2342 * Change the priority if we're in the background group.
2343 */
2344 if (*pSavedThreadPolicy == SP_BACKGROUND) {
2345 if (set_sched_policy(thread->systemTid, SP_FOREGROUND) != 0) {
2346 ALOGW("Couldn't set fg policy on tid %d", thread->systemTid);
2347 } else {
2348 changeFlags |= kChangedPolicy;
2349 ALOGD("Temporarily moving tid %d to fg (was %d)",
2350 thread->systemTid, *pSavedThreadPolicy);
2351 }
2352 }
2353
2354 /*
2355 * getpriority() returns the "nice" value, so larger numbers indicate
2356 * lower priority, with 0 being normal.
2357 */
2358 if (*pSavedThreadPrio > 0) {
2359 const int kHigher = 0;
2360 if (setpriority(PRIO_PROCESS, thread->systemTid, kHigher) != 0) {
2361 ALOGW("Couldn't raise priority on tid %d to %d",
2362 thread->systemTid, kHigher);
2363 } else {
2364 changeFlags |= kChangedPriority;
2365 ALOGD("Temporarily raised priority on tid %d (%d -> %d)",
2366 thread->systemTid, *pSavedThreadPrio, kHigher);
2367 }
2368 }
2369
2370 return changeFlags;
2371 }
2372
2373 /*
2374 * Reset the priority values for the thread in question.
2375 */
dvmResetThreadPriority(Thread * thread,int changeFlags,int savedThreadPrio,SchedPolicy savedThreadPolicy)2376 void dvmResetThreadPriority(Thread* thread, int changeFlags,
2377 int savedThreadPrio, SchedPolicy savedThreadPolicy)
2378 {
2379 if ((changeFlags & kChangedPolicy) != 0) {
2380 if (set_sched_policy(thread->systemTid, savedThreadPolicy) != 0) {
2381 ALOGW("NOTE: couldn't reset tid %d to (%d)",
2382 thread->systemTid, savedThreadPolicy);
2383 } else {
2384 ALOGD("Restored policy of %d to %d",
2385 thread->systemTid, savedThreadPolicy);
2386 }
2387 }
2388
2389 if ((changeFlags & kChangedPriority) != 0) {
2390 if (setpriority(PRIO_PROCESS, thread->systemTid, savedThreadPrio) != 0)
2391 {
2392 ALOGW("NOTE: couldn't reset priority on thread %d to %d",
2393 thread->systemTid, savedThreadPrio);
2394 } else {
2395 ALOGD("Restored priority on %d to %d",
2396 thread->systemTid, savedThreadPrio);
2397 }
2398 }
2399 }
2400
2401 /*
2402 * Wait for another thread to see the pending suspension and stop running.
2403 * It can either suspend itself or go into a non-running state such as
2404 * VMWAIT or NATIVE in which it cannot interact with the GC.
2405 *
2406 * If we're running at a higher priority, sched_yield() may not do anything,
2407 * so we need to sleep for "long enough" to guarantee that the other
2408 * thread has a chance to finish what it's doing. Sleeping for too short
2409 * a period (e.g. less than the resolution of the sleep clock) might cause
2410 * the scheduler to return immediately, so we want to start with a
2411 * "reasonable" value and expand.
2412 *
2413 * This does not return until the other thread has stopped running.
2414 * Eventually we time out and the VM aborts.
2415 *
2416 * This does not try to detect the situation where two threads are
2417 * waiting for each other to suspend. In normal use this is part of a
2418 * suspend-all, which implies that the suspend-all lock is held, or as
2419 * part of a debugger action in which the JDWP thread is always the one
2420 * doing the suspending. (We may need to re-evaluate this now that
2421 * getThreadStackTrace is implemented as suspend-snapshot-resume.)
2422 *
2423 * TODO: track basic stats about time required to suspend VM.
2424 */
2425 #define FIRST_SLEEP (250*1000) /* 0.25s */
2426 #define MORE_SLEEP (750*1000) /* 0.75s */
waitForThreadSuspend(Thread * self,Thread * thread)2427 static void waitForThreadSuspend(Thread* self, Thread* thread)
2428 {
2429 const int kMaxRetries = 10;
2430 int spinSleepTime = FIRST_SLEEP;
2431 bool complained = false;
2432 int priChangeFlags = 0;
2433 int savedThreadPrio = -500;
2434 SchedPolicy savedThreadPolicy = SP_FOREGROUND;
2435
2436 int sleepIter = 0;
2437 int retryCount = 0;
2438 u8 startWhen = 0; // init req'd to placate gcc
2439 u8 firstStartWhen = 0;
2440
2441 while (thread->status == THREAD_RUNNING) {
2442 if (sleepIter == 0) { // get current time on first iteration
2443 startWhen = dvmGetRelativeTimeUsec();
2444 if (firstStartWhen == 0) // first iteration of first attempt
2445 firstStartWhen = startWhen;
2446
2447 /*
2448 * After waiting for a bit, check to see if the target thread is
2449 * running at a reduced priority. If so, bump it up temporarily
2450 * to give it more CPU time.
2451 */
2452 if (retryCount == 2) {
2453 assert(thread->systemTid != 0);
2454 priChangeFlags = dvmRaiseThreadPriorityIfNeeded(thread,
2455 &savedThreadPrio, &savedThreadPolicy);
2456 }
2457 }
2458
2459 #if defined (WITH_JIT)
2460 /*
2461 * If we're still waiting after the first timeout, unchain all
2462 * translations iff:
2463 * 1) There are new chains formed since the last unchain
2464 * 2) The top VM frame of the running thread is running JIT'ed code
2465 */
2466 if (gDvmJit.pJitEntryTable && retryCount > 0 &&
2467 gDvmJit.hasNewChain && thread->inJitCodeCache) {
2468 ALOGD("JIT unchain all for threadid=%d", thread->threadId);
2469 dvmJitUnchainAll();
2470 }
2471 #endif
2472
2473 /*
2474 * Sleep briefly. The iterative sleep call returns false if we've
2475 * exceeded the total time limit for this round of sleeping.
2476 */
2477 if (!dvmIterativeSleep(sleepIter++, spinSleepTime, startWhen)) {
2478 if (spinSleepTime != FIRST_SLEEP) {
2479 ALOGW("threadid=%d: spin on suspend #%d threadid=%d (pcf=%d)",
2480 self->threadId, retryCount,
2481 thread->threadId, priChangeFlags);
2482 if (retryCount > 1) {
2483 /* stack trace logging is slow; skip on first iter */
2484 dumpWedgedThread(thread);
2485 }
2486 complained = true;
2487 }
2488
2489 // keep going; could be slow due to valgrind
2490 sleepIter = 0;
2491 spinSleepTime = MORE_SLEEP;
2492
2493 if (retryCount++ == kMaxRetries) {
2494 ALOGE("Fatal spin-on-suspend, dumping threads");
2495 dvmDumpAllThreads(false);
2496
2497 /* log this after -- long traces will scroll off log */
2498 ALOGE("threadid=%d: stuck on threadid=%d, giving up",
2499 self->threadId, thread->threadId);
2500
2501 /* try to get a debuggerd dump from the spinning thread */
2502 dvmNukeThread(thread);
2503 /* abort the VM */
2504 dvmAbort();
2505 }
2506 }
2507 }
2508
2509 if (complained) {
2510 ALOGW("threadid=%d: spin on suspend resolved in %lld msec",
2511 self->threadId,
2512 (dvmGetRelativeTimeUsec() - firstStartWhen) / 1000);
2513 //dvmDumpThread(thread, false); /* suspended, so dump is safe */
2514 }
2515 if (priChangeFlags != 0) {
2516 dvmResetThreadPriority(thread, priChangeFlags, savedThreadPrio,
2517 savedThreadPolicy);
2518 }
2519 }
2520
2521 /*
2522 * Suspend all threads except the current one. This is used by the GC,
2523 * the debugger, and by any thread that hits a "suspend all threads"
2524 * debugger event (e.g. breakpoint or exception).
2525 *
2526 * If thread N hits a "suspend all threads" breakpoint, we don't want it
2527 * to suspend the JDWP thread. For the GC, we do, because the debugger can
2528 * create objects and even execute arbitrary code. The "why" argument
2529 * allows the caller to say why the suspension is taking place.
2530 *
2531 * This can be called when a global suspend has already happened, due to
2532 * various debugger gymnastics, so keeping an "everybody is suspended" flag
2533 * doesn't work.
2534 *
2535 * DO NOT grab any locks before calling here. We grab & release the thread
2536 * lock and suspend lock here (and we're not using recursive threads), and
2537 * we might have to self-suspend if somebody else beats us here.
2538 *
2539 * We know the current thread is in the thread list, because we attach the
2540 * thread before doing anything that could cause VM suspension (like object
2541 * allocation).
2542 */
dvmSuspendAllThreads(SuspendCause why)2543 void dvmSuspendAllThreads(SuspendCause why)
2544 {
2545 Thread* self = dvmThreadSelf();
2546 Thread* thread;
2547
2548 assert(why != 0);
2549
2550 /*
2551 * Start by grabbing the thread suspend lock. If we can't get it, most
2552 * likely somebody else is in the process of performing a suspend or
2553 * resume, so lockThreadSuspend() will cause us to self-suspend.
2554 *
2555 * We keep the lock until all other threads are suspended.
2556 */
2557 lockThreadSuspend("susp-all", why);
2558
2559 LOG_THREAD("threadid=%d: SuspendAll starting", self->threadId);
2560
2561 /*
2562 * This is possible if the current thread was in VMWAIT mode when a
2563 * suspend-all happened, and then decided to do its own suspend-all.
2564 * This can happen when a couple of threads have simultaneous events
2565 * of interest to the debugger.
2566 */
2567 //assert(self->suspendCount == 0);
2568
2569 /*
2570 * Increment everybody's suspend count (except our own).
2571 */
2572 dvmLockThreadList(self);
2573
2574 lockThreadSuspendCount();
2575 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2576 if (thread == self)
2577 continue;
2578
2579 /* debugger events don't suspend JDWP thread */
2580 if ((why == SUSPEND_FOR_DEBUG || why == SUSPEND_FOR_DEBUG_EVENT) &&
2581 thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState))
2582 continue;
2583
2584 dvmAddToSuspendCounts(thread, 1,
2585 (why == SUSPEND_FOR_DEBUG ||
2586 why == SUSPEND_FOR_DEBUG_EVENT)
2587 ? 1 : 0);
2588 }
2589 unlockThreadSuspendCount();
2590
2591 /*
2592 * Wait for everybody in THREAD_RUNNING state to stop. Other states
2593 * indicate the code is either running natively or sleeping quietly.
2594 * Any attempt to transition back to THREAD_RUNNING will cause a check
2595 * for suspension, so it should be impossible for anything to execute
2596 * interpreted code or modify objects (assuming native code plays nicely).
2597 *
2598 * It's also okay if the thread transitions to a non-RUNNING state.
2599 *
2600 * Note we released the threadSuspendCountLock before getting here,
2601 * so if another thread is fiddling with its suspend count (perhaps
2602 * self-suspending for the debugger) it won't block while we're waiting
2603 * in here.
2604 */
2605 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2606 if (thread == self)
2607 continue;
2608
2609 /* debugger events don't suspend JDWP thread */
2610 if ((why == SUSPEND_FOR_DEBUG || why == SUSPEND_FOR_DEBUG_EVENT) &&
2611 thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState))
2612 continue;
2613
2614 /* wait for the other thread to see the pending suspend */
2615 waitForThreadSuspend(self, thread);
2616
2617 LOG_THREAD("threadid=%d: threadid=%d status=%d sc=%d dc=%d",
2618 self->threadId, thread->threadId, thread->status,
2619 thread->suspendCount, thread->dbgSuspendCount);
2620 }
2621
2622 dvmUnlockThreadList();
2623 unlockThreadSuspend();
2624
2625 LOG_THREAD("threadid=%d: SuspendAll complete", self->threadId);
2626 }
2627
2628 /*
2629 * Resume all threads that are currently suspended.
2630 *
2631 * The "why" must match with the previous suspend.
2632 */
dvmResumeAllThreads(SuspendCause why)2633 void dvmResumeAllThreads(SuspendCause why)
2634 {
2635 Thread* self = dvmThreadSelf();
2636 Thread* thread;
2637
2638 lockThreadSuspend("res-all", why); /* one suspend/resume at a time */
2639 LOG_THREAD("threadid=%d: ResumeAll starting", self->threadId);
2640
2641 /*
2642 * Decrement the suspend counts for all threads. No need for atomic
2643 * writes, since nobody should be moving until we decrement the count.
2644 * We do need to hold the thread list because of JNI attaches.
2645 */
2646 dvmLockThreadList(self);
2647 lockThreadSuspendCount();
2648 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2649 if (thread == self)
2650 continue;
2651
2652 /* debugger events don't suspend JDWP thread */
2653 if ((why == SUSPEND_FOR_DEBUG || why == SUSPEND_FOR_DEBUG_EVENT) &&
2654 thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState))
2655 {
2656 continue;
2657 }
2658
2659 if (thread->suspendCount > 0) {
2660 dvmAddToSuspendCounts(thread, -1,
2661 (why == SUSPEND_FOR_DEBUG ||
2662 why == SUSPEND_FOR_DEBUG_EVENT)
2663 ? -1 : 0);
2664 } else {
2665 LOG_THREAD("threadid=%d: suspendCount already zero",
2666 thread->threadId);
2667 }
2668 }
2669 unlockThreadSuspendCount();
2670 dvmUnlockThreadList();
2671
2672 /*
2673 * In some ways it makes sense to continue to hold the thread-suspend
2674 * lock while we issue the wakeup broadcast. It allows us to complete
2675 * one operation before moving on to the next, which simplifies the
2676 * thread activity debug traces.
2677 *
2678 * This approach caused us some difficulty under Linux, because the
2679 * condition variable broadcast not only made the threads runnable,
2680 * but actually caused them to execute, and it was a while before
2681 * the thread performing the wakeup had an opportunity to release the
2682 * thread-suspend lock.
2683 *
2684 * This is a problem because, when a thread tries to acquire that
2685 * lock, it times out after 3 seconds. If at some point the thread
2686 * is told to suspend, the clock resets; but since the VM is still
2687 * theoretically mid-resume, there's no suspend pending. If, for
2688 * example, the GC was waking threads up while the SIGQUIT handler
2689 * was trying to acquire the lock, we would occasionally time out on
2690 * a busy system and SignalCatcher would abort.
2691 *
2692 * We now perform the unlock before the wakeup broadcast. The next
2693 * suspend can't actually start until the broadcast completes and
2694 * returns, because we're holding the thread-suspend-count lock, but the
2695 * suspending thread is now able to make progress and we avoid the abort.
2696 *
2697 * (Technically there is a narrow window between when we release
2698 * the thread-suspend lock and grab the thread-suspend-count lock.
2699 * This could cause us to send a broadcast to threads with nonzero
2700 * suspend counts, but this is expected and they'll all just fall
2701 * right back to sleep. It's probably safe to grab the suspend-count
2702 * lock before releasing thread-suspend, since we're still following
2703 * the correct order of acquisition, but it feels weird.)
2704 */
2705
2706 LOG_THREAD("threadid=%d: ResumeAll waking others", self->threadId);
2707 unlockThreadSuspend();
2708
2709 /*
2710 * Broadcast a notification to all suspended threads, some or all of
2711 * which may choose to wake up. No need to wait for them.
2712 */
2713 lockThreadSuspendCount();
2714 int cc = pthread_cond_broadcast(&gDvm.threadSuspendCountCond);
2715 if (cc != 0) {
2716 ALOGE("pthread_cond_broadcast(&gDvm.threadSuspendCountCond) failed: %s", strerror(cc));
2717 dvmAbort();
2718 }
2719 unlockThreadSuspendCount();
2720
2721 LOG_THREAD("threadid=%d: ResumeAll complete", self->threadId);
2722 }
2723
2724 /*
2725 * Undo any debugger suspensions. This is called when the debugger
2726 * disconnects.
2727 */
dvmUndoDebuggerSuspensions()2728 void dvmUndoDebuggerSuspensions()
2729 {
2730 Thread* self = dvmThreadSelf();
2731 Thread* thread;
2732
2733 lockThreadSuspend("undo", SUSPEND_FOR_DEBUG);
2734 LOG_THREAD("threadid=%d: UndoDebuggerSusp starting", self->threadId);
2735
2736 /*
2737 * Decrement the suspend counts for all threads. No need for atomic
2738 * writes, since nobody should be moving until we decrement the count.
2739 * We do need to hold the thread list because of JNI attaches.
2740 */
2741 dvmLockThreadList(self);
2742 lockThreadSuspendCount();
2743 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
2744 if (thread == self)
2745 continue;
2746
2747 /* debugger events don't suspend JDWP thread */
2748 if (thread->handle == dvmJdwpGetDebugThread(gDvm.jdwpState)) {
2749 assert(thread->dbgSuspendCount == 0);
2750 continue;
2751 }
2752
2753 assert(thread->suspendCount >= thread->dbgSuspendCount);
2754 dvmAddToSuspendCounts(thread, -thread->dbgSuspendCount,
2755 -thread->dbgSuspendCount);
2756 }
2757 unlockThreadSuspendCount();
2758 dvmUnlockThreadList();
2759
2760 /*
2761 * Broadcast a notification to all suspended threads, some or all of
2762 * which may choose to wake up. No need to wait for them.
2763 */
2764 lockThreadSuspendCount();
2765 int cc = pthread_cond_broadcast(&gDvm.threadSuspendCountCond);
2766 if (cc != 0) {
2767 ALOGE("pthread_cond_broadcast(&gDvm.threadSuspendCountCond) failed: %s", strerror(cc));
2768 dvmAbort();
2769 }
2770 unlockThreadSuspendCount();
2771
2772 unlockThreadSuspend();
2773
2774 LOG_THREAD("threadid=%d: UndoDebuggerSusp complete", self->threadId);
2775 }
2776
2777 /*
2778 * Determine if a thread is suspended.
2779 *
2780 * As with all operations on foreign threads, the caller should hold
2781 * the thread list lock before calling.
2782 *
2783 * If the thread is suspending or waking, these fields could be changing
2784 * out from under us (or the thread could change state right after we
2785 * examine it), making this generally unreliable. This is chiefly
2786 * intended for use by the debugger.
2787 */
dvmIsSuspended(const Thread * thread)2788 bool dvmIsSuspended(const Thread* thread)
2789 {
2790 /*
2791 * The thread could be:
2792 * (1) Running happily. status is RUNNING, suspendCount is zero.
2793 * Return "false".
2794 * (2) Pending suspend. status is RUNNING, suspendCount is nonzero.
2795 * Return "false".
2796 * (3) Suspended. suspendCount is nonzero, and status is !RUNNING.
2797 * Return "true".
2798 * (4) Waking up. suspendCount is zero, status is SUSPENDED
2799 * Return "false" (since it could change out from under us, unless
2800 * we hold suspendCountLock).
2801 */
2802
2803 return (thread->suspendCount != 0 &&
2804 thread->status != THREAD_RUNNING);
2805 }
2806
2807 /*
2808 * Wait until another thread self-suspends. This is specifically for
2809 * synchronization between the JDWP thread and a thread that has decided
2810 * to suspend itself after sending an event to the debugger.
2811 *
2812 * Threads that encounter "suspend all" events work as well -- the thread
2813 * in question suspends everybody else and then itself.
2814 *
2815 * We can't hold a thread lock here or in the caller, because we could
2816 * get here just before the to-be-waited-for-thread issues a "suspend all".
2817 * There's an opportunity for badness if the thread we're waiting for exits
2818 * and gets cleaned up, but since the thread in question is processing a
2819 * debugger event, that's not really a possibility. (To avoid deadlock,
2820 * it's important that we not be in THREAD_RUNNING while we wait.)
2821 */
dvmWaitForSuspend(Thread * thread)2822 void dvmWaitForSuspend(Thread* thread)
2823 {
2824 Thread* self = dvmThreadSelf();
2825
2826 LOG_THREAD("threadid=%d: waiting for threadid=%d to sleep",
2827 self->threadId, thread->threadId);
2828
2829 assert(thread->handle != dvmJdwpGetDebugThread(gDvm.jdwpState));
2830 assert(thread != self);
2831 assert(self->status != THREAD_RUNNING);
2832
2833 waitForThreadSuspend(self, thread);
2834
2835 LOG_THREAD("threadid=%d: threadid=%d is now asleep",
2836 self->threadId, thread->threadId);
2837 }
2838
2839 /*
2840 * Check to see if we need to suspend ourselves. If so, go to sleep on
2841 * a condition variable.
2842 *
2843 * Returns "true" if we suspended ourselves.
2844 */
fullSuspendCheck(Thread * self)2845 static bool fullSuspendCheck(Thread* self)
2846 {
2847 assert(self != NULL);
2848 assert(self->suspendCount >= 0);
2849
2850 /*
2851 * Grab gDvm.threadSuspendCountLock. This gives us exclusive write
2852 * access to self->suspendCount.
2853 */
2854 lockThreadSuspendCount(); /* grab gDvm.threadSuspendCountLock */
2855
2856 bool needSuspend = (self->suspendCount != 0);
2857 if (needSuspend) {
2858 LOG_THREAD("threadid=%d: self-suspending", self->threadId);
2859 ThreadStatus oldStatus = self->status; /* should be RUNNING */
2860 self->status = THREAD_SUSPENDED;
2861
2862 ATRACE_BEGIN("DVM Suspend");
2863 while (self->suspendCount != 0) {
2864 /*
2865 * Wait for wakeup signal, releasing lock. The act of releasing
2866 * and re-acquiring the lock provides the memory barriers we
2867 * need for correct behavior on SMP.
2868 */
2869 dvmWaitCond(&gDvm.threadSuspendCountCond,
2870 &gDvm.threadSuspendCountLock);
2871 }
2872 ATRACE_END();
2873 assert(self->suspendCount == 0 && self->dbgSuspendCount == 0);
2874 self->status = oldStatus;
2875 LOG_THREAD("threadid=%d: self-reviving, status=%d",
2876 self->threadId, self->status);
2877 }
2878
2879 unlockThreadSuspendCount();
2880
2881 return needSuspend;
2882 }
2883
2884 /*
2885 * Check to see if a suspend is pending. If so, suspend the current
2886 * thread, and return "true" after we have been resumed.
2887 */
dvmCheckSuspendPending(Thread * self)2888 bool dvmCheckSuspendPending(Thread* self)
2889 {
2890 assert(self != NULL);
2891 if (self->suspendCount == 0) {
2892 return false;
2893 } else {
2894 return fullSuspendCheck(self);
2895 }
2896 }
2897
2898 /*
2899 * Update our status.
2900 *
2901 * The "self" argument, which may be NULL, is accepted as an optimization.
2902 *
2903 * Returns the old status.
2904 */
dvmChangeStatus(Thread * self,ThreadStatus newStatus)2905 ThreadStatus dvmChangeStatus(Thread* self, ThreadStatus newStatus)
2906 {
2907 ThreadStatus oldStatus;
2908
2909 if (self == NULL)
2910 self = dvmThreadSelf();
2911
2912 LOGVV("threadid=%d: (status %d -> %d)",
2913 self->threadId, self->status, newStatus);
2914
2915 oldStatus = self->status;
2916 if (oldStatus == newStatus)
2917 return oldStatus;
2918
2919 if (newStatus == THREAD_RUNNING) {
2920 /*
2921 * Change our status to THREAD_RUNNING. The transition requires
2922 * that we check for pending suspension, because the VM considers
2923 * us to be "asleep" in all other states, and another thread could
2924 * be performing a GC now.
2925 *
2926 * The order of operations is very significant here. One way to
2927 * do this wrong is:
2928 *
2929 * GCing thread Our thread (in NATIVE)
2930 * ------------ ----------------------
2931 * check suspend count (== 0)
2932 * dvmSuspendAllThreads()
2933 * grab suspend-count lock
2934 * increment all suspend counts
2935 * release suspend-count lock
2936 * check thread state (== NATIVE)
2937 * all are suspended, begin GC
2938 * set state to RUNNING
2939 * (continue executing)
2940 *
2941 * We can correct this by grabbing the suspend-count lock and
2942 * performing both of our operations (check suspend count, set
2943 * state) while holding it, now we need to grab a mutex on every
2944 * transition to RUNNING.
2945 *
2946 * What we do instead is change the order of operations so that
2947 * the transition to RUNNING happens first. If we then detect
2948 * that the suspend count is nonzero, we switch to SUSPENDED.
2949 *
2950 * Appropriate compiler and memory barriers are required to ensure
2951 * that the operations are observed in the expected order.
2952 *
2953 * This does create a small window of opportunity where a GC in
2954 * progress could observe what appears to be a running thread (if
2955 * it happens to look between when we set to RUNNING and when we
2956 * switch to SUSPENDED). At worst this only affects assertions
2957 * and thread logging. (We could work around it with some sort
2958 * of intermediate "pre-running" state that is generally treated
2959 * as equivalent to running, but that doesn't seem worthwhile.)
2960 *
2961 * We can also solve this by combining the "status" and "suspend
2962 * count" fields into a single 32-bit value. This trades the
2963 * store/load barrier on transition to RUNNING for an atomic RMW
2964 * op on all transitions and all suspend count updates (also, all
2965 * accesses to status or the thread count require bit-fiddling).
2966 * It also eliminates the brief transition through RUNNING when
2967 * the thread is supposed to be suspended. This is possibly faster
2968 * on SMP and slightly more correct, but less convenient.
2969 */
2970 volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
2971 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
2972 android_atomic_acquire_store(newStatus, addr);
2973 if (self->suspendCount != 0) {
2974 fullSuspendCheck(self);
2975 }
2976 } else {
2977 /*
2978 * Not changing to THREAD_RUNNING. No additional work required.
2979 *
2980 * We use a releasing store to ensure that, if we were RUNNING,
2981 * any updates we previously made to objects on the managed heap
2982 * will be observed before the state change.
2983 */
2984 assert(newStatus != THREAD_SUSPENDED);
2985 volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
2986 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
2987 android_atomic_release_store(newStatus, addr);
2988 }
2989
2990 return oldStatus;
2991 }
2992
2993 /*
2994 * Get a statically defined thread group from a field in the ThreadGroup
2995 * Class object. Expected arguments are "mMain" and "mSystem".
2996 */
getStaticThreadGroup(const char * fieldName)2997 static Object* getStaticThreadGroup(const char* fieldName)
2998 {
2999 StaticField* groupField;
3000 Object* groupObj;
3001
3002 groupField = dvmFindStaticField(gDvm.classJavaLangThreadGroup,
3003 fieldName, "Ljava/lang/ThreadGroup;");
3004 if (groupField == NULL) {
3005 ALOGE("java.lang.ThreadGroup does not have an '%s' field", fieldName);
3006 dvmThrowInternalError("bad definition for ThreadGroup");
3007 return NULL;
3008 }
3009 groupObj = dvmGetStaticFieldObject(groupField);
3010 if (groupObj == NULL) {
3011 ALOGE("java.lang.ThreadGroup.%s not initialized", fieldName);
3012 dvmThrowInternalError(NULL);
3013 return NULL;
3014 }
3015
3016 return groupObj;
3017 }
dvmGetSystemThreadGroup()3018 Object* dvmGetSystemThreadGroup()
3019 {
3020 return getStaticThreadGroup("mSystem");
3021 }
dvmGetMainThreadGroup()3022 Object* dvmGetMainThreadGroup()
3023 {
3024 return getStaticThreadGroup("mMain");
3025 }
3026
3027 /*
3028 * Given a VMThread object, return the associated Thread*.
3029 *
3030 * NOTE: if the thread detaches, the struct Thread will disappear, and
3031 * we will be touching invalid data. For safety, lock the thread list
3032 * before calling this.
3033 */
dvmGetThreadFromThreadObject(Object * vmThreadObj)3034 Thread* dvmGetThreadFromThreadObject(Object* vmThreadObj)
3035 {
3036 int vmData;
3037
3038 vmData = dvmGetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData);
3039
3040 if (false) {
3041 Thread* thread = gDvm.threadList;
3042 while (thread != NULL) {
3043 if ((Thread*)vmData == thread)
3044 break;
3045
3046 thread = thread->next;
3047 }
3048
3049 if (thread == NULL) {
3050 ALOGW("WARNING: vmThreadObj=%p has thread=%p, not in thread list",
3051 vmThreadObj, (Thread*)vmData);
3052 vmData = 0;
3053 }
3054 }
3055
3056 return (Thread*) vmData;
3057 }
3058
3059 /*
3060 * Given a pthread handle, return the associated Thread*.
3061 * Caller must hold the thread list lock.
3062 *
3063 * Returns NULL if the thread was not found.
3064 */
dvmGetThreadByHandle(pthread_t handle)3065 Thread* dvmGetThreadByHandle(pthread_t handle)
3066 {
3067 Thread* thread;
3068 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
3069 if (thread->handle == handle)
3070 break;
3071 }
3072 return thread;
3073 }
3074
3075 /*
3076 * Given a threadId, return the associated Thread*.
3077 * Caller must hold the thread list lock.
3078 *
3079 * Returns NULL if the thread was not found.
3080 */
dvmGetThreadByThreadId(u4 threadId)3081 Thread* dvmGetThreadByThreadId(u4 threadId)
3082 {
3083 Thread* thread;
3084 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
3085 if (thread->threadId == threadId)
3086 break;
3087 }
3088 return thread;
3089 }
3090
dvmChangeThreadPriority(Thread * thread,int newPriority)3091 void dvmChangeThreadPriority(Thread* thread, int newPriority)
3092 {
3093 os_changeThreadPriority(thread, newPriority);
3094 }
3095
3096 /*
3097 * Return true if the thread is on gDvm.threadList.
3098 * Caller should not hold gDvm.threadListLock.
3099 */
dvmIsOnThreadList(const Thread * thread)3100 bool dvmIsOnThreadList(const Thread* thread)
3101 {
3102 bool ret = false;
3103
3104 dvmLockThreadList(NULL);
3105 if (thread == gDvm.threadList) {
3106 ret = true;
3107 } else {
3108 ret = thread->prev != NULL || thread->next != NULL;
3109 }
3110 dvmUnlockThreadList();
3111
3112 return ret;
3113 }
3114
3115 /*
3116 * Dump a thread to the log file -- just calls dvmDumpThreadEx() with an
3117 * output target.
3118 */
dvmDumpThread(Thread * thread,bool isRunning)3119 void dvmDumpThread(Thread* thread, bool isRunning)
3120 {
3121 DebugOutputTarget target;
3122
3123 dvmCreateLogOutputTarget(&target, ANDROID_LOG_INFO, LOG_TAG);
3124 dvmDumpThreadEx(&target, thread, isRunning);
3125 }
3126
3127 /*
3128 * Try to get the scheduler group.
3129 *
3130 * The data from /proc/<pid>/cgroup looks (something) like:
3131 * 2:cpu:/bg_non_interactive
3132 * 1:cpuacct:/
3133 *
3134 * We return the part on the "cpu" line after the '/', which will be an
3135 * empty string for the default cgroup. If the string is longer than
3136 * "bufLen", the string will be truncated.
3137 *
3138 * On error, -1 is returned, and an error description will be stored in
3139 * the buffer.
3140 */
getSchedulerGroup(int tid,char * buf,size_t bufLen)3141 static int getSchedulerGroup(int tid, char* buf, size_t bufLen)
3142 {
3143 #ifdef HAVE_ANDROID_OS
3144 char pathBuf[32];
3145 char lineBuf[256];
3146 FILE *fp;
3147
3148 snprintf(pathBuf, sizeof(pathBuf), "/proc/%d/cgroup", tid);
3149 if ((fp = fopen(pathBuf, "r")) == NULL) {
3150 snprintf(buf, bufLen, "[fopen-error:%d]", errno);
3151 return -1;
3152 }
3153
3154 while (fgets(lineBuf, sizeof(lineBuf) -1, fp) != NULL) {
3155 char* subsys;
3156 char* grp;
3157 size_t len;
3158
3159 /* Junk the first field */
3160 subsys = strchr(lineBuf, ':');
3161 if (subsys == NULL) {
3162 goto out_bad_data;
3163 }
3164
3165 if (strncmp(subsys, ":cpu:", 5) != 0) {
3166 /* Not the subsys we're looking for */
3167 continue;
3168 }
3169
3170 grp = strchr(subsys, '/');
3171 if (grp == NULL) {
3172 goto out_bad_data;
3173 }
3174 grp++; /* Drop the leading '/' */
3175
3176 len = strlen(grp);
3177 grp[len-1] = '\0'; /* Drop the trailing '\n' */
3178
3179 if (bufLen <= len) {
3180 len = bufLen - 1;
3181 }
3182 strncpy(buf, grp, len);
3183 buf[len] = '\0';
3184 fclose(fp);
3185 return 0;
3186 }
3187
3188 snprintf(buf, bufLen, "[no-cpu-subsys]");
3189 fclose(fp);
3190 return -1;
3191
3192 out_bad_data:
3193 ALOGE("Bad cgroup data {%s}", lineBuf);
3194 snprintf(buf, bufLen, "[data-parse-failed]");
3195 fclose(fp);
3196 return -1;
3197
3198 #else
3199 snprintf(buf, bufLen, "[n/a]");
3200 return -1;
3201 #endif
3202 }
3203
3204 /*
3205 * Convert ThreadStatus to a string.
3206 */
dvmGetThreadStatusStr(ThreadStatus status)3207 const char* dvmGetThreadStatusStr(ThreadStatus status)
3208 {
3209 switch (status) {
3210 case THREAD_ZOMBIE: return "ZOMBIE";
3211 case THREAD_RUNNING: return "RUNNABLE";
3212 case THREAD_TIMED_WAIT: return "TIMED_WAIT";
3213 case THREAD_MONITOR: return "MONITOR";
3214 case THREAD_WAIT: return "WAIT";
3215 case THREAD_INITIALIZING: return "INITIALIZING";
3216 case THREAD_STARTING: return "STARTING";
3217 case THREAD_NATIVE: return "NATIVE";
3218 case THREAD_VMWAIT: return "VMWAIT";
3219 case THREAD_SUSPENDED: return "SUSPENDED";
3220 default: return "UNKNOWN";
3221 }
3222 }
3223
dumpSchedStat(const DebugOutputTarget * target,pid_t tid)3224 static void dumpSchedStat(const DebugOutputTarget* target, pid_t tid) {
3225 #ifdef HAVE_ANDROID_OS
3226 /* get some bits from /proc/self/stat */
3227 ProcStatData procStatData;
3228 if (!dvmGetThreadStats(&procStatData, tid)) {
3229 /* failed, use zeroed values */
3230 memset(&procStatData, 0, sizeof(procStatData));
3231 }
3232
3233 /* grab the scheduler stats for this thread */
3234 char schedstatBuf[64];
3235 snprintf(schedstatBuf, sizeof(schedstatBuf), "/proc/self/task/%d/schedstat", tid);
3236 int schedstatFd = open(schedstatBuf, O_RDONLY);
3237 strcpy(schedstatBuf, "0 0 0"); /* show this if open/read fails */
3238 if (schedstatFd >= 0) {
3239 ssize_t bytes;
3240 bytes = read(schedstatFd, schedstatBuf, sizeof(schedstatBuf) - 1);
3241 close(schedstatFd);
3242 if (bytes >= 1) {
3243 schedstatBuf[bytes - 1] = '\0'; /* remove trailing newline */
3244 }
3245 }
3246
3247 /* show what we got */
3248 dvmPrintDebugMessage(target,
3249 " | state=%c schedstat=( %s ) utm=%lu stm=%lu core=%d\n",
3250 procStatData.state, schedstatBuf, procStatData.utime,
3251 procStatData.stime, procStatData.processor);
3252 #endif
3253 }
3254
3255 struct SchedulerStats {
3256 int policy;
3257 int priority;
3258 char group[32];
3259 };
3260
3261 /*
3262 * Get scheduler statistics.
3263 */
getSchedulerStats(SchedulerStats * stats,pid_t tid)3264 static void getSchedulerStats(SchedulerStats* stats, pid_t tid) {
3265 struct sched_param sp;
3266 if (pthread_getschedparam(pthread_self(), &stats->policy, &sp) != 0) {
3267 ALOGW("Warning: pthread_getschedparam failed");
3268 stats->policy = -1;
3269 stats->priority = -1;
3270 } else {
3271 stats->priority = sp.sched_priority;
3272 }
3273 if (getSchedulerGroup(tid, stats->group, sizeof(stats->group)) == 0 &&
3274 stats->group[0] == '\0') {
3275 strcpy(stats->group, "default");
3276 }
3277 }
3278
shouldShowNativeStack(Thread * thread)3279 static bool shouldShowNativeStack(Thread* thread) {
3280 // In native code somewhere in the VM? That's interesting.
3281 if (thread->status == THREAD_VMWAIT) {
3282 return true;
3283 }
3284
3285 // In an Object.wait variant? That's not interesting.
3286 if (thread->status == THREAD_TIMED_WAIT || thread->status == THREAD_WAIT) {
3287 return false;
3288 }
3289
3290 // The Signal Catcher thread? That's not interesting.
3291 if (thread->status == THREAD_RUNNING) {
3292 return false;
3293 }
3294
3295 // In some other native method? That's interesting.
3296 // We don't just check THREAD_NATIVE because native methods will be in
3297 // state THREAD_SUSPENDED if they're calling back into the VM, or THREAD_MONITOR
3298 // if they're blocked on a monitor, or one of the thread-startup states if
3299 // it's early enough in their life cycle (http://b/7432159).
3300 u4* fp = thread->interpSave.curFrame;
3301 if (fp == NULL) {
3302 // The thread has no managed frames, so native frames are all there is.
3303 return true;
3304 }
3305 const Method* currentMethod = SAVEAREA_FROM_FP(fp)->method;
3306 return currentMethod != NULL && dvmIsNativeMethod(currentMethod);
3307 }
3308
3309 /*
3310 * Print information about the specified thread.
3311 *
3312 * Works best when the thread in question is "self" or has been suspended.
3313 * When dumping a separate thread that's still running, set "isRunning" to
3314 * use a more cautious thread dump function.
3315 */
dvmDumpThreadEx(const DebugOutputTarget * target,Thread * thread,bool isRunning)3316 void dvmDumpThreadEx(const DebugOutputTarget* target, Thread* thread,
3317 bool isRunning)
3318 {
3319 Object* threadObj;
3320 Object* groupObj;
3321 StringObject* nameStr;
3322 char* threadName = NULL;
3323 char* groupName = NULL;
3324 bool isDaemon;
3325 int priority; // java.lang.Thread priority
3326
3327 /*
3328 * Get the java.lang.Thread object. This function gets called from
3329 * some weird debug contexts, so it's possible that there's a GC in
3330 * progress on some other thread. To decrease the chances of the
3331 * thread object being moved out from under us, we add the reference
3332 * to the tracked allocation list, which pins it in place.
3333 *
3334 * If threadObj is NULL, the thread is still in the process of being
3335 * attached to the VM, and there's really nothing interesting to
3336 * say about it yet.
3337 */
3338 threadObj = thread->threadObj;
3339 if (threadObj == NULL) {
3340 ALOGI("Can't dump thread %d: threadObj not set", thread->threadId);
3341 return;
3342 }
3343 dvmAddTrackedAlloc(threadObj, NULL);
3344
3345 nameStr = (StringObject*) dvmGetFieldObject(threadObj,
3346 gDvm.offJavaLangThread_name);
3347 threadName = dvmCreateCstrFromString(nameStr);
3348
3349 priority = dvmGetFieldInt(threadObj, gDvm.offJavaLangThread_priority);
3350 isDaemon = dvmGetFieldBoolean(threadObj, gDvm.offJavaLangThread_daemon);
3351
3352 /* a null value for group is not expected, but deal with it anyway */
3353 groupObj = (Object*) dvmGetFieldObject(threadObj,
3354 gDvm.offJavaLangThread_group);
3355 if (groupObj != NULL) {
3356 nameStr = (StringObject*)
3357 dvmGetFieldObject(groupObj, gDvm.offJavaLangThreadGroup_name);
3358 groupName = dvmCreateCstrFromString(nameStr);
3359 }
3360 if (groupName == NULL)
3361 groupName = strdup("(null; initializing?)");
3362
3363 SchedulerStats schedStats;
3364 getSchedulerStats(&schedStats, thread->systemTid);
3365
3366 dvmPrintDebugMessage(target,
3367 "\"%s\"%s prio=%d tid=%d %s%s\n",
3368 threadName, isDaemon ? " daemon" : "",
3369 priority, thread->threadId, dvmGetThreadStatusStr(thread->status),
3370 #if defined(WITH_JIT)
3371 thread->inJitCodeCache ? " JIT" : ""
3372 #else
3373 ""
3374 #endif
3375 );
3376 dvmPrintDebugMessage(target,
3377 " | group=\"%s\" sCount=%d dsCount=%d obj=%p self=%p\n",
3378 groupName, thread->suspendCount, thread->dbgSuspendCount,
3379 thread->threadObj, thread);
3380 dvmPrintDebugMessage(target,
3381 " | sysTid=%d nice=%d sched=%d/%d cgrp=%s handle=%d\n",
3382 thread->systemTid, getpriority(PRIO_PROCESS, thread->systemTid),
3383 schedStats.policy, schedStats.priority, schedStats.group, (int)thread->handle);
3384
3385 dumpSchedStat(target, thread->systemTid);
3386
3387 if (shouldShowNativeStack(thread)) {
3388 dvmDumpNativeStack(target, thread->systemTid);
3389 }
3390
3391 if (isRunning)
3392 dvmDumpRunningThreadStack(target, thread);
3393 else
3394 dvmDumpThreadStack(target, thread);
3395
3396 dvmPrintDebugMessage(target, "\n");
3397
3398 dvmReleaseTrackedAlloc(threadObj, NULL);
3399 free(threadName);
3400 free(groupName);
3401 }
3402
dvmGetThreadName(Thread * thread)3403 std::string dvmGetThreadName(Thread* thread) {
3404 if (thread->threadObj == NULL) {
3405 ALOGW("threadObj is NULL, name not available");
3406 return "-unknown-";
3407 }
3408
3409 StringObject* nameObj = (StringObject*)
3410 dvmGetFieldObject(thread->threadObj, gDvm.offJavaLangThread_name);
3411 char* name = dvmCreateCstrFromString(nameObj);
3412 std::string result(name);
3413 free(name);
3414 return result;
3415 }
3416
3417 #ifdef HAVE_ANDROID_OS
3418 /*
3419 * Dumps information about a non-Dalvik thread.
3420 */
dumpNativeThread(const DebugOutputTarget * target,pid_t tid)3421 static void dumpNativeThread(const DebugOutputTarget* target, pid_t tid) {
3422 char path[64];
3423 snprintf(path, sizeof(path), "/proc/%d/comm", tid);
3424
3425 int fd = open(path, O_RDONLY);
3426 char name[64];
3427 ssize_t n = 0;
3428 if (fd >= 0) {
3429 n = read(fd, name, sizeof(name) - 1);
3430 close(fd);
3431 }
3432 if (n > 0 && name[n - 1] == '\n') {
3433 n -= 1;
3434 }
3435 if (n <= 0) {
3436 strcpy(name, "<no name>");
3437 } else {
3438 name[n] = '\0';
3439 }
3440
3441 SchedulerStats schedStats;
3442 getSchedulerStats(&schedStats, tid);
3443
3444 dvmPrintDebugMessage(target,
3445 "\"%s\" sysTid=%d nice=%d sched=%d/%d cgrp=%s\n",
3446 name, tid, getpriority(PRIO_PROCESS, tid),
3447 schedStats.policy, schedStats.priority, schedStats.group);
3448 dumpSchedStat(target, tid);
3449 // Temporarily disabled collecting native stacks from non-Dalvik
3450 // threads because sometimes they misbehave.
3451 //dvmDumpNativeStack(target, tid);
3452
3453 dvmPrintDebugMessage(target, "\n");
3454 }
3455
3456 /*
3457 * Returns true if the specified tid is a Dalvik thread.
3458 * Assumes the thread list lock is held.
3459 */
isDalvikThread(pid_t tid)3460 static bool isDalvikThread(pid_t tid) {
3461 for (Thread* thread = gDvm.threadList; thread != NULL; thread = thread->next) {
3462 if (thread->systemTid == tid) {
3463 return true;
3464 }
3465 }
3466 return false;
3467 }
3468 #endif
3469
3470 /*
3471 * Dump all threads to the log file -- just calls dvmDumpAllThreadsEx() with
3472 * an output target.
3473 */
dvmDumpAllThreads(bool grabLock)3474 void dvmDumpAllThreads(bool grabLock)
3475 {
3476 DebugOutputTarget target;
3477
3478 dvmCreateLogOutputTarget(&target, ANDROID_LOG_INFO, LOG_TAG);
3479 dvmDumpAllThreadsEx(&target, grabLock);
3480 }
3481
3482 /*
3483 * Print information about all known threads. Assumes they have been
3484 * suspended (or are in a non-interpreting state, e.g. WAIT or NATIVE).
3485 *
3486 * If "grabLock" is true, we grab the thread lock list. This is important
3487 * to do unless the caller already holds the lock.
3488 */
dvmDumpAllThreadsEx(const DebugOutputTarget * target,bool grabLock)3489 void dvmDumpAllThreadsEx(const DebugOutputTarget* target, bool grabLock)
3490 {
3491 Thread* thread;
3492
3493 dvmPrintDebugMessage(target, "DALVIK THREADS:\n");
3494
3495 #ifdef HAVE_ANDROID_OS
3496 dvmPrintDebugMessage(target,
3497 "(mutexes: tll=%x tsl=%x tscl=%x ghl=%x)\n\n",
3498 gDvm.threadListLock.value,
3499 gDvm._threadSuspendLock.value,
3500 gDvm.threadSuspendCountLock.value,
3501 gDvm.gcHeapLock.value);
3502 #endif
3503
3504 if (grabLock)
3505 dvmLockThreadList(dvmThreadSelf());
3506
3507 thread = gDvm.threadList;
3508 while (thread != NULL) {
3509 dvmDumpThreadEx(target, thread, false);
3510
3511 /* verify link */
3512 assert(thread->next == NULL || thread->next->prev == thread);
3513
3514 thread = thread->next;
3515 }
3516
3517 #ifdef HAVE_ANDROID_OS
3518 DIR* d = opendir("/proc/self/task");
3519 if (d != NULL) {
3520 dirent* entry = NULL;
3521 bool first = true;
3522 while ((entry = readdir(d)) != NULL) {
3523 char* end;
3524 pid_t tid = strtol(entry->d_name, &end, 10);
3525 if (!*end && !isDalvikThread(tid)) {
3526 if (first) {
3527 dvmPrintDebugMessage(target, "NATIVE THREADS:\n");
3528 first = false;
3529 }
3530 dumpNativeThread(target, tid);
3531 }
3532 }
3533 closedir(d);
3534 }
3535 #endif
3536
3537 if (grabLock)
3538 dvmUnlockThreadList();
3539 }
3540
3541 /*
3542 * Nuke the target thread from orbit.
3543 *
3544 * The idea is to send a "crash" signal to the target thread so that
3545 * debuggerd will take notice and dump an appropriate stack trace.
3546 * Because of the way debuggerd works, we have to throw the same signal
3547 * at it twice.
3548 *
3549 * This does not necessarily cause the entire process to stop, but once a
3550 * thread has been nuked the rest of the system is likely to be unstable.
3551 * This returns so that some limited set of additional operations may be
3552 * performed, but it's advisable (and expected) to call dvmAbort soon.
3553 * (This is NOT a way to simply cancel a thread.)
3554 */
dvmNukeThread(Thread * thread)3555 void dvmNukeThread(Thread* thread)
3556 {
3557 int killResult;
3558
3559 /* suppress the heapworker watchdog to assist anyone using a debugger */
3560 gDvm.nativeDebuggerActive = true;
3561
3562 /*
3563 * Send the signals, separated by a brief interval to allow debuggerd
3564 * to work its magic. An uncommon signal like SIGFPE or SIGSTKFLT
3565 * can be used instead of SIGSEGV to avoid making it look like the
3566 * code actually crashed at the current point of execution.
3567 *
3568 * (Observed behavior: with SIGFPE, debuggerd will dump the target
3569 * thread and then the thread that calls dvmAbort. With SIGSEGV,
3570 * you don't get the second stack trace; possibly something in the
3571 * kernel decides that a signal has already been sent and it's time
3572 * to just kill the process. The position in the current thread is
3573 * generally known, so the second dump is not useful.)
3574 *
3575 * The target thread can continue to execute between the two signals.
3576 * (The first just causes debuggerd to attach to it.)
3577 */
3578 #ifdef SIGSTKFLT
3579 #define SIG SIGSTKFLT
3580 #define SIGNAME "SIGSTKFLT"
3581 #elif defined(SIGEMT)
3582 #define SIG SIGEMT
3583 #define SIGNAME "SIGEMT"
3584 #else
3585 #error No signal available for dvmNukeThread
3586 #endif
3587
3588 ALOGD("threadid=%d: sending two " SIGNAME "s to threadid=%d (tid=%d) to"
3589 " cause debuggerd dump",
3590 dvmThreadSelf()->threadId, thread->threadId, thread->systemTid);
3591 killResult = pthread_kill(thread->handle, SIG);
3592 if (killResult != 0) {
3593 ALOGD("NOTE: pthread_kill #1 failed: %s", strerror(killResult));
3594 }
3595 usleep(2 * 1000 * 1000); // TODO: timed-wait until debuggerd attaches
3596 killResult = pthread_kill(thread->handle, SIG);
3597 if (killResult != 0) {
3598 ALOGD("NOTE: pthread_kill #2 failed: %s", strerror(killResult));
3599 }
3600 ALOGD("Sent, pausing to let debuggerd run");
3601 usleep(8 * 1000 * 1000); // TODO: timed-wait until debuggerd finishes
3602
3603 /* ignore SIGSEGV so the eventual dvmAbort() doesn't notify debuggerd */
3604 signal(SIGSEGV, SIG_IGN);
3605 ALOGD("Continuing");
3606 }
3607