Home | History | Annotate | Download | only in vm 
      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  * VM thread support.
     19  */
     20 #ifndef _DALVIK_THREAD
     21 #define _DALVIK_THREAD
     22 
     23 #include "jni.h"
     24 
     25 #include <errno.h>
     26 #include <cutils/sched_policy.h>
     27 
     28 
     29 #if defined(CHECK_MUTEX) && !defined(__USE_UNIX98)
     30 /* glibc lacks this unless you #define __USE_UNIX98 */
     31 int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
     32 enum { PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP };
     33 #endif
     34 
     35 #ifdef WITH_MONITOR_TRACKING
     36 struct LockedObjectData;
     37 #endif
     38 
     39 /*
     40  * Current status; these map to JDWP constants, so don't rearrange them.
     41  * (If you do alter this, update the strings in dvmDumpThread and the
     42  * conversion table in VMThread.java.)
     43  *
     44  * Note that "suspended" is orthogonal to these values (so says JDWP).
     45  */
     46 typedef enum ThreadStatus {
     47     THREAD_UNDEFINED    = -1,       /* makes enum compatible with int32_t */
     48 
     49     /* these match up with JDWP values */
     50     THREAD_ZOMBIE       = 0,        /* TERMINATED */
     51     THREAD_RUNNING      = 1,        /* RUNNABLE or running now */
     52     THREAD_TIMED_WAIT   = 2,        /* TIMED_WAITING in Object.wait() */
     53     THREAD_MONITOR      = 3,        /* BLOCKED on a monitor */
     54     THREAD_WAIT         = 4,        /* WAITING in Object.wait() */
     55     /* non-JDWP states */
     56     THREAD_INITIALIZING = 5,        /* allocated, not yet running */
     57     THREAD_STARTING     = 6,        /* started, not yet on thread list */
     58     THREAD_NATIVE       = 7,        /* off in a JNI native method */
     59     THREAD_VMWAIT       = 8,        /* waiting on a VM resource */
     60     THREAD_SUSPENDED    = 9,        /* suspended, usually by GC or debugger */
     61 } ThreadStatus;
     62 
     63 /* thread priorities, from java.lang.Thread */
     64 enum {
     65     THREAD_MIN_PRIORITY     = 1,
     66     THREAD_NORM_PRIORITY    = 5,
     67     THREAD_MAX_PRIORITY     = 10,
     68 };
     69 
     70 
     71 /* initialization */
     72 bool dvmThreadStartup(void);
     73 bool dvmThreadObjStartup(void);
     74 void dvmThreadShutdown(void);
     75 void dvmSlayDaemons(void);
     76 
     77 
     78 #define kJniLocalRefMin         32
     79 #define kJniLocalRefMax         512     /* arbitrary; should be plenty */
     80 #define kInternalRefDefault     32      /* equally arbitrary */
     81 #define kInternalRefMax         4096    /* mainly a sanity check */
     82 
     83 #define kMinStackSize       (512 + STACK_OVERFLOW_RESERVE)
     84 #define kDefaultStackSize   (12*1024)   /* three 4K pages */
     85 #define kMaxStackSize       (256*1024 + STACK_OVERFLOW_RESERVE)
     86 
     87 /*
     88  * Our per-thread data.
     89  *
     90  * These are allocated on the system heap.
     91  */
     92 typedef struct Thread {
     93     /* small unique integer; useful for "thin" locks and debug messages */
     94     u4          threadId;
     95 
     96     /*
     97      * Thread's current status.  Can only be changed by the thread itself
     98      * (i.e. don't mess with this from other threads).
     99      */
    100     volatile ThreadStatus status;
    101 
    102     /*
    103      * This is the number of times the thread has been suspended.  When the
    104      * count drops to zero, the thread resumes.
    105      *
    106      * "dbgSuspendCount" is the portion of the suspend count that the
    107      * debugger is responsible for.  This has to be tracked separately so
    108      * that we can recover correctly if the debugger abruptly disconnects
    109      * (suspendCount -= dbgSuspendCount).  The debugger should not be able
    110      * to resume GC-suspended threads, because we ignore the debugger while
    111      * a GC is in progress.
    112      *
    113      * Both of these are guarded by gDvm.threadSuspendCountLock.
    114      *
    115      * (We could store both of these in the same 32-bit, using 16-bit
    116      * halves, to make atomic ops possible.  In practice, you only need
    117      * to read suspendCount, and we need to hold a mutex when making
    118      * changes, so there's no need to merge them.  Note the non-debug
    119      * component will rarely be other than 1 or 0 -- not sure it's even
    120      * possible with the way mutexes are currently used.)
    121      */
    122     int         suspendCount;
    123     int         dbgSuspendCount;
    124 
    125     /* thread handle, as reported by pthread_self() */
    126     pthread_t   handle;
    127 
    128     /* thread ID, only useful under Linux */
    129     pid_t       systemTid;
    130 
    131     /* start (high addr) of interp stack (subtract size to get malloc addr) */
    132     u1*         interpStackStart;
    133 
    134     /* current limit of stack; flexes for StackOverflowError */
    135     const u1*   interpStackEnd;
    136 
    137     /* interpreter stack size; our stacks are fixed-length */
    138     int         interpStackSize;
    139     bool        stackOverflowed;
    140 
    141     /* FP of bottom-most (currently executing) stack frame on interp stack */
    142     void*       curFrame;
    143 
    144     /* current exception, or NULL if nothing pending */
    145     Object*     exception;
    146 
    147     /* the java/lang/Thread that we are associated with */
    148     Object*     threadObj;
    149 
    150     /* the JNIEnv pointer associated with this thread */
    151     JNIEnv*     jniEnv;
    152 
    153     /* internal reference tracking */
    154     ReferenceTable  internalLocalRefTable;
    155 
    156 #if defined(WITH_JIT)
    157     /*
    158      * Whether the current top VM frame is in the interpreter or JIT cache:
    159      *   NULL    : in the interpreter
    160      *   non-NULL: entry address of the JIT'ed code (the actual value doesn't
    161      *             matter)
    162      */
    163     void*       inJitCodeCache;
    164 #if defined(WITH_SELF_VERIFICATION)
    165     /* Buffer for register state during self verification */
    166     struct ShadowSpace* shadowSpace;
    167 #endif
    168 #endif
    169 
    170     /* JNI local reference tracking */
    171 #ifdef USE_INDIRECT_REF
    172     IndirectRefTable jniLocalRefTable;
    173 #else
    174     ReferenceTable  jniLocalRefTable;
    175 #endif
    176 
    177     /* JNI native monitor reference tracking (initialized on first use) */
    178     ReferenceTable  jniMonitorRefTable;
    179 
    180     /* hack to make JNI_OnLoad work right */
    181     Object*     classLoaderOverride;
    182 
    183     /* mutex to guard the interrupted and the waitMonitor members */
    184     pthread_mutex_t    waitMutex;
    185 
    186     /* pointer to the monitor lock we're currently waiting on */
    187     /* guarded by waitMutex */
    188     /* TODO: consider changing this to Object* for better JDWP interaction */
    189     Monitor*    waitMonitor;
    190 
    191     /* thread "interrupted" status; stays raised until queried or thrown */
    192     /* guarded by waitMutex */
    193     bool        interrupted;
    194 
    195     /* links to the next thread in the wait set this thread is part of */
    196     struct Thread*     waitNext;
    197 
    198     /* object to sleep on while we are waiting for a monitor */
    199     pthread_cond_t     waitCond;
    200 
    201     /*
    202      * Set to true when the thread is in the process of throwing an
    203      * OutOfMemoryError.
    204      */
    205     bool        throwingOOME;
    206 
    207     /* links to rest of thread list; grab global lock before traversing */
    208     struct Thread* prev;
    209     struct Thread* next;
    210 
    211     /* used by threadExitCheck when a thread exits without detaching */
    212     int         threadExitCheckCount;
    213 
    214     /* JDWP invoke-during-breakpoint support */
    215     DebugInvokeReq  invokeReq;
    216 
    217 #ifdef WITH_MONITOR_TRACKING
    218     /* objects locked by this thread; most recent is at head of list */
    219     struct LockedObjectData* pLockedObjects;
    220 #endif
    221 
    222 #ifdef WITH_ALLOC_LIMITS
    223     /* allocation limit, for Debug.setAllocationLimit() regression testing */
    224     int         allocLimit;
    225 #endif
    226 
    227     /* base time for per-thread CPU timing (used by method profiling) */
    228     bool        cpuClockBaseSet;
    229     u8          cpuClockBase;
    230 
    231     /* memory allocation profiling state */
    232     AllocProfState allocProf;
    233 
    234 #ifdef WITH_JNI_STACK_CHECK
    235     u4          stackCrc;
    236 #endif
    237 
    238 #if WITH_EXTRA_GC_CHECKS > 1
    239     /* PC, saved on every instruction; redundant with StackSaveArea */
    240     const u2*   currentPc2;
    241 #endif
    242 } Thread;
    243 
    244 /* start point for an internal thread; mimics pthread args */
    245 typedef void* (*InternalThreadStart)(void* arg);
    246 
    247 /* args for internal thread creation */
    248 typedef struct InternalStartArgs {
    249     /* inputs */
    250     InternalThreadStart func;
    251     void*       funcArg;
    252     char*       name;
    253     Object*     group;
    254     bool        isDaemon;
    255     /* result */
    256     volatile Thread** pThread;
    257     volatile int*     pCreateStatus;
    258 } InternalStartArgs;
    259 
    260 /* finish init */
    261 bool dvmPrepMainForJni(JNIEnv* pEnv);
    262 bool dvmPrepMainThread(void);
    263 
    264 /* utility function to get the tid */
    265 pid_t dvmGetSysThreadId(void);
    266 
    267 /*
    268  * Get our Thread* from TLS.
    269  *
    270  * Returns NULL if this isn't a thread that the VM is aware of.
    271  */
    272 Thread* dvmThreadSelf(void);
    273 
    274 /* grab the thread list global lock */
    275 void dvmLockThreadList(Thread* self);
    276 /* release the thread list global lock */
    277 void dvmUnlockThreadList(void);
    278 
    279 /*
    280  * Thread suspend/resume, used by the GC and debugger.
    281  */
    282 typedef enum SuspendCause {
    283     SUSPEND_NOT = 0,
    284     SUSPEND_FOR_GC,
    285     SUSPEND_FOR_DEBUG,
    286     SUSPEND_FOR_DEBUG_EVENT,
    287     SUSPEND_FOR_STACK_DUMP,
    288     SUSPEND_FOR_DEX_OPT,
    289     SUSPEND_FOR_VERIFY,
    290 #if defined(WITH_JIT)
    291     SUSPEND_FOR_TBL_RESIZE,  // jit-table resize
    292     SUSPEND_FOR_IC_PATCH,    // polymorphic callsite inline-cache patch
    293     SUSPEND_FOR_CC_RESET,    // code-cache reset
    294     SUSPEND_FOR_REFRESH,     // Reload data cached in interpState
    295 #endif
    296 } SuspendCause;
    297 void dvmSuspendThread(Thread* thread);
    298 void dvmSuspendSelf(bool jdwpActivity);
    299 void dvmResumeThread(Thread* thread);
    300 void dvmSuspendAllThreads(SuspendCause why);
    301 void dvmResumeAllThreads(SuspendCause why);
    302 void dvmUndoDebuggerSuspensions(void);
    303 
    304 /*
    305  * Check suspend state.  Grab threadListLock before calling.
    306  */
    307 bool dvmIsSuspended(const Thread* thread);
    308 
    309 /*
    310  * Wait until a thread has suspended.  (Used by debugger support.)
    311  */
    312 void dvmWaitForSuspend(Thread* thread);
    313 
    314 /*
    315  * Check to see if we should be suspended now.  If so, suspend ourselves
    316  * by sleeping on a condition variable.
    317  */
    318 bool dvmCheckSuspendPending(Thread* self);
    319 
    320 /*
    321  * Fast test for use in the interpreter.  Returns "true" if our suspend
    322  * count is nonzero.
    323  */
    324 INLINE bool dvmCheckSuspendQuick(Thread* self) {
    325     return (self->suspendCount != 0);
    326 }
    327 
    328 /*
    329  * Used when changing thread state.  Threads may only change their own.
    330  * The "self" argument, which may be NULL, is accepted as an optimization.
    331  *
    332  * If you're calling this before waiting on a resource (e.g. THREAD_WAIT
    333  * or THREAD_MONITOR), do so in the same function as the wait -- this records
    334  * the current stack depth for the GC.
    335  *
    336  * If you're changing to THREAD_RUNNING, this will check for suspension.
    337  *
    338  * Returns the old status.
    339  */
    340 ThreadStatus dvmChangeStatus(Thread* self, ThreadStatus newStatus);
    341 
    342 /*
    343  * Initialize a mutex.
    344  */
    345 INLINE void dvmInitMutex(pthread_mutex_t* pMutex)
    346 {
    347 #ifdef CHECK_MUTEX
    348     pthread_mutexattr_t attr;
    349     int cc;
    350 
    351     pthread_mutexattr_init(&attr);
    352     cc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
    353     assert(cc == 0);
    354     pthread_mutex_init(pMutex, &attr);
    355     pthread_mutexattr_destroy(&attr);
    356 #else
    357     pthread_mutex_init(pMutex, NULL);       // default=PTHREAD_MUTEX_FAST_NP
    358 #endif
    359 }
    360 
    361 /*
    362  * Grab a plain mutex.
    363  */
    364 INLINE void dvmLockMutex(pthread_mutex_t* pMutex)
    365 {
    366     int cc __attribute__ ((__unused__)) = pthread_mutex_lock(pMutex);
    367     assert(cc == 0);
    368 }
    369 
    370 /*
    371  * Try grabbing a plain mutex.  Returns 0 if successful.
    372  */
    373 INLINE int dvmTryLockMutex(pthread_mutex_t* pMutex)
    374 {
    375     int cc = pthread_mutex_trylock(pMutex);
    376     assert(cc == 0 || cc == EBUSY);
    377     return cc;
    378 }
    379 
    380 /*
    381  * Unlock pthread mutex.
    382  */
    383 INLINE void dvmUnlockMutex(pthread_mutex_t* pMutex)
    384 {
    385     int cc __attribute__ ((__unused__)) = pthread_mutex_unlock(pMutex);
    386     assert(cc == 0);
    387 }
    388 
    389 /*
    390  * Destroy a mutex.
    391  */
    392 INLINE void dvmDestroyMutex(pthread_mutex_t* pMutex)
    393 {
    394     int cc __attribute__ ((__unused__)) = pthread_mutex_destroy(pMutex);
    395     assert(cc == 0);
    396 }
    397 
    398 INLINE void dvmBroadcastCond(pthread_cond_t* pCond)
    399 {
    400     int cc __attribute__ ((__unused__)) = pthread_cond_broadcast(pCond);
    401     assert(cc == 0);
    402 }
    403 
    404 INLINE void dvmSignalCond(pthread_cond_t* pCond)
    405 {
    406     int cc __attribute__ ((__unused__)) = pthread_cond_signal(pCond);
    407     assert(cc == 0);
    408 }
    409 
    410 INLINE void dvmWaitCond(pthread_cond_t* pCond, pthread_mutex_t* pMutex)
    411 {
    412     int cc __attribute__ ((__unused__)) = pthread_cond_wait(pCond, pMutex);
    413     assert(cc == 0);
    414 }
    415 
    416 /*
    417  * Create a thread as a result of java.lang.Thread.start().
    418  */
    419 bool dvmCreateInterpThread(Object* threadObj, int reqStackSize);
    420 
    421 /*
    422  * Create a thread internal to the VM.  It's visible to interpreted code,
    423  * but found in the "system" thread group rather than "main".
    424  */
    425 bool dvmCreateInternalThread(pthread_t* pHandle, const char* name,
    426     InternalThreadStart func, void* funcArg);
    427 
    428 /*
    429  * Attach or detach the current thread from the VM.
    430  */
    431 bool dvmAttachCurrentThread(const JavaVMAttachArgs* pArgs, bool isDaemon);
    432 void dvmDetachCurrentThread(void);
    433 
    434 /*
    435  * Get the "main" or "system" thread group.
    436  */
    437 Object* dvmGetMainThreadGroup(void);
    438 Object* dvmGetSystemThreadGroup(void);
    439 
    440 /*
    441  * Given a java/lang/VMThread object, return our Thread.
    442  */
    443 Thread* dvmGetThreadFromThreadObject(Object* vmThreadObj);
    444 
    445 /*
    446  * Given a pthread handle, return the associated Thread*.
    447  * Caller must hold the thread list lock.
    448  *
    449  * Returns NULL if the thread was not found.
    450  */
    451 Thread* dvmGetThreadByHandle(pthread_t handle);
    452 
    453 /*
    454  * Given a thread ID, return the associated Thread*.
    455  * Caller must hold the thread list lock.
    456  *
    457  * Returns NULL if the thread was not found.
    458  */
    459 Thread* dvmGetThreadByThreadId(u4 threadId);
    460 
    461 /*
    462  * Sleep in a thread.  Returns when the sleep timer returns or the thread
    463  * is interrupted.
    464  */
    465 void dvmThreadSleep(u8 msec, u4 nsec);
    466 
    467 /*
    468  * Get the name of a thread.  (For safety, hold the thread list lock.)
    469  */
    470 char* dvmGetThreadName(Thread* thread);
    471 
    472 /*
    473  * Convert ThreadStatus to a string.
    474  */
    475 const char* dvmGetThreadStatusStr(ThreadStatus status);
    476 
    477 /*
    478  * Return true if a thread is on the internal list.  If it is, the
    479  * thread is part of the GC's root set.
    480  */
    481 bool dvmIsOnThreadList(const Thread* thread);
    482 
    483 /*
    484  * Get/set the JNIEnv field.
    485  */
    486 INLINE JNIEnv* dvmGetThreadJNIEnv(Thread* self) { return self->jniEnv; }
    487 INLINE void dvmSetThreadJNIEnv(Thread* self, JNIEnv* env) { self->jniEnv = env;}
    488 
    489 /*
    490  * Update the priority value of the underlying pthread.
    491  */
    492 void dvmChangeThreadPriority(Thread* thread, int newPriority);
    493 
    494 /* "change flags" values for raise/reset thread priority calls */
    495 #define kChangedPriority    0x01
    496 #define kChangedPolicy      0x02
    497 
    498 /*
    499  * If necessary, raise the thread's priority to nice=0 cgroup=fg.
    500  *
    501  * Returns bit flags indicating changes made (zero if nothing was done).
    502  */
    503 int dvmRaiseThreadPriorityIfNeeded(Thread* thread, int* pSavedThreadPrio,
    504     SchedPolicy* pSavedThreadPolicy);
    505 
    506 /*
    507  * Drop the thread priority to what it was before an earlier call to
    508  * dvmRaiseThreadPriorityIfNeeded().
    509  */
    510 void dvmResetThreadPriority(Thread* thread, int changeFlags,
    511     int savedThreadPrio, SchedPolicy savedThreadPolicy);
    512 
    513 /*
    514  * Debug: dump information about a single thread.
    515  */
    516 void dvmDumpThread(Thread* thread, bool isRunning);
    517 void dvmDumpThreadEx(const DebugOutputTarget* target, Thread* thread,
    518     bool isRunning);
    519 
    520 /*
    521  * Debug: dump information about all threads.
    522  */
    523 void dvmDumpAllThreads(bool grabLock);
    524 void dvmDumpAllThreadsEx(const DebugOutputTarget* target, bool grabLock);
    525 
    526 /*
    527  * Debug: kill a thread to get a debuggerd stack trace.  Leaves the VM
    528  * in an uncertain state.
    529  */
    530 void dvmNukeThread(Thread* thread);
    531 
    532 #ifdef WITH_MONITOR_TRACKING
    533 /*
    534  * Track locks held by the current thread, along with the stack trace at
    535  * the point the lock was acquired.
    536  *
    537  * At any given time the number of locks held across the VM should be
    538  * fairly small, so there's no reason not to generate and store the entire
    539  * stack trace.
    540  */
    541 typedef struct LockedObjectData {
    542     /* the locked object */
    543     struct Object*  obj;
    544 
    545     /* number of times it has been locked recursively (zero-based ref count) */
    546     int             recursionCount;
    547 
    548     /* stack trace at point of initial acquire */
    549     u4              stackDepth;
    550     int*            rawStackTrace;
    551 
    552     struct LockedObjectData* next;
    553 } LockedObjectData;
    554 
    555 /*
    556  * Add/remove/find objects from the thread's monitor list.
    557  */
    558 void dvmAddToMonitorList(Thread* self, Object* obj, bool withTrace);
    559 void dvmRemoveFromMonitorList(Thread* self, Object* obj);
    560 LockedObjectData* dvmFindInMonitorList(const Thread* self, const Object* obj);
    561 #endif
    562 
    563 #endif /*_DALVIK_THREAD*/
    564