Sync.cpp revision 147dd3f9f0905dfc6687843a6ca3276031067505
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/* 18f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Fundamental synchronization mechanisms. 19f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 20f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The top part of the file has operations on "monitor" structs; the 21f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * next part has the native calls on objects. 22f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 23f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The current implementation uses "thin locking" to avoid allocating 24f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * an Object's full Monitor struct until absolutely necessary (i.e., 25f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * during contention or a call to wait()). 26f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 27f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * TODO: make improvements to thin locking 28f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We may be able to improve performance and reduce memory requirements by: 29f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - reverting to a thin lock once the Monitor is no longer necessary 30f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - using a pool of monitor objects, with some sort of recycling scheme 31f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 32f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * TODO: recycle native-level monitors when objects are garbage collected. 33f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 34f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "Dalvik.h" 35f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 36f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <stdlib.h> 37f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <unistd.h> 38f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <pthread.h> 39f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <time.h> 40f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <sys/time.h> 41f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <errno.h> 42f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 43f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#define LOG_THIN LOGV 44f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 45f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION /* fwd */ 46f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic const char* kStartBanner = 47f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "<-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#"; 48f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic const char* kEndBanner = 49f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#->"; 50f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 51f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 52f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Unsorted, expanding list of objects. 53f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 54f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This is very similar to PointerSet (which came into existence after this), 55f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * but these are unsorted, uniqueness is not enforced by the "add" function, 56f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * and the base object isn't allocated on the heap. 57f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 58f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projecttypedef struct ExpandingObjectList { 59f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project u2 alloc; 60f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project u2 count; 61f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object** list; 62f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} ExpandingObjectList; 63f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 64f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* fwd */ 65f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void updateDeadlockPrediction(Thread* self, Object* obj); 66f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void removeCollectedObject(Object* obj); 67f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void expandObjClear(ExpandingObjectList* pList); 68f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 69f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 70f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 71f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Every Object has a monitor associated with it, but not every Object is 72f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * actually locked. Even the ones that are locked do not need a 73f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * full-fledged monitor until a) there is actual contention or b) wait() 74f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is called on the Object. 75f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 76f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * For Dalvik, we have implemented a scheme similar to the one described 77f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in Bacon et al.'s "Thin locks: featherweight synchronization for Java" 78f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (ACM 1998). Things are even easier for us, though, because we have 79f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a full 32 bits to work with. 80f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 8194338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * The two states of an Object's lock are referred to as "thin" and 8294338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * "fat". A lock may transition from the "thin" state to the "fat" 8394338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * state and this transition is referred to as inflation. Once a lock 8494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * has been inflated it remains in the "fat" state indefinitely. 85f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 8677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * The lock value itself is stored in Object.lock. The LSB of the 8777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * lock encodes its state. When cleared, the lock is in the "thin" 8877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * state and its bits are formatted as follows: 8971938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro * 9094338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * [31 ---- 19] [18 ---- 3] [2 ---- 1] [0] 9194338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * lock count thread id hash state 0 92f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 9377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * When set, the lock is in the "fat" state and its bits are formatted 9494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * as follows: 95f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 9694338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * [31 ---- 3] [2 ---- 1] [0] 9794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro * pointer hash state 1 98f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 99f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * For an in-depth description of the mechanics of thin-vs-fat locking, 100f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * read the paper referred to above. 101f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 102f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 103f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 104f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Monitors provide: 105f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - mutually exclusive access to resources 106f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - a way for multiple threads to wait for notification 107f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 108f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * In effect, they fill the role of both mutexes and condition variables. 109f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 110f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Only one thread can own the monitor at any time. There may be several 111f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * threads waiting on it (the wait call unlocks it). One or more waiting 112f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * threads may be getting interrupted or notified at any given time. 113f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 114f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstruct Monitor { 115f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* owner; /* which thread currently owns the lock? */ 116f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int lockCount; /* owner's recursive lock depth */ 117f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object* obj; /* what object are we part of [debug only] */ 118f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 11977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread* waitSet; /* threads currently waiting on this monitor */ 120f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 121f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pthread_mutex_t lock; 122f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 123f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* next; 124f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 125f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 126f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 127f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Objects that have been locked immediately after this one in the 128f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * past. We use an expanding flat array, allocated on first use, to 129f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * minimize allocations. Deletions from the list, expected to be 130f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * infrequent, are crunched down. 131f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 132f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ExpandingObjectList historyChildren; 133f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 134f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 135f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We also track parents. This isn't strictly necessary, but it makes 136f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the cleanup at GC time significantly faster. 137f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 138f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ExpandingObjectList historyParents; 139f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 140f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* used during cycle detection */ 141f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool historyMark; 142f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 143f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* stack trace, established the first time we locked the object */ 144f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int historyStackDepth; 145f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int* historyRawStackTrace; 146f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 147f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project}; 148f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 149f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 150f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 151f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Create and initialize a monitor. 152f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 153f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectMonitor* dvmCreateMonitor(Object* obj) 154f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 155f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 156f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 157f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = (Monitor*) calloc(1, sizeof(Monitor)); 158f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon == NULL) { 159f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGE("Unable to allocate monitor\n"); 160f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAbort(); 161f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 16294338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (((u4)mon & 7) != 0) { 16394338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro LOGE("Misaligned monitor: %p\n", mon); 16494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro dvmAbort(); 16594338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro } 166f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->obj = obj; 167f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmInitMutex(&mon->lock); 168f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 169f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* replace the head of the list with the new monitor */ 170f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project do { 171f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->next = gDvm.monitorList; 172f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } while (!ATOMIC_CMP_SWAP((int32_t*)(void*)&gDvm.monitorList, 173f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (int32_t)mon->next, (int32_t)mon)); 174f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 175f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return mon; 176f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 177f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 178f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 179f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Free the monitor list. Only used when shutting the VM down. 180f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 181f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmFreeMonitorList(void) 182f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 183f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 184f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* nextMon; 185f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 186f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = gDvm.monitorList; 187f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project while (mon != NULL) { 188f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project nextMon = mon->next; 189f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 190f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 191f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project expandObjClear(&mon->historyChildren); 192f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project expandObjClear(&mon->historyParents); 193f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project free(mon->historyRawStackTrace); 194f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 195f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project free(mon); 196f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = nextMon; 197f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 198f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 199f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 200f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 201f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Log some info about our monitors. 202f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 203f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmDumpMonitorInfo(const char* msg) 204f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 205f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if QUIET_ZYGOTE_MONITOR 206f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.zygote) { 207f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 208f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 209f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 210f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 211f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int totalCount; 212f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int liveCount; 213f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 214f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project totalCount = liveCount = 0; 215f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon = gDvm.monitorList; 216f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project while (mon != NULL) { 217f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project totalCount++; 218f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->obj != NULL) 219f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project liveCount++; 220f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = mon->next; 221f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 222f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 223f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD("%s: monitor list has %d entries (%d live)\n", 224f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project msg, totalCount, liveCount); 225f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 226f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 227f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 228f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Get the object that a monitor is part of. 229f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 230f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectObject* dvmGetMonitorObject(Monitor* mon) 231f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 232f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon == NULL) 233f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return NULL; 234f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 235f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return mon->obj; 236f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 237f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 238f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 23930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Returns the thread id of the thread owning the given lock. 24030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 24130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapirostatic u4 lockOwner(Object* obj) 24230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro{ 24330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro Thread *owner; 24430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro u4 lock; 24530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 24630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(obj != NULL); 24730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 24830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Since we're reading the lock value multiple times, latch it so 24930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * that it doesn't change out from under us if we get preempted. 25030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 25130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lock = obj->lock; 25230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (LW_SHAPE(lock) == LW_SHAPE_THIN) { 25330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return LW_LOCK_OWNER(lock); 25430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 25530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro owner = LW_MONITOR(lock)->owner; 25630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return owner ? owner->threadId : 0; 25730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 25830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro} 25930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 26030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro/* 261f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Checks whether the given thread holds the given 262f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * objects's lock. 263f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 264f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool dvmHoldsLock(Thread* thread, Object* obj) 265f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 266f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (thread == NULL || obj == NULL) { 267f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 268f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 26930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return thread->threadId == lockOwner(obj); 270f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 271f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 272f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 273f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 274f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Free the monitor associated with an object and make the object's lock 275f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * thin again. This is called during garbage collection. 276f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 2775a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapirostatic void freeObjectMonitor(Object* obj) 278f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 279f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor *mon; 280f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 2815a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro assert(LW_SHAPE(obj->lock) == LW_SHAPE_FAT); 282f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 283f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 284f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.deadlockPredictMode != kDPOff) 2855a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro removeCollectedObject(obj); 286f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 287f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 2885a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro mon = LW_MONITOR(obj->lock); 2895a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro obj->lock = DVM_LOCK_INITIAL_THIN_VALUE; 290f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 291f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* This lock is associated with an object 292f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * that's being swept. The only possible way 293f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * anyone could be holding this lock would be 294f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * if some JNI code locked but didn't unlock 295f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the object, in which case we've got some bad 296f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * native code somewhere. 297f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 298f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(pthread_mutex_trylock(&mon->lock) == 0); 299f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pthread_mutex_destroy(&mon->lock); 300f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 3015a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro expandObjClear(&mon->historyChildren); 3025a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro expandObjClear(&mon->historyParents); 3035a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro free(mon->historyRawStackTrace); 304f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 3055a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro free(mon); 306f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 307f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 3085a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro/* 3095a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro * Frees monitor objects belonging to unmarked objects. 3105a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro */ 3115a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapirovoid dvmSweepMonitorList(Monitor** mon, int (*isUnmarkedObject)(void*)) 3125a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro{ 3135a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro Monitor handle; 3145a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro Monitor *prev, *curr; 3155a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro Object *obj; 3165a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro 3175a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro assert(mon != NULL); 3185a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro assert(*mon != NULL); 3195a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro assert(isUnmarkedObject != NULL); 3205a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro prev = &handle; 3215a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro prev->next = curr = *mon; 3225a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro while (curr != NULL) { 3235a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro obj = curr->obj; 3245a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro if (obj != NULL && (*isUnmarkedObject)(obj) != 0) { 3255a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro prev->next = curr = curr->next; 3265a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro freeObjectMonitor(obj); 3275a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro } else { 3285a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro prev = curr; 3295a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro curr = curr->next; 3305a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro } 3315a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro } 3325a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro *mon = handle.next; 3335a6071b914e7669eaf032256f163f65403bfcf3bCarl Shapiro} 334f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 335f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 336f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Lock a monitor. 337f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 338f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void lockMonitor(Thread* self, Monitor* mon) 339f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 340f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int cc; 341f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 342f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->owner == self) { 343f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount++; 344f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 345f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ThreadStatus oldStatus; 346f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 347f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (pthread_mutex_trylock(&mon->lock) != 0) { 348f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* mutex is locked, switch to wait status and sleep on it */ 349f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project oldStatus = dvmChangeStatus(self, THREAD_MONITOR); 350f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project cc = pthread_mutex_lock(&mon->lock); 351f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(cc == 0); 352f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmChangeStatus(self, oldStatus); 353f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 354f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 355f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = self; 356f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(mon->lockCount == 0); 357f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 358f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 359f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 360f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 361f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Try to lock a monitor. 362f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 363f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns "true" on success. 364f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 365f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool tryLockMonitor(Thread* self, Monitor* mon) 366f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 367f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int cc; 368f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 369f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->owner == self) { 370f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount++; 371f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 372f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 373f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project cc = pthread_mutex_trylock(&mon->lock); 374f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (cc == 0) { 375f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = self; 376f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(mon->lockCount == 0); 377f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 378f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 379f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 380f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 381f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 382f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 383f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 384f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 385f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 386f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Unlock a monitor. 387f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 388f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns true if the unlock succeeded. 389f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If the unlock failed, an exception will be pending. 390f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 391f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool unlockMonitor(Thread* self, Monitor* mon) 392f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 39377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(self != NULL); 394f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(mon != NULL); // can this happen? 395f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 396f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->owner == self) { 397f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 398f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We own the monitor, so nobody else can be in here. 399f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 400f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->lockCount == 0) { 401f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int cc; 402f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = NULL; 403f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project cc = pthread_mutex_unlock(&mon->lock); 404f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(cc == 0); 405f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 406f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount--; 407f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 408f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 409f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 410f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We don't own this, so we're not allowed to unlock it. 411f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The JNI spec says that we should throw IllegalMonitorStateException 412f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in this case. 413f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 414e11f3fdcd878b7d4604392f22c749c2482ea0a5fCarl Shapiro dvmThrowExceptionFmt("Ljava/lang/IllegalMonitorStateException;", 415e11f3fdcd878b7d4604392f22c749c2482ea0a5fCarl Shapiro "unlock of unowned monitor, self=%d owner=%d", 416e11f3fdcd878b7d4604392f22c749c2482ea0a5fCarl Shapiro self->threadId, 417e11f3fdcd878b7d4604392f22c749c2482ea0a5fCarl Shapiro mon->owner ? mon->owner->threadId : 0); 418f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 419f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 420f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 421f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 422f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 423f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 42477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * Checks the wait set for circular structure. Returns 0 if the list 425b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro * is not circular. Otherwise, returns 1. Used only by asserts. 42677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 42777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirostatic int waitSetCheck(Monitor *mon) 42877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 42977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread *fast, *slow; 43077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro size_t n; 43177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 43277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(mon != NULL); 43377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro fast = slow = mon->waitSet; 43477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro n = 0; 43577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro for (;;) { 43677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (fast == NULL) return 0; 43777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (fast->waitNext == NULL) return 0; 4385f56e67999c67861872c27097803d2126142fed4Carl Shapiro if (fast == slow && n > 0) return 1; 43977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro n += 2; 44077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro fast = fast->waitNext->waitNext; 44177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro slow = slow->waitNext; 44277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 44377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 44477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 44577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro/* 44630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Links a thread into a monitor's wait set. The monitor lock must be 44730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * held by the caller of this routine. 44877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 44977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirostatic void waitSetAppend(Monitor *mon, Thread *thread) 45077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 45177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread *elt; 45277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 45377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(mon != NULL); 45430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(mon->owner == dvmThreadSelf()); 45577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread != NULL); 45677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread->waitNext == NULL); 45777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(waitSetCheck(mon) == 0); 45877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (mon->waitSet == NULL) { 45977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread; 46077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 46177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 46277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = mon->waitSet; 46377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro while (elt->waitNext != NULL) { 46477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = elt->waitNext; 46577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 46677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt->waitNext = thread; 46777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 46877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 46977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro/* 47030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Unlinks a thread from a monitor's wait set. The monitor lock must 47130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * be held by the caller of this routine. 47277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 47377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirostatic void waitSetRemove(Monitor *mon, Thread *thread) 47477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 47577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread *elt; 47677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 47777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(mon != NULL); 47830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(mon->owner == dvmThreadSelf()); 47977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread != NULL); 48077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(waitSetCheck(mon) == 0); 48177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (mon->waitSet == NULL) { 48277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 48377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 48477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (mon->waitSet == thread) { 48577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread->waitNext; 48677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 48777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 48877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 48977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = mon->waitSet; 49077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro while (elt->waitNext != NULL) { 49177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (elt->waitNext == thread) { 49277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt->waitNext = thread->waitNext; 49377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 49477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 49577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 49677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro elt = elt->waitNext; 49777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 49877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 49977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 500b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro/* 501b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro * Converts the given relative waiting time into an absolute time. 502b453919fee9bf10ccd576d389d8b3584061bba8bCarl Shapiro */ 503eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbeevoid absoluteTime(s8 msec, s4 nsec, struct timespec *ts) 50477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro{ 50577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro s8 endSec; 50677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 50777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro#ifdef HAVE_TIMEDWAIT_MONOTONIC 50877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro clock_gettime(CLOCK_MONOTONIC, ts); 50977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro#else 51077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro { 51177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro struct timeval tv; 51277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro gettimeofday(&tv, NULL); 51377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_sec = tv.tv_sec; 51477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_nsec = tv.tv_usec * 1000; 51577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 51677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro#endif 51777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro endSec = ts->tv_sec + msec / 1000; 51877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (endSec >= 0x7fffffff) { 51977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro LOGV("NOTE: end time exceeds epoch\n"); 52077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro endSec = 0x7ffffffe; 52177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 52277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_sec = endSec; 52377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_nsec = (ts->tv_nsec + (msec % 1000) * 1000000) + nsec; 52477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 52577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* catch rollover */ 52677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (ts->tv_nsec >= 1000000000L) { 52777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_sec++; 52877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ts->tv_nsec -= 1000000000L; 52977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 53077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro} 53177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 532eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbeeint dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex, 533eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee s8 msec, s4 nsec) 534eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee{ 535eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee int ret; 536eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee struct timespec ts; 537eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee absoluteTime(msec, nsec, &ts); 538eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee#if defined(HAVE_TIMEDWAIT_MONOTONIC) 539eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee ret = pthread_cond_timedwait_monotonic(cond, mutex, &ts); 540eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee#else 541eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee ret = pthread_cond_timedwait(cond, mutex, &ts); 542eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee#endif 543eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee assert(ret == 0 || ret == ETIMEDOUT); 544eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee return ret; 545eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee} 546eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee 54777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro/* 548f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Wait on a monitor until timeout, interrupt, or notification. Used for 549f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.wait() and (somewhat indirectly) Thread.sleep() and Thread.join(). 550f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 551f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If another thread calls Thread.interrupt(), we throw InterruptedException 552f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * and return immediately if one of the following are true: 553f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - blocked in wait(), wait(long), or wait(long, int) methods of Object 554f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - blocked in join(), join(long), or join(long, int) methods of Thread 555f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - blocked in sleep(long), or sleep(long, int) methods of Thread 556f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Otherwise, we set the "interrupted" flag. 557f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 558f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Checks to make sure that "nsec" is in the range 0-999999 559f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (i.e. fractions of a millisecond) and throws the appropriate 560f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * exception if it isn't. 561f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 562f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The spec allows "spurious wakeups", and recommends that all code using 563f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.wait() do so in a loop. This appears to derive from concerns 564f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * about pthread_cond_wait() on multiprocessor systems. Some commentary 565f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * on the web casts doubt on whether these can/should occur. 566f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 567f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Since we're allowed to wake up "early", we clamp extremely long durations 568f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * to return at the end of the 32-bit time epoch. 569f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 570f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void waitMonitor(Thread* self, Monitor* mon, s8 msec, s4 nsec, 571f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool interruptShouldThrow) 572f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 573f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project struct timespec ts; 574f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool wasInterrupted = false; 575f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool timed; 57677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro int ret; 577f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 57871938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(self != NULL); 57971938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(mon != NULL); 58071938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro 58194338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro /* Make sure that we hold the lock. */ 58271938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro if (mon->owner != self) { 583f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalMonitorStateException;", 584f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before wait()"); 585f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 586f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 587f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 588f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 589f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Enforce the timeout range. 590f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 591f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (msec < 0 || nsec < 0 || nsec > 999999) { 592f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalArgumentException;", 593f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "timeout arguments out of range"); 594f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 595f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 596f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 597f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 598f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Compute absolute wakeup time, if necessary. 599f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 600f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (msec == 0 && nsec == 0) { 601f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project timed = false; 602f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 603eb695c6f814f6b0bdbba0e837555d3fe5ad23104Bill Buzbee absoluteTime(msec, nsec, &ts); 604f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project timed = true; 605f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 606f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 607f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 608f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Add ourselves to the set of threads waiting on this monitor, and 609f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * release our hold. We need to let it go even if we're a few levels 610f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * deep in a recursive lock, and we need to restore that later. 611f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 612142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * We append to the wait set ahead of clearing the count and owner 613142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * fields so the subroutine can check that the calling thread owns 614142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * the monitor. Aside from that, the order of member updates is 615142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro * not order sensitive as we hold the pthread mutex. 616f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 617142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro waitSetAppend(mon, self); 618142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapiro int prevLockCount = mon->lockCount; 619f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount = 0; 620f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = NULL; 621f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 622f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 623f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Update thread status. If the GC wakes up, it'll ignore us, knowing 624f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * that we won't touch any references in this state, and we'll check 625f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * our suspend mode before we transition out. 626f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 627f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (timed) 628f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmChangeStatus(self, THREAD_TIMED_WAIT); 629f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 630f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmChangeStatus(self, THREAD_WAIT); 631f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 63277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ret = pthread_mutex_lock(&self->waitMutex); 63377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(ret == 0); 63477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 635f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 63677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * Set waitMonitor to the monitor object we will be waiting on. 63777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * When waitMonitor is non-NULL a notifying or interrupting thread 63877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * must signal the thread's waitCond to wake it up. 639f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 64077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(self->waitMonitor == NULL); 641f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->waitMonitor = mon; 642f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 643f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 644f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Handle the case where the thread was interrupted before we called 645f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * wait(). 646f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 647f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (self->interrupted) { 648f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project wasInterrupted = true; 64977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro self->waitMonitor = NULL; 65077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_unlock(&self->waitMutex); 651f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project goto done; 652f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 653f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 65477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* 65577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * Release the monitor lock and wait for a notification or 65677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * a timeout to occur. 65777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 65877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_unlock(&mon->lock); 65977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 66077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (!timed) { 66177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ret = pthread_cond_wait(&self->waitCond, &self->waitMutex); 66277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(ret == 0); 66377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } else { 664f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef HAVE_TIMEDWAIT_MONOTONIC 66577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ret = pthread_cond_timedwait_monotonic(&self->waitCond, &self->waitMutex, &ts); 666f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#else 66777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro ret = pthread_cond_timedwait(&self->waitCond, &self->waitMutex, &ts); 668f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 66977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(ret == 0 || ret == ETIMEDOUT); 67077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 67177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (self->interrupted) { 67277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro wasInterrupted = true; 673f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 674f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 67577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro self->interrupted = false; 67677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro self->waitMonitor = NULL; 67777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 67877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_unlock(&self->waitMutex); 67977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 68030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* Reacquire the monitor lock. */ 68177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro lockMonitor(self, mon); 682f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 683142ef271a96b4bb2997effc3f3c1bfa601abbeb6Carl Shapirodone: 684f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 68507b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * We remove our thread from wait set after restoring the count 68607b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * and owner fields so the subroutine can check that the calling 68707b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * thread owns the monitor. Aside from that, the order of member 68807b359273a838a15accafefcbe861be15caaac3aCarl Shapiro * updates is not order sensitive as we hold the pthread mutex. 689f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 690f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->owner = self; 691f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->lockCount = prevLockCount; 69207b359273a838a15accafefcbe861be15caaac3aCarl Shapiro waitSetRemove(mon, self); 693f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 694f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* set self->status back to THREAD_RUNNING, and self-suspend if needed */ 695f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmChangeStatus(self, THREAD_RUNNING); 696f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 697f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (wasInterrupted) { 698f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 699f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We were interrupted while waiting, or somebody interrupted an 70030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * un-interruptible thread earlier and we're bailing out immediately. 701f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 702f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The doc sayeth: "The interrupted status of the current thread is 703f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * cleared when this exception is thrown." 704f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 705f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->interrupted = false; 706f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (interruptShouldThrow) 707f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/InterruptedException;", NULL); 708f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 709f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 710f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 711f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 712f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Notify one thread waiting on this monitor. 713f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 714f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void notifyMonitor(Thread* self, Monitor* mon) 715f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 71677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread* thread; 71777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 71871938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(self != NULL); 71971938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(mon != NULL); 72071938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro 72194338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro /* Make sure that we hold the lock. */ 72271938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro if (mon->owner != self) { 723f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalMonitorStateException;", 724f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notify()"); 725f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 726f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 72730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* Signal the first waiting thread in the wait set. */ 72830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro while (mon->waitSet != NULL) { 72977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread = mon->waitSet; 73077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread->waitNext; 73177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 73277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_lock(&thread->waitMutex); 73377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* Check to see if the thread is still waiting. */ 73477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->waitMonitor != NULL) { 73577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_cond_signal(&thread->waitCond); 73630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro pthread_mutex_unlock(&thread->waitMutex); 73730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return; 73877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 73977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_unlock(&thread->waitMutex); 740f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 741f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 742f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 743f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 744f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Notify all threads waiting on this monitor. 745f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 746f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void notifyAllMonitor(Thread* self, Monitor* mon) 747f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 74877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro Thread* thread; 74977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 75071938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(self != NULL); 75171938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro assert(mon != NULL); 75271938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro 75394338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro /* Make sure that we hold the lock. */ 75471938023ea2bacc1923ec44c71a797f254d268e2Carl Shapiro if (mon->owner != self) { 755f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalMonitorStateException;", 756f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notifyAll()"); 757f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 758f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 75977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* Signal all threads in the wait set. */ 76077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro while (mon->waitSet != NULL) { 76177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread = mon->waitSet; 76277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro mon->waitSet = thread->waitNext; 76377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro thread->waitNext = NULL; 76477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_lock(&thread->waitMutex); 76577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* Check to see if the thread is still waiting. */ 76677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->waitMonitor != NULL) { 76777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_cond_signal(&thread->waitCond); 76877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 76977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_unlock(&thread->waitMutex); 770f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 771f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 772f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 773f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 774f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Implements monitorenter for "synchronized" stuff. 775f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 776f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This does not fail or throw an exception (unless deadlock prediction 777f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is enabled and set to "err" mode). 778f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 779f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmLockObject(Thread* self, Object *obj) 780f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 781147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro volatile u4 *thinp; 78294338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro Monitor *mon; 783147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro ThreadStatus oldStatus; 784147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro useconds_t sleepDelay; 785147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro const useconds_t maxSleepDelay = 1 << 20; 786147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro u4 thin, newThin, threadId; 787f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 788147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro assert(self != NULL); 789147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro assert(obj != NULL); 790147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro threadId = self->threadId; 791147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thinp = &obj->lock; 792147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiroretry: 793147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin = *thinp; 794147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 795147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 796147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is a thin lock. The owner field is used to 797147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * determine the acquire method, ordered by cost. 798f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 799147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_LOCK_OWNER(thin) == threadId) { 800147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 801147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The calling thread owns the lock. Increment the 802147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * value of the recursion count field. 803f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 804147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro obj->lock += 1 << LW_LOCK_COUNT_SHIFT; 805147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else if (LW_LOCK_OWNER(thin) == 0) { 806147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 807147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is unowned. Install the thread id of the 808147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * calling thread into the owner field. This is the 809147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * common case. In performance critical code the JIT 810147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * will have tried this before calling out to the VM. 811f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 812147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT); 813147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (!ATOMIC_CMP_SWAP((int32_t *)thinp, thin, newThin)) { 814147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 815147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The acquire failed. Try again. 816f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 817147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro goto retry; 818147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } 819147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 820147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro LOG_THIN("(%d) spin on lock %p: %#x (%#x) %#x", 821147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro threadId, &obj->lock, 0, *thinp, thin); 822147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 823147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is owned by another thread. Notify the VM 824147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * that we are about to wait. 825147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 826147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro oldStatus = dvmChangeStatus(self, THREAD_MONITOR); 827147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 828147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Spin until the thin lock is released or inflated. 829147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 830147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro sleepDelay = 0; 831147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro for (;;) { 832147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin = *thinp; 833147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 834147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Check the shape of the lock word. Another thread 835147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * may have inflated the lock while we were waiting. 836f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 837147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 838147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (LW_LOCK_OWNER(thin) == 0) { 839147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 840147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock has been released. Install the 841147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * thread id of the calling thread into the 842147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * owner field. 843147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 844147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT); 845147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro if (ATOMIC_CMP_SWAP((int32_t *)thinp, 846147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin, newThin)) { 847147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 848147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The acquire succeed. Break out of the 849147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * loop and proceed to inflate the lock. 850f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 851147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro break; 852f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 853147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 854147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 855147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock has not been released. Yield so 856147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * the owning thread can run. 857147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 858f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (sleepDelay == 0) { 859f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project sched_yield(); 860147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro sleepDelay = 1000; 861f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 862f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project usleep(sleepDelay); 863f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (sleepDelay < maxSleepDelay / 2) { 864f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project sleepDelay *= 2; 865f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 866f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 867f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 868147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 869147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 870147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The thin lock was inflated by another thread. 871147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Let the VM know we are no longer waiting and 872147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * try again. 873147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 874147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro LOG_THIN("(%d) lock %p surprise-fattened", 875147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro threadId, &obj->lock); 876147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro dvmChangeStatus(self, oldStatus); 877147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro goto retry; 878147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } 879f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 880147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro LOG_THIN("(%d) spin on lock done %p: %#x (%#x) %#x", 881147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro threadId, &obj->lock, 0, *thinp, thin); 882147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 883147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * We have acquired the thin lock. Let the VM know that 884147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * we are no longer waiting. 885147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 886147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro dvmChangeStatus(self, oldStatus); 887147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 888147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * Fatten the lock. 889f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 890147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro mon = dvmCreateMonitor(obj); 891147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro lockMonitor(self, mon); 892147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin = *thinp; 893147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin &= LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT; 894147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin |= (u4)mon | LW_SHAPE_FAT; 895147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro MEM_BARRIER(); 896147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro obj->lock = thin; 897147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro LOG_THIN("(%d) lock %p fattened", threadId, &obj->lock); 898f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 899147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro } else { 900147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro /* 901147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro * The lock is a fat lock. 902147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro */ 903147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro assert(LW_MONITOR(obj->lock) != NULL); 904147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro lockMonitor(self, LW_MONITOR(obj->lock)); 905f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 906f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 907f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 908f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * See if we were allowed to grab the lock at this time. We do it 909f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * *after* acquiring the lock, rather than before, so that we can 910f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * freely update the Monitor struct. This seems counter-intuitive, 911f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * but our goal is deadlock *prediction* not deadlock *prevention*. 912f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (If we actually deadlock, the situation is easy to diagnose from 913f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a thread dump, so there's no point making a special effort to do 914f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the checks before the lock is held.) 915f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 916f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This needs to happen before we add the object to the thread's 917f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * monitor list, so we can tell the difference between first-lock and 918f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * re-lock. 919f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 920f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * It's also important that we do this while in THREAD_RUNNING, so 921f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * that we don't interfere with cleanup operations in the GC. 922f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 923f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.deadlockPredictMode != kDPOff) { 924f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (self->status != THREAD_RUNNING) { 925f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGE("Bad thread status (%d) in DP\n", self->status); 926f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmDumpThread(self, false); 927f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAbort(); 928f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 929f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!dvmCheckException(self)); 930f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project updateDeadlockPrediction(self, obj); 931f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (dvmCheckException(self)) { 932f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 933f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If we're throwing an exception here, we need to free the 934f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * lock. We add the object to the thread's monitor list so the 935f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * "unlock" code can remove it. 936f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 937f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAddToMonitorList(self, obj, false); 938f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockObject(self, obj); 939f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGV("--- unlocked, pending is '%s'\n", 940f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmGetException(self)->clazz->descriptor); 941f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 942f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 943f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 944f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 945f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Add the locked object, and the current stack trace, to the list 946f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * held by the Thread object. If deadlock prediction isn't on, 947f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * don't capture the stack trace. 948f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 949f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAddToMonitorList(self, obj, gDvm.deadlockPredictMode != kDPOff); 950f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#elif defined(WITH_MONITOR_TRACKING) 951f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 952f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Add the locked object to the list held by the Thread object. 953f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 954f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAddToMonitorList(self, obj, false); 955f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 956f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 957f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 958f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 959f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Implements monitorexit for "synchronized" stuff. 960f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 961f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * On failure, throws an exception and returns "false". 962f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 963f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool dvmUnlockObject(Thread* self, Object *obj) 964f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 96594338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro u4 thin; 966f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 967ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro assert(self != NULL); 968ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro assert(self->status == THREAD_RUNNING); 969ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro assert(obj != NULL); 970ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 971ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * Cache the lock word as its value can change while we are 972ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * examining its state. 973f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 974147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin = obj->lock; 975ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 976ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 977ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The lock is thin. We must ensure that the lock is owned 978ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * by the given thread before unlocking it. 979f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 980ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro if (LW_LOCK_OWNER(thin) == self->threadId) { 981ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 982ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * We are the lock owner. It is safe to update the lock 983ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * without CAS as lock ownership guards the lock itself. 984ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 985ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro if (LW_LOCK_COUNT(thin) == 0) { 986ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 987ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The lock was not recursively acquired, the common 988ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * case. Unlock by clearing all bits except for the 989ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * hash state. 990ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 991147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro obj->lock &= (LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT); 992ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro } else { 993ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 994ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The object was recursively acquired. Decrement the 995ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * lock recursion count field. 996ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 997147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro obj->lock -= 1 << LW_LOCK_COUNT_SHIFT; 998ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro } 999ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro } else { 1000ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1001ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * We do not own the lock. The JVM spec requires that we 1002ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * throw an exception in this case. 1003f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1004f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalMonitorStateException;", 1005ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro "unlock of unowned monitor"); 1006f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1007f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1008f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 1009ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1010ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * The lock is fat. We must check to see if unlockMonitor has 1011ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * raised any exceptions before continuing. 1012f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 10138d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro assert(LW_MONITOR(obj->lock) != NULL); 10148d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro if (!unlockMonitor(self, LW_MONITOR(obj->lock))) { 1015ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro /* 1016ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro * An exception has been raised. Do not fall through. 1017ef5b4d3a0db17756c0e9bb90f14e18c4bf17a446Carl Shapiro */ 1018f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1019f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1020f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1021f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1022f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_MONITOR_TRACKING 1023f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1024f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Remove the object from the Thread's list. 1025f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1026f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmRemoveFromMonitorList(self, obj); 1027f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 1028f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1029f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 1030f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1031f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1032f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1033f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.wait(). Also called for class init. 1034f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1035f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmObjectWait(Thread* self, Object *obj, s8 msec, s4 nsec, 1036f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool interruptShouldThrow) 1037f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 10388d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro Monitor* mon = LW_MONITOR(obj->lock); 10398d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 hashState; 10408d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 thin = obj->lock; 1041f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1042f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* If the lock is still thin, we need to fatten it. 1043f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 104494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 1045f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make sure that 'self' holds the lock. 1046f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 104794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_LOCK_OWNER(thin) != self->threadId) { 1048f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalMonitorStateException;", 1049f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before wait()"); 1050f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1051f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1052f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1053f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* This thread holds the lock. We need to fatten the lock 1054f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * so 'self' can block on it. Don't update the object lock 1055f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * field yet, because 'self' needs to acquire the lock before 1056f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * any other thread gets a chance. 1057f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1058f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = dvmCreateMonitor(obj); 1059f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1060f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 'self' has actually locked the object one or more times; 1061f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * make sure that the monitor reflects this. 1062f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1063f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lockMonitor(self, mon); 106494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro mon->lockCount = LW_LOCK_COUNT(thin); 1065f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOG_THIN("(%d) lock 0x%08x fattened by wait() to count %d\n", 1066f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->threadId, (uint)&obj->lock, mon->lockCount); 1067f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1068581bed77d3596b9d7242da10867c8d4cfd382239Andy McFadden 1069f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make the monitor public now that it's in the right state. 1070f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1071147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin &= LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT; 1072147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro thin |= (u4)mon | LW_SHAPE_FAT; 1073581bed77d3596b9d7242da10867c8d4cfd382239Andy McFadden MEM_BARRIER(); 1074147dd3f9f0905dfc6687843a6ca3276031067505Carl Shapiro obj->lock = thin; 1075f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1076f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1077f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project waitMonitor(self, mon, msec, nsec, interruptShouldThrow); 1078f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1079f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1080f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1081f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.notify(). 1082f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1083f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmObjectNotify(Thread* self, Object *obj) 1084f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 10858d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 thin = obj->lock; 1086f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1087f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* If the lock is still thin, there aren't any waiters; 1088f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * waiting on an object forces lock fattening. 1089f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 109094338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 1091f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make sure that 'self' holds the lock. 1092f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 109394338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_LOCK_OWNER(thin) != self->threadId) { 1094f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalMonitorStateException;", 1095f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notify()"); 1096f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1097f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1098f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1099f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* no-op; there are no waiters to notify. 1100f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1101f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 1102f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* It's a fat lock. 1103f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 110494338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro notifyMonitor(self, LW_MONITOR(thin)); 1105f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1106f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1107f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1108f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1109f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Object.notifyAll(). 1110f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1111f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmObjectNotifyAll(Thread* self, Object *obj) 1112f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 11138d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 thin = obj->lock; 1114f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1115f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* If the lock is still thin, there aren't any waiters; 1116f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * waiting on an object forces lock fattening. 1117f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 111894338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_SHAPE(thin) == LW_SHAPE_THIN) { 1119f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make sure that 'self' holds the lock. 1120f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 112194338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro if (LW_LOCK_OWNER(thin) != self->threadId) { 1122f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/IllegalMonitorStateException;", 1123f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "object not locked by thread before notifyAll()"); 1124f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1125f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1126f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1127f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* no-op; there are no waiters to notify. 1128f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1129f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 1130f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* It's a fat lock. 1131f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 113294338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro notifyAllMonitor(self, LW_MONITOR(thin)); 1133f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1134f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1135f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1136f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1137f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This implements java.lang.Thread.sleep(long msec, int nsec). 1138f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1139f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The sleep is interruptible by other threads, which means we can't just 1140f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * plop into an OS sleep call. (We probably could if we wanted to send 1141f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * signals around and rely on EINTR, but that's inefficient and relies 1142f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * on native code respecting our signal mask.) 1143f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1144f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We have to do all of this stuff for Object.wait() as well, so it's 1145f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * easiest to just sleep on a private Monitor. 1146f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1147f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * It appears that we want sleep(0,0) to go through the motions of sleeping 1148f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * for a very short duration, rather than just returning. 1149f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1150f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmThreadSleep(u8 msec, u4 nsec) 1151f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1152f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* self = dvmThreadSelf(); 1153f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon = gDvm.threadSleepMon; 1154f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1155f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* sleep(0,0) wakes up immediately, wait(0,0) means wait forever; adjust */ 1156f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (msec == 0 && nsec == 0) 1157f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project nsec++; 1158f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1159f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lockMonitor(self, mon); 1160f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project waitMonitor(self, mon, msec, nsec, true); 1161f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unlockMonitor(self, mon); 1162f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1163f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1164f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1165f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Implement java.lang.Thread.interrupt(). 1166f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 116777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapirovoid dvmThreadInterrupt(Thread* thread) 1168f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 116977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro assert(thread != NULL); 117077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 117177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_lock(&thread->waitMutex); 117277f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 117377f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro /* 117477f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * If the interrupted flag is already set no additional action is 117577f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro * required. 117677f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro */ 117777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->interrupted == true) { 117877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_unlock(&thread->waitMutex); 117977f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro return; 118077f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro } 118177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro 1182f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1183f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Raise the "interrupted" flag. This will cause it to bail early out 1184f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * of the next wait() attempt, if it's not currently waiting on 1185f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * something. 1186f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1187f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project thread->interrupted = true; 1188f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project MEM_BARRIER(); 1189f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1190f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1191f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Is the thread waiting? 1192f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1193f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Note that fat vs. thin doesn't matter here; waitMonitor 1194f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is only set when a thread actually waits on a monitor, 1195f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * which implies that the monitor has already been fattened. 1196f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 119777f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro if (thread->waitMonitor != NULL) { 119877f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_cond_signal(&thread->waitCond); 1199f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1200f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 120177f52ebffa3793a7e824fab7da02eaee9afdae0eCarl Shapiro pthread_mutex_unlock(&thread->waitMutex); 1202f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1203f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 120430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro#ifndef WITH_COPYING_GC 120594338aadf8355b28846f0d21c49142ca29479dc4Carl Shapirou4 dvmIdentityHashCode(Object *obj) 120694338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro{ 120794338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro return (u4)obj; 120894338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro} 120930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro#else 121030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapirostatic size_t arrayElementWidth(const ArrayObject *array) 121130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro{ 121230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro const char *descriptor; 121330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 121430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (dvmIsObjectArray(array)) { 121530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return sizeof(Object *); 121630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 121730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro descriptor = array->obj.clazz->descriptor; 121830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro switch (descriptor[1]) { 121930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'B': return 1; /* byte */ 122030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'C': return 2; /* char */ 122130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'D': return 8; /* double */ 122230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'F': return 4; /* float */ 122330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'I': return 4; /* int */ 122430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'J': return 8; /* long */ 122530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'S': return 2; /* short */ 122630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro case 'Z': return 1; /* boolean */ 122730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 122830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 122930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro LOGE("object %p has an unhandled descriptor '%s'", array, descriptor); 123030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmDumpThread(dvmThreadSelf(), false); 123130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmAbort(); 123230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return 0; /* Quiet the compiler. */ 123330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro} 123430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 123530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapirostatic size_t arrayObjectLength(const ArrayObject *array) 123630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro{ 123730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro size_t length; 123830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 123930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro length = offsetof(ArrayObject, contents); 124030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro length += array->length * arrayElementWidth(array); 124130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return length; 124230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro} 124330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 124430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro/* 124530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Returns the identity hash code of the given object. 124630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 124730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapirou4 dvmIdentityHashCode(Object *obj) 124830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro{ 124930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro Thread *self, *thread; 125030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro volatile u4 *lw; 125130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro size_t length; 125230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro u4 lock, owner, hashState; 125330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro 125430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (obj == NULL) { 125530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 125630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Null is defined to have an identity hash code of 0. 125730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 125830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return 0; 125930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 126030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lw = &obj->lock; 126130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiroretry: 126230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro hashState = LW_HASH_STATE(*lw); 126330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (hashState == LW_HASH_STATE_HASHED) { 126430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 126530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The object has been hashed but has not had its hash code 126630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * relocated by the garbage collector. Use the raw object 126730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * address. 126830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 126930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 127030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else if (hashState == LW_HASH_STATE_HASHED_AND_MOVED) { 127130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 127230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The object has been hashed and its hash code has been 127330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * relocated by the collector. Use the value of the naturally 127430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * aligned word following the instance data. 127530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 127630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISARRAY)) { 127730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro length = arrayObjectLength((ArrayObject *)obj); 127830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro length = (length + 3) & ~3; 127930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 128030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro length = obj->clazz->objectSize; 128130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 128230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return *(u4 *)(((char *)obj) + length); 128330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else if (hashState == LW_HASH_STATE_UNHASHED) { 128430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 128530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The object has never been hashed. Change the hash state to 128630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * hashed and use the raw object address. 128730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 128830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro self = dvmThreadSelf(); 128930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (self->threadId == lockOwner(obj)) { 129030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 129130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * We already own the lock so we can update the hash state 129230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * directly. 129330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 129430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro *lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 129530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 129630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 129730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 129830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * We do not own the lock. Try acquiring the lock. Should 129930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * this fail, we must suspend the owning thread. 130030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 130130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (LW_SHAPE(*lw) == LW_SHAPE_THIN) { 130230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 130330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * If the lock is thin assume it is unowned. We simulate 130430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * an acquire, update, and release with a single CAS. 130530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 130630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lock = DVM_LOCK_INITIAL_THIN_VALUE; 130730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lock |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 130830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (ATOMIC_CMP_SWAP((int32_t *)lw, 130930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro (int32_t)DVM_LOCK_INITIAL_THIN_VALUE, 131030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro (int32_t)lock)) { 131130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 131230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * A new lockword has been installed with a hash state 131330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * of hashed. Use the raw object address. 131430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 131530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 131630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 131730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 131830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (tryLockMonitor(self, LW_MONITOR(*lw))) { 131930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 132030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The monitor lock has been acquired. Change the 132130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * hash state to hashed and use the raw object 132230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * address. 132330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 132430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro *lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 132530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro unlockMonitor(self, LW_MONITOR(*lw)); 132630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 132730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 132830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 132930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 133030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * At this point we have failed to acquire the lock. We must 133130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * identify the owning thread and suspend it. 133230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 133330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmLockThreadList(self); 133430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 133530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Cache the lock word as its value can change between 133630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * determining its shape and retrieving its owner. 133730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 133830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro lock = *lw; 133930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (LW_SHAPE(lock) == LW_SHAPE_THIN) { 134030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 134130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Find the thread with the corresponding thread id. 134230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 134330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro owner = LW_LOCK_OWNER(lock); 134430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro assert(owner != self->threadId); 134530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 134630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * If the lock has no owner do not bother scanning the 134730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * thread list and fall through to the failure handler. 134830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 134930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro thread = owner ? gDvm.threadList : NULL; 135030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro while (thread != NULL) { 135130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (thread->threadId == owner) { 135230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro break; 135330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 135430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro thread = thread->next; 135530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 135630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } else { 135730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro thread = LW_MONITOR(lock)->owner; 135830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 135930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 136030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * If thread is NULL the object has been released since the 136130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * thread list lock was acquired. Try again. 136230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 136330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (thread == NULL) { 136430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmUnlockThreadList(); 136530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro goto retry; 136630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 136730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 136830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * Wait for the owning thread to suspend. 136930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 137030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmSuspendThread(thread); 137130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro if (dvmHoldsLock(thread, obj)) { 137230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 137330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The owning thread has been suspended. We can safely 137430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * change the hash state to hashed. 137530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 137630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro *lw |= (LW_HASH_STATE_HASHED << LW_HASH_STATE_SHIFT); 137730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmResumeThread(thread); 137830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmUnlockThreadList(); 137930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return (u4)obj >> 3; 138030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 138130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro /* 138230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro * The wrong thread has been suspended. Try again. 138330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro */ 138430aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmResumeThread(thread); 138530aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmUnlockThreadList(); 138630aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro goto retry; 138730aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro } 138830aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro LOGE("object %p has an unknown hash state %#x", obj, hashState); 138930aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmDumpThread(dvmThreadSelf(), false); 139030aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro dvmAbort(); 139130aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro return 0; /* Quiet the compiler. */ 139230aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro} 139330aa99778069baf0dab767f0fc1f5b1d51d110ffCarl Shapiro#endif /* WITH_COPYING_GC */ 1394f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1395f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 1396f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1397f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * =========================================================================== 1398f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Deadlock prediction 1399f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * =========================================================================== 1400f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1401f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1402f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectThe idea is to predict the possibility of deadlock by recording the order 1403f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectin which monitors are acquired. If we see an attempt to acquire a lock 1404f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectout of order, we can identify the locks and offending code. 1405f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1406f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectTo make this work, we need to keep track of the locks held by each thread, 1407f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectand create history trees for each lock. When a thread tries to acquire 1408f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projecta new lock, we walk through the "history children" of the lock, looking 1409f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectfor a match with locks the thread already holds. If we find a match, 1410f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectit means the thread has made a request that could result in a deadlock. 1411f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1412f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectTo support recursive locks, we always allow re-locking a currently-held 1413f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectlock, and maintain a recursion depth count. 1414f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1415f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectAn ASCII-art example, where letters represent Objects: 1416f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1417f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project A 1418f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /|\ 1419f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project / | \ 1420f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project B | D 1421f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project \ | 1422f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project \| 1423f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project C 1424f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1425f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectThe above is the tree we'd have after handling Object synchronization 1426f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectsequences "ABC", "AC", "AD". A has three children, {B, C, D}. C is also 1427f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projecta child of B. (The lines represent pointers between parent and child. 1428f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectEvery node can have multiple parents and multiple children.) 1429f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1430f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectIf we hold AC, and want to lock B, we recursively search through B's 1431f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectchildren to see if A or C appears. It does, so we reject the attempt. 1432f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project(A straightforward way to implement it: add a link from C to B, then 1433f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectdetermine whether the graph starting at B contains a cycle.) 1434f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1435f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectIf we hold AC and want to lock D, we would succeed, creating a new link 1436f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectfrom C to D. 1437f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1438f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectThe lock history and a stack trace is attached to the Object's Monitor 1439f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstruct, which means we need to fatten every Object we lock (thin locking 1440f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectis effectively disabled). If we don't need the stack trace we can 1441f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectavoid fattening the leaf nodes, only fattening objects that need to hold 1442f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projecthistory trees. 1443f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1444f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectUpdates to Monitor structs are only allowed for the thread that holds 1445f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectthe Monitor, so we actually do most of our deadlock prediction work after 1446f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectthe lock has been acquired. 1447f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1448f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectWhen an object with a monitor is GCed, we need to remove it from the 1449f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projecthistory trees. There are two basic approaches: 1450f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (1) For through the entire set of known monitors, search all child 1451f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lists for the object in question. This is rather slow, resulting 1452f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project in GC passes that take upwards of 10 seconds to complete. 1453f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (2) Maintain "parent" pointers in each node. Remove the entries as 1454f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project required. This requires additional storage and maintenance for 1455f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project every operation, but is significantly faster at GC time. 1456f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectFor each GCed object, we merge all of the object's children into each of 1457f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectthe object's parents. 1458f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project*/ 1459f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1460f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if !defined(WITH_MONITOR_TRACKING) 1461f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project# error "WITH_DEADLOCK_PREDICTION requires WITH_MONITOR_TRACKING" 1462f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 1463f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1464f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1465f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Clear out the contents of an ExpandingObjectList, freeing any 1466f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * dynamic allocations. 1467f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1468f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void expandObjClear(ExpandingObjectList* pList) 1469f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1470f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (pList->list != NULL) { 1471f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project free(pList->list); 1472f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->list = NULL; 1473f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1474f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->alloc = pList->count = 0; 1475f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1476f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1477f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1478f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Get the number of objects currently stored in the list. 1479f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1480f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic inline int expandBufGetCount(const ExpandingObjectList* pList) 1481f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1482f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return pList->count; 1483f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1484f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1485f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1486f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Get the Nth entry from the list. 1487f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1488f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic inline Object* expandBufGetEntry(const ExpandingObjectList* pList, 1489f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i) 1490f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1491f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return pList->list[i]; 1492f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1493f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1494f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1495f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Add a new entry to the list. 1496f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1497f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We don't check for or try to enforce uniqueness. It's expected that 1498f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the higher-level code does this for us. 1499f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1500f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void expandObjAddEntry(ExpandingObjectList* pList, Object* obj) 1501f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1502f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (pList->count == pList->alloc) { 1503f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* time to expand */ 1504f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object** newList; 1505f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1506f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (pList->alloc == 0) 1507f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->alloc = 4; 1508f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project else 1509f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->alloc *= 2; 1510f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGVV("expanding %p to %d\n", pList, pList->alloc); 1511f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project newList = realloc(pList->list, pList->alloc * sizeof(Object*)); 1512f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (newList == NULL) { 1513f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGE("Failed expanding DP object list (alloc=%d)\n", pList->alloc); 1514f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAbort(); 1515f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1516f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->list = newList; 1517f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1518f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1519f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->list[pList->count++] = obj; 1520f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1521f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1522f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1523f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns "true" if the element was successfully removed. 1524f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1525f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool expandObjRemoveEntry(ExpandingObjectList* pList, Object* obj) 1526f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1527f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i; 1528f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1529f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = pList->count-1; i >= 0; i--) { 1530f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (pList->list[i] == obj) 1531f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project break; 1532f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1533f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (i < 0) 1534f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1535f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1536f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (i != pList->count-1) { 1537f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1538f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The order of elements is not important, so we just copy the 1539f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * last entry into the new slot. 1540f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1541f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project //memmove(&pList->list[i], &pList->list[i+1], 1542f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project // (pList->count-1 - i) * sizeof(pList->list[0])); 1543f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->list[i] = pList->list[pList->count-1]; 1544f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1545f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1546f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->count--; 1547f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList->list[pList->count] = (Object*) 0xdecadead; 1548f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 1549f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1550f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1551f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1552f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns "true" if "obj" appears in the list. 1553f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1554f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool expandObjHas(const ExpandingObjectList* pList, Object* obj) 1555f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1556f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i; 1557f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1558f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = 0; i < pList->count; i++) { 1559f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (pList->list[i] == obj) 1560f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 1561f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1562f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1563f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1564f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1565f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1566f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Print the list contents to stdout. For debugging. 1567f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1568f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void expandObjDump(const ExpandingObjectList* pList) 1569f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1570f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i; 1571f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = 0; i < pList->count; i++) 1572f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project printf(" %p", pList->list[i]); 1573f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1574f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1575f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1576f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Check for duplicate entries. Returns the index of the first instance 1577f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * of the duplicated value, or -1 if no duplicates were found. 1578f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1579f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic int expandObjCheckForDuplicates(const ExpandingObjectList* pList) 1580f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1581f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i, j; 1582f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = 0; i < pList->count-1; i++) { 1583f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (j = i + 1; j < pList->count; j++) { 1584f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (pList->list[i] == pList->list[j]) { 1585f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return i; 1586f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1587f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1588f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1589f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1590f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return -1; 1591f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1592f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1593f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1594f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1595f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Determine whether "child" appears in the list of objects associated 1596f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * with the Monitor in "parent". If "parent" is a thin lock, we return 1597f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * false immediately. 1598f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1599f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool objectInChildList(const Object* parent, Object* child) 1600f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 16018d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 lock = parent->lock; 1602f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!IS_LOCK_FAT(&lock)) { 1603f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project //LOGI("on thin\n"); 1604f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1605f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1606f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 16078d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro return expandObjHas(&LW_MONITOR(lock)->historyChildren, child); 1608f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1609f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1610f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1611f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Print the child list. 1612f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1613f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void dumpKids(Object* parent) 1614f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 16158d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro Monitor* mon = LW_MONITOR(parent->lock); 1616f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1617f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project printf("Children of %p:", parent); 1618f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project expandObjDump(&mon->historyChildren); 1619f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project printf("\n"); 1620f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1621f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1622f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1623f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Add "child" to the list of children in "parent", and add "parent" to 1624f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the list of parents in "child". 1625f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1626f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void linkParentToChild(Object* parent, Object* child) 1627f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 16288d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro //assert(LW_MONITOR(parent->lock)->owner == dvmThreadSelf()); // !owned for merge 1629f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(IS_LOCK_FAT(&parent->lock)); 1630f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(IS_LOCK_FAT(&child->lock)); 1631f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(parent != child); 1632f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 1633f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 16348d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mon = LW_MONITOR(parent->lock); 1635f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!expandObjHas(&mon->historyChildren, child)); 1636f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project expandObjAddEntry(&mon->historyChildren, child); 1637f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 16388d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mon = LW_MONITOR(child->lock); 1639f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!expandObjHas(&mon->historyParents, parent)); 1640f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project expandObjAddEntry(&mon->historyParents, parent); 1641f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1642f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1643f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1644f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1645f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Remove "child" from the list of children in "parent". 1646f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1647f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void unlinkParentFromChild(Object* parent, Object* child) 1648f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 16498d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro //assert(LW_MONITOR(parent->lock)->owner == dvmThreadSelf()); // !owned for GC 1650f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(IS_LOCK_FAT(&parent->lock)); 1651f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(IS_LOCK_FAT(&child->lock)); 1652f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(parent != child); 1653f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 1654f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 16558d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mon = LW_MONITOR(parent->lock); 1656f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!expandObjRemoveEntry(&mon->historyChildren, child)) { 1657f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("WARNING: child %p not found in parent %p\n", child, parent); 1658f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1659f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!expandObjHas(&mon->historyChildren, child)); 1660f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(expandObjCheckForDuplicates(&mon->historyChildren) < 0); 1661f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 16628d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mon = LW_MONITOR(child->lock); 1663f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!expandObjRemoveEntry(&mon->historyParents, parent)) { 1664f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("WARNING: parent %p not found in child %p\n", parent, child); 1665f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1666f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!expandObjHas(&mon->historyParents, parent)); 1667f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(expandObjCheckForDuplicates(&mon->historyParents) < 0); 1668f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1669f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1670f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1671f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1672f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Log the monitors held by the current thread. This is done as part of 1673f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * flagging an error. 1674f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1675f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void logHeldMonitors(Thread* self) 1676f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1677f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project char* name = NULL; 1678f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1679f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project name = dvmGetThreadName(self); 1680f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("Monitors currently held by thread (threadid=%d '%s')\n", 1681f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->threadId, name); 1682f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("(most-recently-acquired on top):\n"); 1683f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project free(name); 1684f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1685f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LockedObjectData* lod = self->pLockedObjects; 1686f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project while (lod != NULL) { 1687f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("--- object %p[%d] (%s)\n", 1688f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lod->obj, lod->recursionCount, lod->obj->clazz->descriptor); 1689f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLogRawStackTrace(lod->rawStackTrace, lod->stackDepth); 1690f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1691f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lod = lod->next; 1692f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1693f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1694f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1695f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1696f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Recursively traverse the object hierarchy starting at "obj". We mark 1697f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * ourselves on entry and clear the mark on exit. If we ever encounter 1698f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a marked object, we have a cycle. 1699f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1700f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns "true" if all is well, "false" if we found a cycle. 1701f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1702f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic bool traverseTree(Thread* self, const Object* obj) 1703f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1704f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(IS_LOCK_FAT(&obj->lock)); 17058d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro Monitor* mon = LW_MONITOR(obj->lock); 1706f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1707f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1708f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Have we been here before? 1709f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1710f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mon->historyMark) { 1711f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int* rawStackTrace; 1712f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int stackDepth; 1713f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1714f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("%s\n", kStartBanner); 1715f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("Illegal lock attempt:\n"); 1716f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("--- object %p (%s)\n", obj, obj->clazz->descriptor); 1717f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1718f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project rawStackTrace = dvmFillInStackTraceRaw(self, &stackDepth); 1719f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLogRawStackTrace(rawStackTrace, stackDepth); 1720f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project free(rawStackTrace); 1721f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1722f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW(" "); 1723f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project logHeldMonitors(self); 1724f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1725f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW(" "); 1726f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("Earlier, the following lock order (from last to first) was\n"); 1727f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("established -- stack trace is from first successful lock):\n"); 1728f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1729f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1730f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->historyMark = true; 1731f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1732f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1733f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Examine the children. We do NOT hold these locks, so they might 1734f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * very well transition from thin to fat or change ownership while 1735f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we work. 1736f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1737f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * NOTE: we rely on the fact that they cannot revert from fat to thin 1738f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * while we work. This is currently a safe assumption. 1739f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1740f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We can safely ignore thin-locked children, because by definition 1741f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * they have no history and are leaf nodes. In the current 1742f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * implementation we always fatten the locks to provide a place to 1743f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * hang the stack trace. 1744f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1745f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ExpandingObjectList* pList = &mon->historyChildren; 1746f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i; 1747f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = expandBufGetCount(pList)-1; i >= 0; i--) { 1748f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project const Object* child = expandBufGetEntry(pList, i); 17498d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 lock = child->lock; 1750f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!IS_LOCK_FAT(&lock)) 1751f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project continue; 1752f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!traverseTree(self, child)) { 1753f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("--- object %p (%s)\n", obj, obj->clazz->descriptor); 1754f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLogRawStackTrace(mon->historyRawStackTrace, 1755f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->historyStackDepth); 1756f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->historyMark = false; 1757f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 1758f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1759f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1760f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1761f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->historyMark = false; 1762f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1763f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 1764f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1765f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1766f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1767f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Update the deadlock prediction tree, based on the current thread 1768f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * acquiring "acqObj". This must be called before the object is added to 1769f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the thread's list of held monitors. 1770f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1771f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If the thread already holds the lock (recursion), or this is a known 1772f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * lock configuration, we return without doing anything. Otherwise, we add 1773f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a link from the most-recently-acquired lock in this thread to "acqObj" 1774f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * after ensuring that the parent lock is "fat". 1775f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1776f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This MUST NOT be called while a GC is in progress in another thread, 1777f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * because we assume exclusive access to history trees in owned monitors. 1778f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1779f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void updateDeadlockPrediction(Thread* self, Object* acqObj) 1780f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1781f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LockedObjectData* lod; 1782f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LockedObjectData* mrl; 1783f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1784f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1785f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Quick check for recursive access. 1786f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1787f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lod = dvmFindInMonitorList(self, acqObj); 1788f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (lod != NULL) { 1789f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGV("+++ DP: recursive %p\n", acqObj); 1790f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1791f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1792f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1793f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1794f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Make the newly-acquired object's monitor "fat". In some ways this 1795f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * isn't strictly necessary, but we need the GC to tell us when 1796f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * "interesting" objects go away, and right now the only way to make 1797f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * an object look interesting is to give it a monitor. 1798f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1799f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This also gives us a place to hang a stack trace. 1800f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1801f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Our thread holds the lock, so we're allowed to rewrite the lock 1802f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * without worrying that something will change out from under us. 1803f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1804f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!IS_LOCK_FAT(&acqObj->lock)) { 1805f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGVV("fattening lockee %p (recur=%d)\n", 180694338aadf8355b28846f0d21c49142ca29479dc4Carl Shapiro acqObj, LW_LOCK_COUNT(acqObj->lock.thin)); 1807f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* newMon = dvmCreateMonitor(acqObj); 1808f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lockMonitor(self, newMon); // can't stall, don't need VMWAIT 18098d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro newMon->lockCount += LW_LOCK_COUNT(acqObj->lock); 18108d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 hashState = LW_HASH_STATE(acqObj->lock) << LW_HASH_STATE_SHIFT; 18118d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro acqObj->lock = (u4)newMon | hashState | LW_SHAPE_FAT; 1812f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1813f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1814f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* if we don't have a stack trace for this monitor, establish one */ 18158d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro if (LW_MONITOR(acqObj->lock)->historyRawStackTrace == NULL) { 18168d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro Monitor* mon = LW_MONITOR(acqObj->lock); 1817f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon->historyRawStackTrace = dvmFillInStackTraceRaw(self, 1818f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project &mon->historyStackDepth); 1819f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1820f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1821f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1822f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We need to examine and perhaps modify the most-recently-locked 1823f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * monitor. We own that, so there's no risk of another thread 1824f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * stepping on us. 1825f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1826f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Retrieve the most-recently-locked entry from our thread. 1827f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1828f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mrl = self->pLockedObjects; 1829f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (mrl == NULL) 1830f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; /* no other locks held */ 1831f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1832f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1833f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Do a quick check to see if "acqObj" is a direct descendant. We can do 1834f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * this without holding the global lock because of our assertion that 1835f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a GC is not running in parallel -- nobody except the GC can 1836f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * modify a history list in a Monitor they don't own, and we own "mrl". 1837f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (There might be concurrent *reads*, but no concurrent *writes.) 1838f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1839f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If we find it, this is a known good configuration, and we're done. 1840f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1841f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (objectInChildList(mrl->obj, acqObj)) 1842f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 1843f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1844f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1845f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * "mrl" is going to need to have a history tree. If it's currently 1846f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a thin lock, we make it fat now. The thin lock might have a 1847f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * nonzero recursive lock count, which we need to carry over. 1848f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1849f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Our thread holds the lock, so we're allowed to rewrite the lock 1850f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * without worrying that something will change out from under us. 1851f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1852f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!IS_LOCK_FAT(&mrl->obj->lock)) { 1853f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGVV("fattening parent %p f/b/o child %p (recur=%d)\n", 18548d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mrl->obj, acqObj, LW_LOCK_COUNT(mrl->obj->lock)); 1855f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* newMon = dvmCreateMonitor(mrl->obj); 1856f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project lockMonitor(self, newMon); // can't stall, don't need VMWAIT 18578d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro newMon->lockCount += LW_LOCK_COUNT(mrl->obj->lock); 18588d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro u4 hashState = LW_HASH_STATE(mrl->obj->lock) << LW_HASH_STATE_SHIFT; 18598d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mrl->obj->lock = (u4)newMon | hashState | LW_SHAPE_FAT; 1860f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1861f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1862f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1863f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We haven't seen this configuration before. We need to scan down 1864f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * acqObj's tree to see if any of the monitors in self->pLockedObjects 1865f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * appear. We grab a global lock before traversing or updating the 1866f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * history list. 1867f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1868f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If we find a match for any of our held locks, we know that the lock 1869f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * has previously been acquired *after* acqObj, and we throw an error. 1870f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1871f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The easiest way to do this is to create a link from "mrl" to "acqObj" 1872f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * and do a recursive traversal, marking nodes as we cross them. If 1873f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we cross one a second time, we have a cycle and can throw an error. 1874f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (We do the flag-clearing traversal before adding the new link, so 1875f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * that we're guaranteed to terminate.) 1876f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1877f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If "acqObj" is a thin lock, it has no history, and we can create a 1878f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * link to it without additional checks. [ We now guarantee that it's 1879f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * always fat. ] 1880f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1881f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project bool failed = false; 1882f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLockMutex(&gDvm.deadlockHistoryLock); 1883f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project linkParentToChild(mrl->obj, acqObj); 1884f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!traverseTree(self, acqObj)) { 1885f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("%s\n", kEndBanner); 1886f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project failed = true; 1887f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1888f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* remove the entry so we're still okay when in "warning" mode */ 1889f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unlinkParentFromChild(mrl->obj, acqObj); 1890f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1891f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockMutex(&gDvm.deadlockHistoryLock); 1892f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1893f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (failed) { 1894f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project switch (gDvm.deadlockPredictMode) { 1895f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case kDPErr: 1896f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ldalvik/system/PotentialDeadlockError;", NULL); 1897f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project break; 1898f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project case kDPAbort: 1899f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGE("Aborting due to potential deadlock\n"); 1900f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAbort(); 1901f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project break; 1902f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project default: 1903f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* warn only */ 1904f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project break; 1905f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1906f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1907f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1908f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1909f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1910f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We're removing "child" from existence. We want to pull all of 1911f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * child's children into "parent", filtering out duplicates. This is 1912f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * called during the GC. 1913f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1914f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This does not modify "child", which might have multiple parents. 1915f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1916f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void mergeChildren(Object* parent, const Object* child) 1917f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1918f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 1919f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i; 1920f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1921f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(IS_LOCK_FAT(&child->lock)); 19228d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mon = LW_MONITOR(child->lock); 1923f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ExpandingObjectList* pList = &mon->historyChildren; 1924f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1925f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = expandBufGetCount(pList)-1; i >= 0; i--) { 1926f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object* grandChild = expandBufGetEntry(pList, i); 1927f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1928f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!objectInChildList(parent, grandChild)) { 1929f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGVV("+++ migrating %p link to %p\n", grandChild, parent); 1930f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project linkParentToChild(parent, grandChild); 1931f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 1932f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGVV("+++ parent %p already links to %p\n", parent, grandChild); 1933f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1934f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1935f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 1936f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1937f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 1938f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * An object with a fat lock is being collected during a GC pass. We 1939f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * want to remove it from any lock history trees that it is a part of. 1940f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1941f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This may require updating the history trees in several monitors. The 1942f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * monitor semantics guarantee that no other thread will be accessing 1943f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the history trees at the same time. 1944f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1945f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void removeCollectedObject(Object* obj) 1946f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1947f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Monitor* mon; 1948f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1949f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGVV("+++ collecting %p\n", obj); 1950f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1951f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if 0 1952f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1953f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We're currently running through the entire set of known monitors. 1954f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This can be somewhat slow. We may want to keep lists of parents 1955f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in each child to speed up GC. 1956f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1957f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = gDvm.monitorList; 1958f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project while (mon != NULL) { 1959f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object* parent = mon->obj; 1960f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (parent != NULL) { /* value nulled for deleted entries */ 1961f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (objectInChildList(parent, obj)) { 1962f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGVV("removing child %p from parent %p\n", obj, parent); 1963f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project unlinkParentFromChild(parent, obj); 1964f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mergeChildren(parent, obj); 1965f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1966f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1967f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mon = mon->next; 1968f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1969f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 1970f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1971f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1972f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * For every parent of this object: 1973f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - merge all of our children into the parent's child list (creates 1974f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a two-way link between parent and child) 1975f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - remove ourselves from the parent's child list 1976f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1977f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ExpandingObjectList* pList; 1978f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int i; 1979f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1980f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(IS_LOCK_FAT(&obj->lock)); 19818d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro mon = LW_MONITOR(obj->lock); 1982f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList = &mon->historyParents; 1983f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = expandBufGetCount(pList)-1; i >= 0; i--) { 1984f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object* parent = expandBufGetEntry(pList, i); 19858d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro Monitor* parentMon = LW_MONITOR(parent->lock); 1986f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1987f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!expandObjRemoveEntry(&parentMon->historyChildren, obj)) { 1988f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("WARNING: child %p not found in parent %p\n", obj, parent); 1989f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1990f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!expandObjHas(&parentMon->historyChildren, obj)); 1991f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1992f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project mergeChildren(parent, obj); 1993f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 1994f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 1995f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 1996f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * For every child of this object: 1997f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - remove ourselves from the child's parent list 1998f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 1999f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project pList = &mon->historyChildren; 2000f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project for (i = expandBufGetCount(pList)-1; i >= 0; i--) { 2001f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object* child = expandBufGetEntry(pList, i); 20028d7f9b2cd9fe252399ae96a36781bba1242fb93cCarl Shapiro Monitor* childMon = LW_MONITOR(child->lock); 2003f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 2004f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!expandObjRemoveEntry(&childMon->historyParents, obj)) { 2005f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW("WARNING: parent %p not found in child %p\n", obj, child); 2006f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 2007f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!expandObjHas(&childMon->historyParents, obj)); 2008f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 2009f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 2010f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 2011f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif /*WITH_DEADLOCK_PREDICTION*/ 2012