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