• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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