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