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