Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2013 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "object_registry.h" |
| 18 | |
Sebastien Hertz | e2d628b | 2014-10-23 15:39:33 +0200 | [diff] [blame] | 19 | #include "handle_scope-inl.h" |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 20 | #include "jni_internal.h" |
Ian Rogers | e63db27 | 2014-07-15 15:36:11 -0700 | [diff] [blame] | 21 | #include "mirror/class.h" |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 22 | #include "scoped_thread_state_change.h" |
| 23 | |
| 24 | namespace art { |
| 25 | |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 26 | std::ostream& operator<<(std::ostream& os, const ObjectRegistryEntry& rhs) { |
| 27 | os << "ObjectRegistryEntry[" << rhs.jni_reference_type |
| 28 | << ",reference=" << rhs.jni_reference |
| 29 | << ",count=" << rhs.reference_count |
| 30 | << ",id=" << rhs.id << "]"; |
| 31 | return os; |
| 32 | } |
| 33 | |
Elliott Hughes | 0f82716 | 2013-02-26 12:12:58 -0800 | [diff] [blame] | 34 | ObjectRegistry::ObjectRegistry() |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 35 | : lock_("ObjectRegistry lock", kJdwpObjectRegistryLock), next_id_(1) { |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 36 | } |
| 37 | |
| 38 | JDWP::RefTypeId ObjectRegistry::AddRefType(mirror::Class* c) { |
| 39 | return InternalAdd(c); |
| 40 | } |
| 41 | |
| 42 | JDWP::ObjectId ObjectRegistry::Add(mirror::Object* o) { |
| 43 | return InternalAdd(o); |
| 44 | } |
| 45 | |
| 46 | JDWP::ObjectId ObjectRegistry::InternalAdd(mirror::Object* o) { |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 47 | if (o == nullptr) { |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 48 | return 0; |
| 49 | } |
| 50 | |
Sebastien Hertz | e2d628b | 2014-10-23 15:39:33 +0200 | [diff] [blame] | 51 | Thread* const self = Thread::Current(); |
Sebastien Hertz | e4266c5 | 2014-10-29 12:06:51 +0100 | [diff] [blame] | 52 | self->AssertNoPendingException(); |
| 53 | |
Sebastien Hertz | e2d628b | 2014-10-23 15:39:33 +0200 | [diff] [blame] | 54 | StackHandleScope<1> hs(self); |
| 55 | Handle<mirror::Object> obj_h(hs.NewHandle(o)); |
| 56 | |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 57 | // Call IdentityHashCode here to avoid a lock level violation between lock_ and monitor_lock. |
Sebastien Hertz | e2d628b | 2014-10-23 15:39:33 +0200 | [diff] [blame] | 58 | int32_t identity_hash_code = obj_h->IdentityHashCode(); |
| 59 | |
| 60 | ScopedObjectAccessUnchecked soa(self); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 61 | MutexLock mu(soa.Self(), lock_); |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 62 | ObjectRegistryEntry* entry = nullptr; |
Sebastien Hertz | e2d628b | 2014-10-23 15:39:33 +0200 | [diff] [blame] | 63 | if (ContainsLocked(soa.Self(), obj_h.Get(), identity_hash_code, &entry)) { |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 64 | // This object was already in our map. |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 65 | ++entry->reference_count; |
| 66 | } else { |
| 67 | entry = new ObjectRegistryEntry; |
| 68 | entry->jni_reference_type = JNIWeakGlobalRefType; |
| 69 | entry->jni_reference = nullptr; |
| 70 | entry->reference_count = 0; |
| 71 | entry->id = 0; |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 72 | entry->identity_hash_code = identity_hash_code; |
| 73 | object_to_entry_.insert(std::make_pair(identity_hash_code, entry)); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 74 | |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 75 | // This object isn't in the registry yet, so add it. |
| 76 | JNIEnv* env = soa.Env(); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 77 | |
Sebastien Hertz | e2d628b | 2014-10-23 15:39:33 +0200 | [diff] [blame] | 78 | jobject local_reference = soa.AddLocalReference<jobject>(obj_h.Get()); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 79 | |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 80 | entry->jni_reference_type = JNIWeakGlobalRefType; |
| 81 | entry->jni_reference = env->NewWeakGlobalRef(local_reference); |
| 82 | entry->reference_count = 1; |
| 83 | entry->id = next_id_++; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 84 | |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 85 | id_to_entry_.Put(entry->id, entry); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 86 | |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 87 | env->DeleteLocalRef(local_reference); |
| 88 | } |
| 89 | return entry->id; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 90 | } |
| 91 | |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 92 | bool ObjectRegistry::ContainsLocked(Thread* self, mirror::Object* o, int32_t identity_hash_code, |
| 93 | ObjectRegistryEntry** out_entry) { |
| 94 | DCHECK(o != nullptr); |
| 95 | for (auto it = object_to_entry_.lower_bound(identity_hash_code), end = object_to_entry_.end(); |
| 96 | it != end && it->first == identity_hash_code; ++it) { |
| 97 | ObjectRegistryEntry* entry = it->second; |
| 98 | if (o == self->DecodeJObject(entry->jni_reference)) { |
| 99 | if (out_entry != nullptr) { |
| 100 | *out_entry = entry; |
| 101 | } |
| 102 | return true; |
| 103 | } |
| 104 | } |
| 105 | return false; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 106 | } |
| 107 | |
| 108 | void ObjectRegistry::Clear() { |
Sebastien Hertz | 55f6534 | 2015-01-13 22:48:34 +0100 | [diff] [blame] | 109 | Thread* const self = Thread::Current(); |
| 110 | |
| 111 | // We must not hold the mutator lock exclusively if we want to delete weak global |
| 112 | // references. Otherwise this can lead to a deadlock with a running GC: |
| 113 | // 1. GC thread disables access to weak global references, then releases |
| 114 | // mutator lock. |
| 115 | // 2. JDWP thread takes mutator lock exclusively after suspending all |
| 116 | // threads. |
| 117 | // 3. GC thread waits for shared mutator lock which is held by JDWP |
| 118 | // thread. |
| 119 | // 4. JDWP thread clears weak global references but need to wait for GC |
| 120 | // thread to re-enable access to them. |
| 121 | Locks::mutator_lock_->AssertNotExclusiveHeld(self); |
| 122 | |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 123 | MutexLock mu(self, lock_); |
| 124 | VLOG(jdwp) << "Object registry contained " << object_to_entry_.size() << " entries"; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 125 | // Delete all the JNI references. |
| 126 | JNIEnv* env = self->GetJniEnv(); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 127 | for (const auto& pair : object_to_entry_) { |
Sebastien Hertz | a032870 | 2014-06-25 22:06:12 +0200 | [diff] [blame] | 128 | const ObjectRegistryEntry* entry = pair.second; |
| 129 | if (entry->jni_reference_type == JNIWeakGlobalRefType) { |
| 130 | env->DeleteWeakGlobalRef(entry->jni_reference); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 131 | } else { |
Sebastien Hertz | a032870 | 2014-06-25 22:06:12 +0200 | [diff] [blame] | 132 | env->DeleteGlobalRef(entry->jni_reference); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 133 | } |
Sebastien Hertz | a032870 | 2014-06-25 22:06:12 +0200 | [diff] [blame] | 134 | delete entry; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 135 | } |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 136 | // Clear the maps. |
| 137 | object_to_entry_.clear(); |
| 138 | id_to_entry_.clear(); |
| 139 | } |
| 140 | |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 141 | mirror::Object* ObjectRegistry::InternalGet(JDWP::ObjectId id, JDWP::JdwpError* error) { |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 142 | Thread* self = Thread::Current(); |
| 143 | MutexLock mu(self, lock_); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 144 | auto it = id_to_entry_.find(id); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 145 | if (it == id_to_entry_.end()) { |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 146 | *error = JDWP::ERR_INVALID_OBJECT; |
| 147 | return nullptr; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 148 | } |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 149 | ObjectRegistryEntry& entry = *it->second; |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 150 | *error = JDWP::ERR_NONE; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 151 | return self->DecodeJObject(entry.jni_reference); |
| 152 | } |
| 153 | |
Jeff Hao | 449db33 | 2013-04-12 18:30:52 -0700 | [diff] [blame] | 154 | jobject ObjectRegistry::GetJObject(JDWP::ObjectId id) { |
Sebastien Hertz | 0630ab5 | 2013-11-28 18:53:35 +0100 | [diff] [blame] | 155 | if (id == 0) { |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 156 | return nullptr; |
Sebastien Hertz | 0630ab5 | 2013-11-28 18:53:35 +0100 | [diff] [blame] | 157 | } |
Jeff Hao | 449db33 | 2013-04-12 18:30:52 -0700 | [diff] [blame] | 158 | Thread* self = Thread::Current(); |
| 159 | MutexLock mu(self, lock_); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 160 | auto it = id_to_entry_.find(id); |
Jeff Hao | 449db33 | 2013-04-12 18:30:52 -0700 | [diff] [blame] | 161 | CHECK(it != id_to_entry_.end()) << id; |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 162 | ObjectRegistryEntry& entry = *it->second; |
Jeff Hao | 449db33 | 2013-04-12 18:30:52 -0700 | [diff] [blame] | 163 | return entry.jni_reference; |
| 164 | } |
| 165 | |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 166 | void ObjectRegistry::DisableCollection(JDWP::ObjectId id) { |
| 167 | Thread* self = Thread::Current(); |
| 168 | MutexLock mu(self, lock_); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 169 | auto it = id_to_entry_.find(id); |
Sebastien Hertz | e96060a | 2013-12-11 12:06:28 +0100 | [diff] [blame] | 170 | CHECK(it != id_to_entry_.end()); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 171 | Promote(*it->second); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | void ObjectRegistry::EnableCollection(JDWP::ObjectId id) { |
| 175 | Thread* self = Thread::Current(); |
| 176 | MutexLock mu(self, lock_); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 177 | auto it = id_to_entry_.find(id); |
Sebastien Hertz | e96060a | 2013-12-11 12:06:28 +0100 | [diff] [blame] | 178 | CHECK(it != id_to_entry_.end()); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 179 | Demote(*it->second); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | void ObjectRegistry::Demote(ObjectRegistryEntry& entry) { |
| 183 | if (entry.jni_reference_type == JNIGlobalRefType) { |
| 184 | Thread* self = Thread::Current(); |
| 185 | JNIEnv* env = self->GetJniEnv(); |
| 186 | jobject global = entry.jni_reference; |
| 187 | entry.jni_reference = env->NewWeakGlobalRef(entry.jni_reference); |
| 188 | entry.jni_reference_type = JNIWeakGlobalRefType; |
| 189 | env->DeleteGlobalRef(global); |
| 190 | } |
| 191 | } |
| 192 | |
| 193 | void ObjectRegistry::Promote(ObjectRegistryEntry& entry) { |
| 194 | if (entry.jni_reference_type == JNIWeakGlobalRefType) { |
| 195 | Thread* self = Thread::Current(); |
| 196 | JNIEnv* env = self->GetJniEnv(); |
| 197 | jobject weak = entry.jni_reference; |
| 198 | entry.jni_reference = env->NewGlobalRef(entry.jni_reference); |
| 199 | entry.jni_reference_type = JNIGlobalRefType; |
| 200 | env->DeleteWeakGlobalRef(weak); |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | bool ObjectRegistry::IsCollected(JDWP::ObjectId id) { |
| 205 | Thread* self = Thread::Current(); |
| 206 | MutexLock mu(self, lock_); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 207 | auto it = id_to_entry_.find(id); |
Sebastien Hertz | e96060a | 2013-12-11 12:06:28 +0100 | [diff] [blame] | 208 | CHECK(it != id_to_entry_.end()); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 209 | ObjectRegistryEntry& entry = *it->second; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 210 | if (entry.jni_reference_type == JNIWeakGlobalRefType) { |
| 211 | JNIEnv* env = self->GetJniEnv(); |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 212 | return env->IsSameObject(entry.jni_reference, nullptr); // Has the jweak been collected? |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 213 | } else { |
Brian Carlstrom | 7934ac2 | 2013-07-26 10:54:15 -0700 | [diff] [blame] | 214 | return false; // We hold a strong reference, so we know this is live. |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 215 | } |
| 216 | } |
| 217 | |
| 218 | void ObjectRegistry::DisposeObject(JDWP::ObjectId id, uint32_t reference_count) { |
| 219 | Thread* self = Thread::Current(); |
| 220 | MutexLock mu(self, lock_); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 221 | auto it = id_to_entry_.find(id); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 222 | if (it == id_to_entry_.end()) { |
| 223 | return; |
| 224 | } |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 225 | ObjectRegistryEntry* entry = it->second; |
| 226 | entry->reference_count -= reference_count; |
| 227 | if (entry->reference_count <= 0) { |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 228 | JNIEnv* env = self->GetJniEnv(); |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 229 | // Erase the object from the maps. Note object may be null if it's |
| 230 | // a weak ref and the GC has cleared it. |
| 231 | int32_t hash_code = entry->identity_hash_code; |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 232 | for (auto inner_it = object_to_entry_.lower_bound(hash_code), end = object_to_entry_.end(); |
| 233 | inner_it != end && inner_it->first == hash_code; ++inner_it) { |
| 234 | if (entry == inner_it->second) { |
| 235 | object_to_entry_.erase(inner_it); |
Hiroshi Yamauchi | b5a9e3d | 2014-06-09 12:11:20 -0700 | [diff] [blame] | 236 | break; |
| 237 | } |
| 238 | } |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 239 | if (entry->jni_reference_type == JNIWeakGlobalRefType) { |
| 240 | env->DeleteWeakGlobalRef(entry->jni_reference); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 241 | } else { |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 242 | env->DeleteGlobalRef(entry->jni_reference); |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 243 | } |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 244 | id_to_entry_.erase(id); |
Mathieu Chartier | 412c7fc | 2014-02-07 12:18:39 -0800 | [diff] [blame] | 245 | delete entry; |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 246 | } |
| 247 | } |
| 248 | |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 249 | } // namespace art |