1f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 2f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Copyright (C) 2008 The Android Open Source Project 3f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 4f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); 5f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * you may not use this file except in compliance with the License. 6f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * You may obtain a copy of the License at 7f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 8f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * http://www.apache.org/licenses/LICENSE-2.0 9f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 10f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Unless required by applicable law or agreed to in writing, software 11f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS, 12f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * See the License for the specific language governing permissions and 14f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * limitations under the License. 15f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 16581bed77d3596b9d7242da10867c8d4cfd382239Andy McFadden 17f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "Dalvik.h" 18f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 19f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro#include <fcntl.h> 20f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <stdlib.h> 21f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <unistd.h> 22f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <pthread.h> 23f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <time.h> 24f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <errno.h> 25f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 26f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 27f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Every Object has a monitor associated with it, but not every Object is 28f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * actually locked. Even the ones that are locked do not need a 29f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * full-fledged monitor until a) there is actual contention or b) wait() 30f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is called on the Object. 31f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 32f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * For Dalvik, we have implemented a scheme similar to the one described 33f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in Bacon et al.'s "Thin locks: featherweight synchronization for Java" 34f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (ACM 1998). Things are even easier for us, though, because we have 35f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a full 32 bits to work with. 36f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 3794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * The two states of an Object's lock are referred to as "thin" and 3894338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * "fat". A lock may transition from the "thin" state to the "fat" 3994338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * state and this transition is referred to as inflation. Once a lock 4094338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * has been inflated it remains in the "fat" state indefinitely. 41f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 4277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * The lock value itself is stored in Object.lock. The LSB of the 4377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * lock encodes its state. When cleared, the lock is in the "thin" 4477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * state and its bits are formatted as follows: 4571938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro * 4694338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * [31 ---- 19] [18 ---- 3] [2 ---- 1] [0] 4794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * lock count thread id hash state 0 48f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 4977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * When set, the lock is in the "fat" state and its bits are formatted 5094338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * as follows: 51f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 5294338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * [31 ---- 3] [2 ---- 1] [0] 5394338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * pointer hash state 1 54f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 55f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * For an in-depth description of the mechanics of thin-vs-fat locking, 56f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * read the paper referred to above. 57f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 58f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 59f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 60f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Monitors provide: 61f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - mutually exclusive access to resources 62f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - a way for multiple threads to wait for notification 63f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 64f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * In effect, they fill the role of both mutexes and condition variables. 65f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 66f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Only one thread can own the monitor at any time. There may be several 67f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * threads waiting on it (the wait call unlocks it). One or more waiting 68f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * threads may be getting interrupted or notified at any given time. 69fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro * 70fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro * TODO: the various members of monitor are not SMP-safe. 71f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 72f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstruct Monitor { 73f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* owner; /* which thread currently owns the lock? */ 74f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int lockCount; /* owner's recursive lock depth */ 75f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object* obj; /* what object are we part of [debug only] */ 76f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 7777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread* waitSet; /* threads currently waiting on this monitor */ 78f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 79f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pthread_mutex_t lock; 80f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 81f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* next; 82f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 83fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro /* 84fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro * Who last acquired this monitor, when lock sampling is enabled. 859d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes * Even when enabled, ownerMethod may be NULL. 86fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro */ 879d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes const Method* ownerMethod; 889d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes u4 ownerPc; 89f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project}; 90f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 91f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 92f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 93f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Create and initialize a monitor. 94f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 95f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectMonitor* dvmCreateMonitor(Object* obj) 96f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 97f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 98f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 99f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = (Monitor*) calloc(1, sizeof(Monitor)); 100f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon == NULL) { 101c1a4ab9c313d8a3d12007f2dbef7b5a6fa4ac2efSteve Block ALOGE("Unable to allocate monitor"); 102f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAbort(); 103f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 104f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->obj = obj; 105f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmInitMutex(&mon->lock); 106f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 107f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* replace the head of the list with the new monitor */ 108f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project do { 109f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->next = gDvm.monitorList; 1106e10b9aaa72425a4825a25f0043533d0c6fdbba4Andy McFadden } while (android_atomic_release_cas((int32_t)mon->next, (int32_t)mon, 1116e10b9aaa72425a4825a25f0043533d0c6fdbba4Andy McFadden (int32_t*)(void*)&gDvm.monitorList) != 0); 112f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 113f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return mon; 114f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 115f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 116f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 117f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Free the monitor list. Only used when shutting the VM down. 118f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1191e1433e78f560a01744e870c19c162ab88df9dc1Carl Shapirovoid dvmFreeMonitorList() 120f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 121f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 122f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* nextMon; 123f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 124f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = gDvm.monitorList; 125f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project while (mon != NULL) { 126f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project nextMon = mon->next; 127f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project free(mon); 128f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = nextMon; 129f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 130f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 131f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 132f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 133f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Get the object that a monitor is part of. 134f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 135f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectObject* dvmGetMonitorObject(Monitor* mon) 136f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 137f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon == NULL) 138f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return NULL; 139f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 140f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return mon->obj; 141f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 142f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 143f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 14430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Returns the thread id of the thread owning the given lock. 14530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 14630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapirostatic u4 lockOwner(Object* obj) 14730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro{ 14830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro Thread *owner; 14930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro u4 lock; 15030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 15130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(obj != NULL); 15230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 15330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Since we're reading the lock value multiple times, latch it so 15430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * that it doesn't change out from under us if we get preempted. 15530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 15630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lock = obj->lock; 15730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (LW_SHAPE(lock) == LW_SHAPE_THIN) { 15830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return LW_LOCK_OWNER(lock); 15930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 16030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro owner = LW_MONITOR(lock)->owner; 16130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return owner ? owner->threadId : 0; 16230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 16330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro} 16430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 16530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro/* 166fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden * Get the thread that holds the lock on the specified object. The 167fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden * object may be unlocked, thin-locked, or fat-locked. 168fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden * 169fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden * The caller must lock the thread list before calling here. 170fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden */ 171fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFaddenThread* dvmGetObjectLockHolder(Object* obj) 172fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden{ 173fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden u4 threadId = lockOwner(obj); 174fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden 175fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden if (threadId == 0) 176fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden return NULL; 177fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden return dvmGetThreadByThreadId(threadId); 178fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden} 179fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden 180fd54266907c3046339b48748f63afa32ee3ab4e1Andy McFadden/* 181f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Checks whether the given thread holds the given 182f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * objects's lock. 183f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 184f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool dvmHoldsLock(Thread* thread, Object* obj) 185f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 186f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (thread == NULL || obj == NULL) { 187f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 188f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 18930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return thread->threadId == lockOwner(obj); 190f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 191f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 192f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 193f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 194f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Free the monitor associated with an object and make the object's lock 195f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * thin again. This is called during garbage collection. 196f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1978bb6104795c7b31abf76ae4325b416d6c1caa17fCarl Shapirostatic void freeMonitor(Monitor *mon) 198f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1998bb6104795c7b31abf76ae4325b416d6c1caa17fCarl Shapiro assert(mon != NULL); 2008bb6104795c7b31abf76ae4325b416d6c1caa17fCarl Shapiro assert(mon->obj != NULL); 2018bb6104795c7b31abf76ae4325b416d6c1caa17fCarl Shapiro assert(LW_SHAPE(mon->obj->lock) == LW_SHAPE_FAT); 202f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 203f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* This lock is associated with an object 204f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * that's being swept. The only possible way 205f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * anyone could be holding this lock would be 206f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * if some JNI code locked but didn't unlock 207f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the object, in which case we've got some bad 208f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * native code somewhere. 209f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 2101ff876da3c8316ebe4a39e29b5db697953421511Carl Shapiro assert(pthread_mutex_trylock(&mon->lock) == 0); 2111ff876da3c8316ebe4a39e29b5db697953421511Carl Shapiro assert(pthread_mutex_unlock(&mon->lock) == 0); 212980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmDestroyMutex(&mon->lock); 2135a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro free(mon); 214f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 215f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 2165a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro/* 2175a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro * Frees monitor objects belonging to unmarked objects. 2185a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro */ 2195a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapirovoid dvmSweepMonitorList(Monitor** mon, int (*isUnmarkedObject)(void*)) 2205a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro{ 2215a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro Monitor handle; 2225a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro Monitor *prev, *curr; 2235a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro Object *obj; 2245a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro 2255a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro assert(mon != NULL); 2265a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro assert(isUnmarkedObject != NULL); 2275a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro prev = &handle; 2285a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro prev->next = curr = *mon; 2295a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro while (curr != NULL) { 2305a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro obj = curr->obj; 2315a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro if (obj != NULL && (*isUnmarkedObject)(obj) != 0) { 2328bb6104795c7b31abf76ae4325b416d6c1caa17fCarl Shapiro prev->next = curr->next; 2338bb6104795c7b31abf76ae4325b416d6c1caa17fCarl Shapiro freeMonitor(curr); 2348bb6104795c7b31abf76ae4325b416d6c1caa17fCarl Shapiro curr = prev->next; 2355a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro } else { 2365a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro prev = curr; 2375a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro curr = curr->next; 2385a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro } 2395a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro } 2405a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro *mon = handle.next; 2415a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro} 242f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 243f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapirostatic char *logWriteInt(char *dst, int value) 244f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro{ 245f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro *dst++ = EVENT_TYPE_INT; 246f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro set4LE((u1 *)dst, value); 247f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro return dst + 4; 248f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro} 249f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 250f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapirostatic char *logWriteString(char *dst, const char *value, size_t len) 251f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro{ 252f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro *dst++ = EVENT_TYPE_STRING; 253af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro len = len < 32 ? len : 32; 254f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro set4LE((u1 *)dst, len); 255f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro dst += 4; 256f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro memcpy(dst, value, len); 257f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro return dst + len; 258f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro} 259f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 260af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro#define EVENT_LOG_TAG_dvm_lock_sample 20003 261f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 262fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapirostatic void logContentionEvent(Thread *self, u4 waitMs, u4 samplePercent, 263fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro const char *ownerFileName, u4 ownerLineNumber) 264f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro{ 265f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro const StackSaveArea *saveArea; 266f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro const Method *meth; 267f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro u4 relativePc; 268fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro char eventBuffer[174]; 269f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro const char *fileName; 270708f143f318bb2167c810f9506102f4ad656545cElliott Hughes char procName[33]; 271f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro char *cp; 272af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro size_t len; 273af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro int fd; 274f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 2758c9441fdbb1ac31c3eca2fb047629476daaa6490Mattias Petersson /* When a thread is being destroyed it is normal that the frame depth is zero */ 2768c9441fdbb1ac31c3eca2fb047629476daaa6490Mattias Petersson if (self->interpSave.curFrame == NULL) { 2778c9441fdbb1ac31c3eca2fb047629476daaa6490Mattias Petersson return; 2788c9441fdbb1ac31c3eca2fb047629476daaa6490Mattias Petersson } 2798c9441fdbb1ac31c3eca2fb047629476daaa6490Mattias Petersson 28030bc0d46ae730d78c42c39cfa56a59ba3025380bbuzbee saveArea = SAVEAREA_FROM_FP(self->interpSave.curFrame); 281f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro meth = saveArea->method; 282f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro cp = eventBuffer; 283f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 284f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro /* Emit the event list length, 1 byte. */ 285fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro *cp++ = 9; 286f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 287f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro /* Emit the process name, <= 37 bytes. */ 288f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro fd = open("/proc/self/cmdline", O_RDONLY); 289af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro memset(procName, 0, sizeof(procName)); 290af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro read(fd, procName, sizeof(procName) - 1); 291f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro close(fd); 292af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro len = strlen(procName); 293af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro cp = logWriteString(cp, procName, len); 294f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 2953b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick /* Emit the sensitive thread ("main thread") status, 5 bytes. */ 2963b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick bool isSensitive = false; 2973b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick if (gDvm.isSensitiveThreadHook != NULL) { 2983b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick isSensitive = gDvm.isSensitiveThreadHook(); 2993b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick } 3003b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick cp = logWriteInt(cp, isSensitive); 301f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 302f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro /* Emit self thread name string, <= 37 bytes. */ 303708f143f318bb2167c810f9506102f4ad656545cElliott Hughes std::string selfName = dvmGetThreadName(self); 304708f143f318bb2167c810f9506102f4ad656545cElliott Hughes cp = logWriteString(cp, selfName.c_str(), selfName.size()); 305f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 306f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro /* Emit the wait time, 5 bytes. */ 307f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro cp = logWriteInt(cp, waitMs); 308f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 309f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro /* Emit the source code file name, <= 37 bytes. */ 310f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro fileName = dvmGetMethodSourceFile(meth); 311f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro if (fileName == NULL) fileName = ""; 312f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro cp = logWriteString(cp, fileName, strlen(fileName)); 313f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 314f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro /* Emit the source code line number, 5 bytes. */ 315f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro relativePc = saveArea->xtra.currentPc - saveArea->method->insns; 316f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro cp = logWriteInt(cp, dvmLineNumFromPC(meth, relativePc)); 317f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 318fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro /* Emit the lock owner source code file name, <= 37 bytes. */ 319fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro if (ownerFileName == NULL) { 3203b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick ownerFileName = ""; 321fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro } else if (strcmp(fileName, ownerFileName) == 0) { 3223b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick /* Common case, so save on log space. */ 3233b55675a442a173eb1337ba3c5866cd30cefb504Brad Fitzpatrick ownerFileName = "-"; 324fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro } 325fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro cp = logWriteString(cp, ownerFileName, strlen(ownerFileName)); 326fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro 327fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro /* Emit the source code line number, 5 bytes. */ 328fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro cp = logWriteInt(cp, ownerLineNumber); 329fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro 330f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro /* Emit the sample percentage, 5 bytes. */ 331f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro cp = logWriteInt(cp, samplePercent); 332f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 333f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro assert((size_t)(cp - eventBuffer) <= sizeof(eventBuffer)); 334af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro android_btWriteLog(EVENT_LOG_TAG_dvm_lock_sample, 335f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro EVENT_TYPE_LIST, 336f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro eventBuffer, 337f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro (size_t)(cp - eventBuffer)); 338f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro} 339f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro 340f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 341f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Lock a monitor. 342f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 343f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void lockMonitor(Thread* self, Monitor* mon) 344f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 345f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro ThreadStatus oldStatus; 346f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro u4 waitThreshold, samplePercent; 347f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro u8 waitStart, waitEnd, waitMs; 348f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 349f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->owner == self) { 350f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount++; 351f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro return; 352f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro } 353045fdc99f7c0dfde95002da66cb85ace19aee069Carl Shapiro if (dvmTryLockMutex(&mon->lock) != 0) { 354f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro oldStatus = dvmChangeStatus(self, THREAD_MONITOR); 355f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro waitThreshold = gDvm.lockProfThreshold; 356f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro if (waitThreshold) { 357f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro waitStart = dvmGetRelativeTimeUsec(); 358f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro } 3599d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes 3609d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes const Method* currentOwnerMethod = mon->ownerMethod; 3619d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes u4 currentOwnerPc = mon->ownerPc; 362fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro 363f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro dvmLockMutex(&mon->lock); 364f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro if (waitThreshold) { 365f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro waitEnd = dvmGetRelativeTimeUsec(); 366f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro } 367f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro dvmChangeStatus(self, oldStatus); 368f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro if (waitThreshold) { 369f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro waitMs = (waitEnd - waitStart) / 1000; 370f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro if (waitMs >= waitThreshold) { 371f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro samplePercent = 100; 372f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro } else { 373af69cf8d062a42300852ddee6bcb9f189f5a1b83Carl Shapiro samplePercent = 100 * waitMs / waitThreshold; 374f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro } 375b8fcf57f13b4d37950cfbd72a6af401941d7bdd8Carl Shapiro if (samplePercent != 0 && ((u4)rand() % 100 < samplePercent)) { 3769d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes const char* currentOwnerFileName = "no_method"; 3779d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes u4 currentOwnerLineNumber = 0; 3789d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes if (currentOwnerMethod != NULL) { 3799d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes currentOwnerFileName = dvmGetMethodSourceFile(currentOwnerMethod); 3809d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes if (currentOwnerFileName == NULL) { 3819d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes currentOwnerFileName = "no_method_file"; 3829d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes } 3839d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes currentOwnerLineNumber = dvmLineNumFromPC(currentOwnerMethod, currentOwnerPc); 3849d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes } 385fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro logContentionEvent(self, waitMs, samplePercent, 386fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro currentOwnerFileName, currentOwnerLineNumber); 387f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro } 388f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 389f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 390f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro mon->owner = self; 391f0c514ce8c64a441375af4a7e364282a3d803c45Carl Shapiro assert(mon->lockCount == 0); 392fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro 393fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro // When debugging, save the current monitor holder for future 394fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro // acquisition failures to use in sampled logging. 395fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro if (gDvm.lockProfThreshold > 0) { 3969d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerMethod = NULL; 3979d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerPc = 0; 39830bc0d46ae730d78c42c39cfa56a59ba3025380bbuzbee if (self->interpSave.curFrame == NULL) { 3999d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes return; 4009d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes } 4019d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes const StackSaveArea* saveArea = SAVEAREA_FROM_FP(self->interpSave.curFrame); 4029d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes if (saveArea == NULL) { 4039d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes return; 404fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro } 4059d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerMethod = saveArea->method; 4069d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerPc = (saveArea->xtra.currentPc - saveArea->method->insns); 407fa903b348ea1ba0ba121ccc3b34927f88e4353b1Carl Shapiro } 408f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 409f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 410f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 411f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Try to lock a monitor. 412f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 413f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns "true" on success. 414f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 415b31b30131bbf58280a515c40027aa958b81b5cd6Carl Shapiro#ifdef WITH_COPYING_GC 416f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool tryLockMonitor(Thread* self, Monitor* mon) 417f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 418f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->owner == self) { 419f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount++; 420f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 421f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 422980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro if (dvmTryLockMutex(&mon->lock) == 0) { 423f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = self; 424f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(mon->lockCount == 0); 425f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 426f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 427f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 428f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 429f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 430f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 431b31b30131bbf58280a515c40027aa958b81b5cd6Carl Shapiro#endif 432f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 433f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 434f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Unlock a monitor. 435f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 436f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns true if the unlock succeeded. 437f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If the unlock failed, an exception will be pending. 438f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 439f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool unlockMonitor(Thread* self, Monitor* mon) 440f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 44177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(self != NULL); 4429227708d5de03fd72c8a99e3dd2747934591ba5bCarl Shapiro assert(mon != NULL); 443f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->owner == self) { 444f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 445f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We own the monitor, so nobody else can be in here. 446f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 447f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->lockCount == 0) { 448f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = NULL; 4499d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerMethod = NULL; 4509d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerPc = 0; 451980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&mon->lock); 452f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 453f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount--; 454f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 455f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 456f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 457f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We don't own this, so we're not allowed to unlock it. 458f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The JNI spec says that we should throw IllegalMonitorStateException 459f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in this case. 460f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 461d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException("unlock of unowned monitor"); 462f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 463f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 464f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 465f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 466f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 467f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 46877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * Checks the wait set for circular structure. Returns 0 if the list 469b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro * is not circular. Otherwise, returns 1. Used only by asserts. 47077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 471b31b30131bbf58280a515c40027aa958b81b5cd6Carl Shapiro#ifndef NDEBUG 47277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirostatic int waitSetCheck(Monitor *mon) 47377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 47477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread *fast, *slow; 47577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro size_t n; 47677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 47777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(mon != NULL); 47877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro fast = slow = mon->waitSet; 47977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro n = 0; 48077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro for (;;) { 48177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (fast == NULL) return 0; 48277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (fast->waitNext == NULL) return 0; 4835f56e67999c67861872c27097803d2126142fed4Carl Shapiro if (fast == slow && n > 0) return 1; 48477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro n += 2; 48577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro fast = fast->waitNext->waitNext; 48677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro slow = slow->waitNext; 48777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 48877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 489b31b30131bbf58280a515c40027aa958b81b5cd6Carl Shapiro#endif 49077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 49177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro/* 49230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Links a thread into a monitor's wait set. The monitor lock must be 49330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * held by the caller of this routine. 49477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 49577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirostatic void waitSetAppend(Monitor *mon, Thread *thread) 49677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 49777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread *elt; 49877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 49977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(mon != NULL); 50030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(mon->owner == dvmThreadSelf()); 50177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread != NULL); 50277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread->waitNext == NULL); 50377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(waitSetCheck(mon) == 0); 50477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (mon->waitSet == NULL) { 50577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread; 50677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 50777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 50877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = mon->waitSet; 50977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro while (elt->waitNext != NULL) { 51077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = elt->waitNext; 51177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 51277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt->waitNext = thread; 51377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 51477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 51577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro/* 51630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Unlinks a thread from a monitor's wait set. The monitor lock must 51730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * be held by the caller of this routine. 51877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 51977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirostatic void waitSetRemove(Monitor *mon, Thread *thread) 52077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 52177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread *elt; 52277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 52377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(mon != NULL); 52430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(mon->owner == dvmThreadSelf()); 52577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread != NULL); 52677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(waitSetCheck(mon) == 0); 52777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (mon->waitSet == NULL) { 52877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 52977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 53077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (mon->waitSet == thread) { 53177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread->waitNext; 53277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 53377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 53477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 53577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = mon->waitSet; 53677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro while (elt->waitNext != NULL) { 53777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (elt->waitNext == thread) { 53877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt->waitNext = thread->waitNext; 53977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 54077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 54177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 54277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = elt->waitNext; 54377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 54477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 54577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 546b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro/* 547b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro * Converts the given relative waiting time into an absolute time. 548b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro */ 549953a0ed4e507fd6e756aa3e5c671bee80d7e9b3eAndy McFaddenstatic void absoluteTime(s8 msec, s4 nsec, struct timespec *ts) 55077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 55177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro s8 endSec; 55277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 55377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro#ifdef HAVE_TIMEDWAIT_MONOTONIC 55477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro clock_gettime(CLOCK_MONOTONIC, ts); 55577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro#else 55677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro { 55777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro struct timeval tv; 55877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro gettimeofday(&tv, NULL); 55977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_sec = tv.tv_sec; 56077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_nsec = tv.tv_usec * 1000; 56177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 56277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro#endif 56377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro endSec = ts->tv_sec + msec / 1000; 56477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (endSec >= 0x7fffffff) { 56592c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block ALOGV("NOTE: end time exceeds epoch"); 56677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro endSec = 0x7ffffffe; 56777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 56877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_sec = endSec; 56977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_nsec = (ts->tv_nsec + (msec % 1000) * 1000000) + nsec; 57077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 57177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* catch rollover */ 57277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (ts->tv_nsec >= 1000000000L) { 57377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_sec++; 57477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_nsec -= 1000000000L; 57577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 57677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 57777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 578fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbeeint dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex, 579fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee s8 msec, s4 nsec) 580fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee{ 581fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee int ret; 582fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee struct timespec ts; 583fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee absoluteTime(msec, nsec, &ts); 584fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee#if defined(HAVE_TIMEDWAIT_MONOTONIC) 585fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee ret = pthread_cond_timedwait_monotonic(cond, mutex, &ts); 586fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee#else 587fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee ret = pthread_cond_timedwait(cond, mutex, &ts); 588fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee#endif 589fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee assert(ret == 0 || ret == ETIMEDOUT); 590fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee return ret; 591fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee} 592fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee 59377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro/* 594f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Wait on a monitor until timeout, interrupt, or notification. Used for 595f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.wait() and (somewhat indirectly) Thread.sleep() and Thread.join(). 596f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 597f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If another thread calls Thread.interrupt(), we throw InterruptedException 598f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * and return immediately if one of the following are true: 599f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - blocked in wait(), wait(long), or wait(long, int) methods of Object 600f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - blocked in join(), join(long), or join(long, int) methods of Thread 601f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - blocked in sleep(long), or sleep(long, int) methods of Thread 602f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Otherwise, we set the "interrupted" flag. 603f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 604f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Checks to make sure that "nsec" is in the range 0-999999 605f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (i.e. fractions of a millisecond) and throws the appropriate 606f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * exception if it isn't. 607f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 608f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The spec allows "spurious wakeups", and recommends that all code using 609f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.wait() do so in a loop. This appears to derive from concerns 610f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * about pthread_cond_wait() on multiprocessor systems. Some commentary 611f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * on the web casts doubt on whether these can/should occur. 612f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 613f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Since we're allowed to wake up "early", we clamp extremely long durations 614f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * to return at the end of the 32-bit time epoch. 615f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 616f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void waitMonitor(Thread* self, Monitor* mon, s8 msec, s4 nsec, 617f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool interruptShouldThrow) 618f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 619f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project struct timespec ts; 620f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool wasInterrupted = false; 621f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool timed; 62277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro int ret; 623f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 62471938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(self != NULL); 62571938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(mon != NULL); 62671938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro 62794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro /* Make sure that we hold the lock. */ 62871938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro if (mon->owner != self) { 629d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException( 630f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before wait()"); 631f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 632f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 633f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 634f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 635f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Enforce the timeout range. 636f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 637f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (msec < 0 || nsec < 0 || nsec > 999999) { 638d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalArgumentException("timeout arguments out of range"); 639f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 640f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 641f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 642f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 643f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Compute absolute wakeup time, if necessary. 644f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 645f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (msec == 0 && nsec == 0) { 646f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project timed = false; 647f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 648fccb31dd58e5cb9f7a3f6e128d481f0ff35a51f0Bill Buzbee absoluteTime(msec, nsec, &ts); 649f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project timed = true; 650f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 651f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 652f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 653f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Add ourselves to the set of threads waiting on this monitor, and 654f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * release our hold. We need to let it go even if we're a few levels 655f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * deep in a recursive lock, and we need to restore that later. 656f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 657142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * We append to the wait set ahead of clearing the count and owner 658142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * fields so the subroutine can check that the calling thread owns 659142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * the monitor. Aside from that, the order of member updates is 660142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * not order sensitive as we hold the pthread mutex. 661f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 662142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro waitSetAppend(mon, self); 663142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro int prevLockCount = mon->lockCount; 664f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount = 0; 665f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = NULL; 6669d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes 6679d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes const Method* savedMethod = mon->ownerMethod; 6689d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes u4 savedPc = mon->ownerPc; 6699d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerMethod = NULL; 6709d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerPc = 0; 671f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 672f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 673f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Update thread status. If the GC wakes up, it'll ignore us, knowing 674f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * that we won't touch any references in this state, and we'll check 675f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * our suspend mode before we transition out. 676f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 677f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (timed) 678f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmChangeStatus(self, THREAD_TIMED_WAIT); 679f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 680f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmChangeStatus(self, THREAD_WAIT); 681f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 682980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmLockMutex(&self->waitMutex); 68377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 684f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 68577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * Set waitMonitor to the monitor object we will be waiting on. 68677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * When waitMonitor is non-NULL a notifying or interrupting thread 68777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * must signal the thread's waitCond to wake it up. 688f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 68977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(self->waitMonitor == NULL); 690f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->waitMonitor = mon; 691f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 692f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 693f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Handle the case where the thread was interrupted before we called 694f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * wait(). 695f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 696f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (self->interrupted) { 697f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project wasInterrupted = true; 69877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro self->waitMonitor = NULL; 699980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&self->waitMutex); 700f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project goto done; 701f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 702f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 70377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* 70477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * Release the monitor lock and wait for a notification or 70577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * a timeout to occur. 70677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 707980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&mon->lock); 70877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 70977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (!timed) { 71077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ret = pthread_cond_wait(&self->waitCond, &self->waitMutex); 71177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(ret == 0); 71277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } else { 713f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef HAVE_TIMEDWAIT_MONOTONIC 71477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ret = pthread_cond_timedwait_monotonic(&self->waitCond, &self->waitMutex, &ts); 715f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#else 71677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ret = pthread_cond_timedwait(&self->waitCond, &self->waitMutex, &ts); 717f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 71877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(ret == 0 || ret == ETIMEDOUT); 71977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 72077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (self->interrupted) { 72177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro wasInterrupted = true; 722f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 723f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 72477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro self->interrupted = false; 72577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro self->waitMonitor = NULL; 72677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 727980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&self->waitMutex); 72877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 72930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* Reacquire the monitor lock. */ 73077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro lockMonitor(self, mon); 731f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 732142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapirodone: 733f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 73407b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * We remove our thread from wait set after restoring the count 73507b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * and owner fields so the subroutine can check that the calling 73607b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * thread owns the monitor. Aside from that, the order of member 73707b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * updates is not order sensitive as we hold the pthread mutex. 738f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 739f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = self; 740f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount = prevLockCount; 7419d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerMethod = savedMethod; 7429d420d4ed7b9e5315bc4e4248cef42034ec47530Elliott Hughes mon->ownerPc = savedPc; 74307b359273a838a15accafefcbe861be15caaac3aCarl Shapiro waitSetRemove(mon, self); 744f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 745f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* set self->status back to THREAD_RUNNING, and self-suspend if needed */ 746f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmChangeStatus(self, THREAD_RUNNING); 747f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 748f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (wasInterrupted) { 749f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 750f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We were interrupted while waiting, or somebody interrupted an 75130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * un-interruptible thread earlier and we're bailing out immediately. 752f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 753f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The doc sayeth: "The interrupted status of the current thread is 754f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * cleared when this exception is thrown." 755f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 756f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->interrupted = false; 757d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein if (interruptShouldThrow) { 758d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowInterruptedException(NULL); 759d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein } 760f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 761f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 762f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 763f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 764f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Notify one thread waiting on this monitor. 765f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 766f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void notifyMonitor(Thread* self, Monitor* mon) 767f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 76877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread* thread; 76977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 77071938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(self != NULL); 77171938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(mon != NULL); 77271938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro 77394338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro /* Make sure that we hold the lock. */ 77471938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro if (mon->owner != self) { 775d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException( 776f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notify()"); 777f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 778f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 77930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* Signal the first waiting thread in the wait set. */ 78030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro while (mon->waitSet != NULL) { 78177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread = mon->waitSet; 78277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread->waitNext; 78377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 784980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmLockMutex(&thread->waitMutex); 78577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* Check to see if the thread is still waiting. */ 78677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->waitMonitor != NULL) { 78777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_cond_signal(&thread->waitCond); 788980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&thread->waitMutex); 78930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return; 79077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 791980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&thread->waitMutex); 792f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 793f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 794f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 795f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 796f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Notify all threads waiting on this monitor. 797f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 798f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void notifyAllMonitor(Thread* self, Monitor* mon) 799f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 80077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread* thread; 80177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 80271938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(self != NULL); 80371938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(mon != NULL); 80471938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro 80594338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro /* Make sure that we hold the lock. */ 80671938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro if (mon->owner != self) { 807d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException( 808f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notifyAll()"); 809f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 810f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 81177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* Signal all threads in the wait set. */ 81277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro while (mon->waitSet != NULL) { 81377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread = mon->waitSet; 81477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread->waitNext; 81577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 816980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmLockMutex(&thread->waitMutex); 81777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* Check to see if the thread is still waiting. */ 81877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->waitMonitor != NULL) { 81977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_cond_signal(&thread->waitCond); 82077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 821980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&thread->waitMutex); 822f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 823f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 824f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 825f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 82666bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro * Changes the shape of a monitor from thin to fat, preserving the 82766bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro * internal lock state. The calling thread must own the lock. 82866bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro */ 82966bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapirostatic void inflateMonitor(Thread *self, Object *obj) 83066bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro{ 83166bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro Monitor *mon; 83266bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro u4 thin; 83366bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro 83466bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro assert(self != NULL); 83566bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro assert(obj != NULL); 83666bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro assert(LW_SHAPE(obj->lock) == LW_SHAPE_THIN); 83766bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro assert(LW_LOCK_OWNER(obj->lock) == self->threadId); 83866bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro /* Allocate and acquire a new monitor. */ 83966bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro mon = dvmCreateMonitor(obj); 84066bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro lockMonitor(self, mon); 84166bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro /* Propagate the lock state. */ 84266bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro thin = obj->lock; 84366bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro mon->lockCount = LW_LOCK_COUNT(thin); 84466bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro thin &= LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT; 84566bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro thin |= (u4)mon | LW_SHAPE_FAT; 84666bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro /* Publish the updated lock word. */ 8474ba5672a3d33ff8aaf45e2ae8371e18fe30d469bCarl Shapiro android_atomic_release_store(thin, (int32_t *)&obj->lock); 84866bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro} 84966bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro 85066bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro/* 851f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Implements monitorenter for "synchronized" stuff. 852f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 853f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This does not fail or throw an exception (unless deadlock prediction 854f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is enabled and set to "err" mode). 855f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 856f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmLockObject(Thread* self, Object *obj) 857f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 858147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro volatile u4 *thinp; 859147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro ThreadStatus oldStatus; 86016a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro struct timespec tm; 86116a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro long sleepDelayNs; 86216a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro long minSleepDelayNs = 1000000; /* 1 millisecond */ 86316a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro long maxSleepDelayNs = 1000000000; /* 1 second */ 864147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro u4 thin, newThin, threadId; 865f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 866147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro assert(self != NULL); 867147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro assert(obj != NULL); 868147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro threadId = self->threadId; 869147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thinp = &obj->lock; 870147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiroretry: 871147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin = *thinp; 872147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 873147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 874147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is a thin lock. The owner field is used to 875147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * determine the acquire method, ordered by cost. 876f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 877147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_LOCK_OWNER(thin) == threadId) { 878147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 879147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The calling thread owns the lock. Increment the 880147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * value of the recursion count field. 881f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 882147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro obj->lock += 1 << LW_LOCK_COUNT_SHIFT; 883f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro if (LW_LOCK_COUNT(obj->lock) == LW_LOCK_COUNT_MASK) { 884f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro /* 885f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro * The reacquisition limit has been reached. Inflate 886f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro * the lock so the next acquire will not overflow the 887f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro * recursion count field. 888f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro */ 889f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro inflateMonitor(self, obj); 890f3cfbbf80364d4d15b722afb48637dffba73fb3cCarl Shapiro } 891147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else if (LW_LOCK_OWNER(thin) == 0) { 892147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 893147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is unowned. Install the thread id of the 894147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * calling thread into the owner field. This is the 895147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * common case. In performance critical code the JIT 896147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * will have tried this before calling out to the VM. 897f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 898147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT); 8993ba10c9932db4c7c9546081ea070c73d5001c168Carl Shapiro if (android_atomic_acquire_cas(thin, newThin, 9006e10b9aaa72425a4825a25f0043533d0c6fdbba4Andy McFadden (int32_t*)thinp) != 0) { 901147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 902147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The acquire failed. Try again. 903f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 904147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro goto retry; 905147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } 906147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 90792c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block ALOGV("(%d) spin on lock %p: %#x (%#x) %#x", 9089eb7b297a4e78b749654ae235649a25d776941c5Carl Shapiro threadId, &obj->lock, 0, *thinp, thin); 909147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 910147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is owned by another thread. Notify the VM 911147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * that we are about to wait. 912147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 913147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro oldStatus = dvmChangeStatus(self, THREAD_MONITOR); 914147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 915147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Spin until the thin lock is released or inflated. 916147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 91716a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro sleepDelayNs = 0; 918147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro for (;;) { 919147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin = *thinp; 920147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 921147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Check the shape of the lock word. Another thread 922147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * may have inflated the lock while we were waiting. 923f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 924147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 925147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_LOCK_OWNER(thin) == 0) { 926147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 927147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock has been released. Install the 928147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * thread id of the calling thread into the 929147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * owner field. 930147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 931147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT); 9323ba10c9932db4c7c9546081ea070c73d5001c168Carl Shapiro if (android_atomic_acquire_cas(thin, newThin, 9336e10b9aaa72425a4825a25f0043533d0c6fdbba4Andy McFadden (int32_t *)thinp) == 0) { 934147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 935147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The acquire succeed. Break out of the 936147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * loop and proceed to inflate the lock. 937f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 938147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro break; 939f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 940147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 941147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 942147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock has not been released. Yield so 943147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * the owning thread can run. 944147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 94516a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro if (sleepDelayNs == 0) { 946f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project sched_yield(); 94716a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro sleepDelayNs = minSleepDelayNs; 948f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 94916a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro tm.tv_sec = 0; 95016a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro tm.tv_nsec = sleepDelayNs; 95116a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro nanosleep(&tm, NULL); 95216a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro /* 95316a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro * Prepare the next delay value. Wrap to 95416a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro * avoid once a second polls for eternity. 95516a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro */ 95616a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro if (sleepDelayNs < maxSleepDelayNs / 2) { 95716a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro sleepDelayNs *= 2; 95816a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro } else { 95916a832c08f9ad2d74657b3fed5810fb1aeec3adcCarl Shapiro sleepDelayNs = minSleepDelayNs; 960f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 961f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 962f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 963147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 964147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 965147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The thin lock was inflated by another thread. 966147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Let the VM know we are no longer waiting and 967147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * try again. 968147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 96992c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block ALOGV("(%d) lock %p surprise-fattened", 970147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro threadId, &obj->lock); 971147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro dvmChangeStatus(self, oldStatus); 972147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro goto retry; 973147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } 974f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 97592c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block ALOGV("(%d) spin on lock done %p: %#x (%#x) %#x", 9769eb7b297a4e78b749654ae235649a25d776941c5Carl Shapiro threadId, &obj->lock, 0, *thinp, thin); 977147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 978147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * We have acquired the thin lock. Let the VM know that 979147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * we are no longer waiting. 980147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 981147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro dvmChangeStatus(self, oldStatus); 982147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 983147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Fatten the lock. 984f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 98566bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro inflateMonitor(self, obj); 98692c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block ALOGV("(%d) lock %p fattened", threadId, &obj->lock); 987f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 988147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 989147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 990147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is a fat lock. 991147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 992147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro assert(LW_MONITOR(obj->lock) != NULL); 993147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro lockMonitor(self, LW_MONITOR(obj->lock)); 994f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 995f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 996f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 997f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 998f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Implements monitorexit for "synchronized" stuff. 999f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1000f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * On failure, throws an exception and returns "false". 1001f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1002f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool dvmUnlockObject(Thread* self, Object *obj) 1003f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 100494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro u4 thin; 1005f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1006ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro assert(self != NULL); 1007ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro assert(self->status == THREAD_RUNNING); 1008ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro assert(obj != NULL); 1009ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1010ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * Cache the lock word as its value can change while we are 1011ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * examining its state. 1012f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1013f28000dc9b6f596921b1a4387746bea4c8cd207fCarl Shapiro thin = *(volatile u4 *)&obj->lock; 1014ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 1015ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1016ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The lock is thin. We must ensure that the lock is owned 1017ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * by the given thread before unlocking it. 1018f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1019ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro if (LW_LOCK_OWNER(thin) == self->threadId) { 1020ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1021ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * We are the lock owner. It is safe to update the lock 1022ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * without CAS as lock ownership guards the lock itself. 1023ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 1024ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro if (LW_LOCK_COUNT(thin) == 0) { 1025ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1026ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The lock was not recursively acquired, the common 1027ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * case. Unlock by clearing all bits except for the 1028ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * hash state. 1029ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 1030f28000dc9b6f596921b1a4387746bea4c8cd207fCarl Shapiro thin &= (LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT); 1031f28000dc9b6f596921b1a4387746bea4c8cd207fCarl Shapiro android_atomic_release_store(thin, (int32_t*)&obj->lock); 1032ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro } else { 1033ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1034ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The object was recursively acquired. Decrement the 1035ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * lock recursion count field. 1036ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 1037147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro obj->lock -= 1 << LW_LOCK_COUNT_SHIFT; 1038ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro } 1039ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro } else { 1040ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1041ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * We do not own the lock. The JVM spec requires that we 1042ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * throw an exception in this case. 1043f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1044d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException("unlock of unowned monitor"); 1045f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1046f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1047f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 1048ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1049ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The lock is fat. We must check to see if unlockMonitor has 1050ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * raised any exceptions before continuing. 1051f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 10528d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro assert(LW_MONITOR(obj->lock) != NULL); 10538d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro if (!unlockMonitor(self, LW_MONITOR(obj->lock))) { 1054ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1055ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * An exception has been raised. Do not fall through. 1056ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 1057f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1058f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1059f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1060f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 1061f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1062f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1063f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1064f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.wait(). Also called for class init. 1065f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1066f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmObjectWait(Thread* self, Object *obj, s8 msec, s4 nsec, 1067f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool interruptShouldThrow) 1068f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 106966bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro Monitor* mon; 1070f28000dc9b6f596921b1a4387746bea4c8cd207fCarl Shapiro u4 thin = *(volatile u4 *)&obj->lock; 1071f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1072f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* If the lock is still thin, we need to fatten it. 1073f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 107494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 1075f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make sure that 'self' holds the lock. 1076f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 107794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_LOCK_OWNER(thin) != self->threadId) { 1078d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException( 1079f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before wait()"); 1080f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1081f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1082f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1083f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* This thread holds the lock. We need to fatten the lock 1084f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * so 'self' can block on it. Don't update the object lock 1085f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * field yet, because 'self' needs to acquire the lock before 1086f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * any other thread gets a chance. 1087f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 108866bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro inflateMonitor(self, obj); 108992c1f6f1b4249e4e379452ee7b49f027052bf4ceSteve Block ALOGV("(%d) lock %p fattened by wait()", self->threadId, &obj->lock); 1090f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 109166bb7dfd93138c585d7be21863dd1b35e9607bd6Carl Shapiro mon = LW_MONITOR(obj->lock); 1092f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project waitMonitor(self, mon, msec, nsec, interruptShouldThrow); 1093f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1094f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1095f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1096f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.notify(). 1097f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1098f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmObjectNotify(Thread* self, Object *obj) 1099f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1100f28000dc9b6f596921b1a4387746bea4c8cd207fCarl Shapiro u4 thin = *(volatile u4 *)&obj->lock; 1101f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1102f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* If the lock is still thin, there aren't any waiters; 1103f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * waiting on an object forces lock fattening. 1104f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 110594338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 1106f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make sure that 'self' holds the lock. 1107f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 110894338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_LOCK_OWNER(thin) != self->threadId) { 1109d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException( 1110f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notify()"); 1111f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1112f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1113f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1114f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* no-op; there are no waiters to notify. 1115f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1116f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 1117f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* It's a fat lock. 1118f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 111994338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro notifyMonitor(self, LW_MONITOR(thin)); 1120f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1121f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1122f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1123f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1124f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.notifyAll(). 1125f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1126f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmObjectNotifyAll(Thread* self, Object *obj) 1127f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1128f28000dc9b6f596921b1a4387746bea4c8cd207fCarl Shapiro u4 thin = *(volatile u4 *)&obj->lock; 1129f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1130f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* If the lock is still thin, there aren't any waiters; 1131f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * waiting on an object forces lock fattening. 1132f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 113394338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 1134f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make sure that 'self' holds the lock. 1135f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 113694338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_LOCK_OWNER(thin) != self->threadId) { 1137d27f3cf3e7b373487f39e035fc4b55168d55c454Dan Bornstein dvmThrowIllegalMonitorStateException( 1138f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notifyAll()"); 1139f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1140f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1141f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1142f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* no-op; there are no waiters to notify. 1143f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1144f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 1145f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* It's a fat lock. 1146f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 114794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro notifyAllMonitor(self, LW_MONITOR(thin)); 1148f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1149f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1150f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1151f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1152f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This implements java.lang.Thread.sleep(long msec, int nsec). 1153f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1154f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The sleep is interruptible by other threads, which means we can't just 1155f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * plop into an OS sleep call. (We probably could if we wanted to send 1156f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * signals around and rely on EINTR, but that's inefficient and relies 1157f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * on native code respecting our signal mask.) 1158f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1159f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We have to do all of this stuff for Object.wait() as well, so it's 1160f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * easiest to just sleep on a private Monitor. 1161f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1162f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * It appears that we want sleep(0,0) to go through the motions of sleeping 1163f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * for a very short duration, rather than just returning. 1164f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1165f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmThreadSleep(u8 msec, u4 nsec) 1166f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1167f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* self = dvmThreadSelf(); 1168f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon = gDvm.threadSleepMon; 1169f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1170f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* sleep(0,0) wakes up immediately, wait(0,0) means wait forever; adjust */ 1171f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (msec == 0 && nsec == 0) 1172f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project nsec++; 1173f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1174f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lockMonitor(self, mon); 1175f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project waitMonitor(self, mon, msec, nsec, true); 1176f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unlockMonitor(self, mon); 1177f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1178f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1179f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1180f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Implement java.lang.Thread.interrupt(). 1181f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 118277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirovoid dvmThreadInterrupt(Thread* thread) 1183f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 118477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread != NULL); 118577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 1186980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmLockMutex(&thread->waitMutex); 118777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 118877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* 118977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * If the interrupted flag is already set no additional action is 119077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * required. 119177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 119277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->interrupted == true) { 1193980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&thread->waitMutex); 119477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 119577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 119677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 1197f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1198f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Raise the "interrupted" flag. This will cause it to bail early out 1199f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * of the next wait() attempt, if it's not currently waiting on 1200f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * something. 1201f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1202f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project thread->interrupted = true; 1203f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1204f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1205f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Is the thread waiting? 1206f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1207f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Note that fat vs. thin doesn't matter here; waitMonitor 1208f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is only set when a thread actually waits on a monitor, 1209f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * which implies that the monitor has already been fattened. 1210f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 121177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->waitMonitor != NULL) { 121277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_cond_signal(&thread->waitCond); 1213f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1214f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1215980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmUnlockMutex(&thread->waitMutex); 1216f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1217f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 121830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro#ifndef WITH_COPYING_GC 121994338aadf8355b28846f0d21c49142ca29479dc4Carl Shapirou4 dvmIdentityHashCode(Object *obj) 122094338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro{ 122194338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro return (u4)obj; 122294338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro} 122330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro#else 122430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro/* 122530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Returns the identity hash code of the given object. 122630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 122730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapirou4 dvmIdentityHashCode(Object *obj) 122830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro{ 122930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro Thread *self, *thread; 123030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro volatile u4 *lw; 1231bfe4dcc3bd3d4d85a07fd3d63da537b51342b6ebCarl Shapiro size_t size; 123230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro u4 lock, owner, hashState; 123330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 123430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (obj == NULL) { 123530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 123630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Null is defined to have an identity hash code of 0. 123730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 123830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return 0; 123930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 124030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lw = &obj->lock; 124130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiroretry: 124230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro hashState = LW_HASH_STATE(*lw); 124330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (hashState == LW_HASH_STATE_HASHED) { 124430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 124530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The object has been hashed but has not had its hash code 124630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * relocated by the garbage collector. Use the raw object 124730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * address. 124830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 124930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 125030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else if (hashState == LW_HASH_STATE_HASHED_AND_MOVED) { 125130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 125230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The object has been hashed and its hash code has been 125330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * relocated by the collector. Use the value of the naturally 125430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * aligned word following the instance data. 125530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 1256c6d2470eec726ae0ad95e4fd2d9d7da7cb2cdcbaDan Bornstein assert(!dvmIsClassObject(obj)); 125730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISARRAY)) { 1258bfe4dcc3bd3d4d85a07fd3d63da537b51342b6ebCarl Shapiro size = dvmArrayObjectSize((ArrayObject *)obj); 1259c48b6d0dc6b8c01c65977a9d18203c8510687267Carl Shapiro size = (size + 2) & ~2; 126030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 1261bfe4dcc3bd3d4d85a07fd3d63da537b51342b6ebCarl Shapiro size = obj->clazz->objectSize; 126230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 1263bfe4dcc3bd3d4d85a07fd3d63da537b51342b6ebCarl Shapiro return *(u4 *)(((char *)obj) + size); 126430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else if (hashState == LW_HASH_STATE_UNHASHED) { 126530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 126630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The object has never been hashed. Change the hash state to 126730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * hashed and use the raw object address. 126830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 126930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro self = dvmThreadSelf(); 127030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (self->threadId == lockOwner(obj)) { 127130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 127230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * We already own the lock so we can update the hash state 127330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * directly. 127430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 127530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro *lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 127630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 127730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 127830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 127930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * We do not own the lock. Try acquiring the lock. Should 128030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * this fail, we must suspend the owning thread. 128130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 128230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (LW_SHAPE(*lw) == LW_SHAPE_THIN) { 128330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 128430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * If the lock is thin assume it is unowned. We simulate 128530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * an acquire, update, and release with a single CAS. 128630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 1287122dac5b92c649b5d3182b163d7fce35e8c69d76Carl Shapiro lock = (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 12883ba10c9932db4c7c9546081ea070c73d5001c168Carl Shapiro if (android_atomic_acquire_cas( 1289122dac5b92c649b5d3182b163d7fce35e8c69d76Carl Shapiro 0, 12906e10b9aaa72425a4825a25f0043533d0c6fdbba4Andy McFadden (int32_t)lock, 12916e10b9aaa72425a4825a25f0043533d0c6fdbba4Andy McFadden (int32_t *)lw) == 0) { 129230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 129330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * A new lockword has been installed with a hash state 129430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * of hashed. Use the raw object address. 129530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 129630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 129730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 129830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 129930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (tryLockMonitor(self, LW_MONITOR(*lw))) { 130030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 130130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The monitor lock has been acquired. Change the 130230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * hash state to hashed and use the raw object 130330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * address. 130430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 130530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro *lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 130630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro unlockMonitor(self, LW_MONITOR(*lw)); 130730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 130830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 130930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 131030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 131130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * At this point we have failed to acquire the lock. We must 131230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * identify the owning thread and suspend it. 131330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 131430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmLockThreadList(self); 131530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 131630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Cache the lock word as its value can change between 131730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * determining its shape and retrieving its owner. 131830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 131930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lock = *lw; 132030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (LW_SHAPE(lock) == LW_SHAPE_THIN) { 132130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 132230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Find the thread with the corresponding thread id. 132330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 132430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro owner = LW_LOCK_OWNER(lock); 132530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(owner != self->threadId); 132630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 132730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * If the lock has no owner do not bother scanning the 132830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * thread list and fall through to the failure handler. 132930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 133030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro thread = owner ? gDvm.threadList : NULL; 133130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro while (thread != NULL) { 133230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (thread->threadId == owner) { 133330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro break; 133430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 133530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro thread = thread->next; 133630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 133730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 133830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro thread = LW_MONITOR(lock)->owner; 133930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 134030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 134130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * If thread is NULL the object has been released since the 134230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * thread list lock was acquired. Try again. 134330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 134430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (thread == NULL) { 134530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmUnlockThreadList(); 134630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro goto retry; 134730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 134830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 134930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Wait for the owning thread to suspend. 135030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 135130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmSuspendThread(thread); 135230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (dvmHoldsLock(thread, obj)) { 135330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 135430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The owning thread has been suspended. We can safely 135530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * change the hash state to hashed. 135630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 135730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro *lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 135830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmResumeThread(thread); 135930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmUnlockThreadList(); 136030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 136130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 136230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 136330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The wrong thread has been suspended. Try again. 136430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 136530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmResumeThread(thread); 136630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmUnlockThreadList(); 136730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro goto retry; 136830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 1369c1a4ab9c313d8a3d12007f2dbef7b5a6fa4ac2efSteve Block ALOGE("object %p has an unknown hash state %#x", obj, hashState); 137030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmDumpThread(dvmThreadSelf(), false); 137130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmAbort(); 137230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return 0; /* Quiet the compiler. */ 137330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro} 137430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro#endif /* WITH_COPYING_GC */ 1375