Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 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 | |
Elliott Hughes | 8218847 | 2011-11-07 18:11:48 -0800 | [diff] [blame] | 17 | #include "debugger.h" |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 18 | #include "jni_internal.h" |
Elliott Hughes | 4cd121e | 2013-01-07 17:35:41 -0800 | [diff] [blame] | 19 | #include "monitor.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 20 | #include "mirror/object.h" |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 21 | #include "scoped_thread_state_change.h" |
Elliott Hughes | 5464308 | 2011-09-25 17:48:00 -0700 | [diff] [blame] | 22 | #include "ScopedUtfChars.h" |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 23 | #include "thread.h" |
| 24 | #include "thread_list.h" |
| 25 | |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 26 | namespace art { |
| 27 | |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 28 | static jobject Thread_currentThread(JNIEnv* env, jclass) { |
Ian Rogers | cfaa455 | 2012-11-26 21:00:08 -0800 | [diff] [blame] | 29 | ScopedObjectAccess soa(env); |
| 30 | return soa.AddLocalReference<jobject>(soa.Self()->GetPeer()); |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 31 | } |
| 32 | |
Ian Rogers | 365c102 | 2012-06-22 15:05:28 -0700 | [diff] [blame] | 33 | static jboolean Thread_interrupted(JNIEnv* env, jclass) { |
Ian Rogers | cfaa455 | 2012-11-26 21:00:08 -0800 | [diff] [blame] | 34 | return static_cast<JNIEnvExt*>(env)->self->Interrupted() ? JNI_TRUE : JNI_FALSE; |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 35 | } |
| 36 | |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 37 | static jboolean Thread_isInterrupted(JNIEnv* env, jobject java_thread) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 38 | ScopedObjectAccess soa(env); |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 39 | MutexLock mu(soa.Self(), *Locks::thread_list_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 40 | Thread* thread = Thread::FromManagedThread(soa, java_thread); |
Elliott Hughes | d369bb7 | 2011-09-12 14:41:14 -0700 | [diff] [blame] | 41 | return (thread != NULL) ? thread->IsInterrupted() : JNI_FALSE; |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 42 | } |
| 43 | |
Ian Rogers | 52673ff | 2012-06-27 23:25:34 -0700 | [diff] [blame] | 44 | static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread, jlong stack_size, |
| 45 | jboolean daemon) { |
| 46 | Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE); |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 47 | } |
| 48 | |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 49 | static jint Thread_nativeGetStatus(JNIEnv* env, jobject java_thread, jboolean has_been_started) { |
Elliott Hughes | cf2b2d4 | 2012-03-27 17:11:42 -0700 | [diff] [blame] | 50 | // Ordinals from Java's Thread.State. |
| 51 | const jint kJavaNew = 0; |
| 52 | const jint kJavaRunnable = 1; |
| 53 | const jint kJavaBlocked = 2; |
| 54 | const jint kJavaWaiting = 3; |
| 55 | const jint kJavaTimedWaiting = 4; |
| 56 | const jint kJavaTerminated = 5; |
| 57 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 58 | ScopedObjectAccess soa(env); |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 59 | ThreadState internal_thread_state = (has_been_started ? kTerminated : kStarting); |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 60 | MutexLock mu(soa.Self(), *Locks::thread_list_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 61 | Thread* thread = Thread::FromManagedThread(soa, java_thread); |
Elliott Hughes | cf2b2d4 | 2012-03-27 17:11:42 -0700 | [diff] [blame] | 62 | if (thread != NULL) { |
| 63 | internal_thread_state = thread->GetState(); |
Elliott Hughes | 8e4aac5 | 2011-09-26 17:03:36 -0700 | [diff] [blame] | 64 | } |
Elliott Hughes | cf2b2d4 | 2012-03-27 17:11:42 -0700 | [diff] [blame] | 65 | switch (internal_thread_state) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 66 | case kTerminated: return kJavaTerminated; |
| 67 | case kRunnable: return kJavaRunnable; |
| 68 | case kTimedWaiting: return kJavaTimedWaiting; |
Elliott Hughes | 4cd121e | 2013-01-07 17:35:41 -0800 | [diff] [blame] | 69 | case kSleeping: return kJavaTimedWaiting; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 70 | case kBlocked: return kJavaBlocked; |
| 71 | case kWaiting: return kJavaWaiting; |
| 72 | case kStarting: return kJavaNew; |
| 73 | case kNative: return kJavaRunnable; |
| 74 | case kWaitingForGcToComplete: return kJavaWaiting; |
| 75 | case kWaitingPerformingGc: return kJavaWaiting; |
| 76 | case kWaitingForDebuggerSend: return kJavaWaiting; |
| 77 | case kWaitingForDebuggerToAttach: return kJavaWaiting; |
| 78 | case kWaitingInMainDebuggerLoop: return kJavaWaiting; |
| 79 | case kWaitingForDebuggerSuspension: return kJavaWaiting; |
| 80 | case kWaitingForJniOnLoad: return kJavaWaiting; |
| 81 | case kWaitingForSignalCatcherOutput: return kJavaWaiting; |
| 82 | case kWaitingInMainSignalCatcherLoop: return kJavaWaiting; |
| 83 | case kSuspended: return kJavaRunnable; |
Elliott Hughes | cf2b2d4 | 2012-03-27 17:11:42 -0700 | [diff] [blame] | 84 | // Don't add a 'default' here so the compiler can spot incompatible enum changes. |
| 85 | } |
| 86 | return -1; // Unreachable. |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 87 | } |
| 88 | |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 89 | static jboolean Thread_nativeHoldsLock(JNIEnv* env, jobject java_thread, jobject java_object) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 90 | ScopedObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 91 | mirror::Object* object = soa.Decode<mirror::Object*>(java_object); |
Elliott Hughes | 5f79133 | 2011-09-15 17:45:30 -0700 | [diff] [blame] | 92 | if (object == NULL) { |
| 93 | Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "object == null"); |
| 94 | return JNI_FALSE; |
| 95 | } |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 96 | MutexLock mu(soa.Self(), *Locks::thread_list_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 97 | Thread* thread = Thread::FromManagedThread(soa, java_thread); |
Elliott Hughes | 5f79133 | 2011-09-15 17:45:30 -0700 | [diff] [blame] | 98 | return thread->HoldsLock(object); |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 99 | } |
| 100 | |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 101 | static void Thread_nativeInterrupt(JNIEnv* env, jobject java_thread) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 102 | ScopedObjectAccess soa(env); |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 103 | MutexLock mu(soa.Self(), *Locks::thread_list_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 104 | Thread* thread = Thread::FromManagedThread(soa, java_thread); |
Elliott Hughes | 5f79133 | 2011-09-15 17:45:30 -0700 | [diff] [blame] | 105 | if (thread != NULL) { |
| 106 | thread->Interrupt(); |
| 107 | } |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 108 | } |
| 109 | |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 110 | static void Thread_nativeSetName(JNIEnv* env, jobject peer, jstring java_name) { |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 111 | ScopedUtfChars name(env, java_name); |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 112 | { |
| 113 | ScopedObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 114 | if (soa.Decode<mirror::Object*>(peer) == soa.Self()->GetPeer()) { |
Mathieu Chartier | dbe6f46 | 2012-09-25 16:54:50 -0700 | [diff] [blame] | 115 | soa.Self()->SetThreadName(name.c_str()); |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 116 | return; |
| 117 | } |
Elliott Hughes | 899e789 | 2012-01-24 14:57:32 -0800 | [diff] [blame] | 118 | } |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 119 | // Suspend thread to avoid it from killing itself while we set its name. We don't just hold the |
| 120 | // thread list lock to avoid this, as setting the thread name causes mutator to lock/unlock |
| 121 | // in the DDMS send code. |
Elliott Hughes | f327e07 | 2013-01-09 16:01:26 -0800 | [diff] [blame] | 122 | bool timed_out; |
| 123 | Thread* thread = Thread::SuspendForDebugger(peer, true, &timed_out); |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 124 | if (thread != NULL) { |
| 125 | { |
| 126 | ScopedObjectAccess soa(env); |
| 127 | thread->SetThreadName(name.c_str()); |
| 128 | } |
| 129 | Runtime::Current()->GetThreadList()->Resume(thread, true); |
Elliott Hughes | f327e07 | 2013-01-09 16:01:26 -0800 | [diff] [blame] | 130 | } else if (timed_out) { |
Ian Rogers | 15bf2d3 | 2012-08-28 17:33:04 -0700 | [diff] [blame] | 131 | LOG(ERROR) << "Trying to set thread name to '" << name.c_str() << "' failed as the thread " |
| 132 | "failed to suspend within a generous timeout."; |
| 133 | } |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | /* |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 137 | * Alter the priority of the specified thread. "new_priority" will range |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 138 | * from Thread.MIN_PRIORITY to Thread.MAX_PRIORITY (1-10), with "normal" |
| 139 | * threads at Thread.NORM_PRIORITY (5). |
| 140 | */ |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 141 | static void Thread_nativeSetPriority(JNIEnv* env, jobject java_thread, jint new_priority) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 142 | ScopedObjectAccess soa(env); |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 143 | MutexLock mu(soa.Self(), *Locks::thread_list_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 144 | Thread* thread = Thread::FromManagedThread(soa, java_thread); |
Elliott Hughes | d369bb7 | 2011-09-12 14:41:14 -0700 | [diff] [blame] | 145 | if (thread != NULL) { |
Elliott Hughes | 57aba86 | 2012-06-20 14:00:47 -0700 | [diff] [blame] | 146 | thread->SetNativePriority(new_priority); |
Elliott Hughes | d369bb7 | 2011-09-12 14:41:14 -0700 | [diff] [blame] | 147 | } |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Elliott Hughes | 4cd121e | 2013-01-07 17:35:41 -0800 | [diff] [blame] | 150 | static void Thread_sleep(JNIEnv* env, jclass, jobject java_lock, jlong ms, jint ns) { |
| 151 | ScopedObjectAccess soa(env); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 152 | mirror::Object* lock = soa.Decode<mirror::Object*>(java_lock); |
Elliott Hughes | 4cd121e | 2013-01-07 17:35:41 -0800 | [diff] [blame] | 153 | Monitor::Wait(Thread::Current(), lock, ms, ns, true, kSleeping); |
| 154 | } |
| 155 | |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 156 | /* |
| 157 | * Causes the thread to temporarily pause and allow other threads to execute. |
| 158 | * |
| 159 | * The exact behavior is poorly defined. Some discussion here: |
| 160 | * http://www.cs.umd.edu/~pugh/java/memoryModel/archive/0944.html |
| 161 | */ |
Elliott Hughes | 0512f02 | 2012-03-15 22:10:52 -0700 | [diff] [blame] | 162 | static void Thread_yield(JNIEnv*, jobject) { |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 163 | sched_yield(); |
| 164 | } |
| 165 | |
| 166 | static JNINativeMethod gMethods[] = { |
| 167 | NATIVE_METHOD(Thread, currentThread, "()Ljava/lang/Thread;"), |
| 168 | NATIVE_METHOD(Thread, interrupted, "()Z"), |
| 169 | NATIVE_METHOD(Thread, isInterrupted, "()Z"), |
Ian Rogers | 52673ff | 2012-06-27 23:25:34 -0700 | [diff] [blame] | 170 | NATIVE_METHOD(Thread, nativeCreate, "(Ljava/lang/Thread;JZ)V"), |
Elliott Hughes | cf2b2d4 | 2012-03-27 17:11:42 -0700 | [diff] [blame] | 171 | NATIVE_METHOD(Thread, nativeGetStatus, "(Z)I"), |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 172 | NATIVE_METHOD(Thread, nativeHoldsLock, "(Ljava/lang/Object;)Z"), |
| 173 | NATIVE_METHOD(Thread, nativeInterrupt, "()V"), |
| 174 | NATIVE_METHOD(Thread, nativeSetName, "(Ljava/lang/String;)V"), |
| 175 | NATIVE_METHOD(Thread, nativeSetPriority, "(I)V"), |
Elliott Hughes | 4cd121e | 2013-01-07 17:35:41 -0800 | [diff] [blame] | 176 | NATIVE_METHOD(Thread, sleep, "(Ljava/lang/Object;JI)V"), |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 177 | NATIVE_METHOD(Thread, yield, "()V"), |
| 178 | }; |
| 179 | |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 180 | void register_java_lang_Thread(JNIEnv* env) { |
Elliott Hughes | eac7667 | 2012-05-24 21:56:51 -0700 | [diff] [blame] | 181 | REGISTER_NATIVE_METHODS("java/lang/Thread"); |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | } // namespace art |