1 /* 2 * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_CLASSFILE_PLACEHOLDERS_HPP 26 #define SHARE_VM_CLASSFILE_PLACEHOLDERS_HPP 27 28 #include "runtime/thread.hpp" 29 #include "utilities/hashtable.hpp" 30 31 class PlaceholderEntry; 32 33 // Placeholder objects. These represent classes currently 34 // being loaded, as well as arrays of primitives. 35 // 36 37 class PlaceholderTable : public TwoOopHashtable<Symbol*, mtClass> { 38 friend class VMStructs; 39 40 public: 41 PlaceholderTable(int table_size); 42 43 PlaceholderEntry* new_entry(int hash, Symbol* name, ClassLoaderData* loader_data, bool havesupername, Symbol* supername); 44 void free_entry(PlaceholderEntry* entry); 45 46 PlaceholderEntry* bucket(int i) { 47 return (PlaceholderEntry*)Hashtable<Symbol*, mtClass>::bucket(i); 48 } 49 50 PlaceholderEntry** bucket_addr(int i) { 51 return (PlaceholderEntry**)Hashtable<Symbol*, mtClass>::bucket_addr(i); 52 } 53 54 void add_entry(int index, PlaceholderEntry* new_entry) { 55 Hashtable<Symbol*, mtClass>::add_entry(index, (HashtableEntry<Symbol*, mtClass>*)new_entry); 56 } 57 58 void add_entry(int index, unsigned int hash, Symbol* name, 59 ClassLoaderData* loader_data, bool havesupername, Symbol* supername); 60 61 // This returns a Symbol* to match type for SystemDictionary 62 Symbol* find_entry(int index, unsigned int hash, 63 Symbol* name, ClassLoaderData* loader_data); 64 65 PlaceholderEntry* get_entry(int index, unsigned int hash, 66 Symbol* name, ClassLoaderData* loader_data); 67 68 // caller to create a placeholder entry must enumerate an action 69 // caller claims ownership of that action 70 // For parallel classloading: 71 // multiple LOAD_INSTANCE threads can proceed in parallel 72 // multiple LOAD_SUPER threads can proceed in parallel 73 // LOAD_SUPER needed to check for class circularity 74 // DEFINE_CLASS: ultimately define class must be single threaded 75 // on a class/classloader basis 76 // so the head of that queue owns the token 77 // and the rest of the threads return the result the first thread gets 78 enum classloadAction { 79 LOAD_INSTANCE = 1, // calling load_instance_class 80 LOAD_SUPER = 2, // loading superclass for this class 81 DEFINE_CLASS = 3 // find_or_define class 82 }; 83 84 // find_and_add returns probe pointer - old or new 85 // If no entry exists, add a placeholder entry and push SeenThread for classloadAction 86 // If entry exists, reuse entry and push SeenThread for classloadAction 87 PlaceholderEntry* find_and_add(int index, unsigned int hash, 88 Symbol* name, ClassLoaderData* loader_data, 89 classloadAction action, Symbol* supername, 90 Thread* thread); 91 92 void remove_entry(int index, unsigned int hash, 93 Symbol* name, ClassLoaderData* loader_data); 94 95 // find_and_remove first removes SeenThread for classloadAction 96 // If all queues are empty and definer is null, remove the PlacheholderEntry completely 97 void find_and_remove(int index, unsigned int hash, 98 Symbol* name, ClassLoaderData* loader_data, 99 classloadAction action, Thread* thread); 100 101 #ifndef PRODUCT 102 void print(); 103 #endif 104 void verify(); 105 }; 106 107 // SeenThread objects represent list of threads that are 108 // currently performing a load action on a class. 109 // For class circularity, set before loading a superclass. 110 // For bootclasssearchpath, set before calling load_instance_class. 111 // Defining must be single threaded on a class/classloader basis 112 // For DEFINE_CLASS, the head of the queue owns the 113 // define token and the rest of the threads wait to return the 114 // result the first thread gets. 115 class SeenThread: public CHeapObj<mtInternal> { 116 private: 117 Thread *_thread; 118 SeenThread* _stnext; 119 SeenThread* _stprev; 120 public: 121 SeenThread(Thread *thread) { 122 _thread = thread; 123 _stnext = NULL; 124 _stprev = NULL; 125 } 126 Thread* thread() const { return _thread;} 127 void set_thread(Thread *thread) { _thread = thread; } 128 129 SeenThread* next() const { return _stnext;} 130 void set_next(SeenThread *seen) { _stnext = seen; } 131 void set_prev(SeenThread *seen) { _stprev = seen; } 132 133 #ifndef PRODUCT 134 void printActionQ() { 135 SeenThread* seen = this; 136 while (seen != NULL) { 137 seen->thread()->print_value(); 138 tty->print(", "); 139 seen = seen->next(); 140 } 141 } 142 #endif // PRODUCT 143 }; 144 145 // Placeholder objects represent classes currently being loaded. 146 // All threads examining the placeholder table must hold the 147 // SystemDictionary_lock, so we don't need special precautions 148 // on store ordering here. 149 // The system dictionary is the only user of this class. 150 151 class PlaceholderEntry : public HashtableEntry<Symbol*, mtClass> { 152 friend class VMStructs; 153 154 155 private: 156 ClassLoaderData* _loader_data; // initiating loader 157 bool _havesupername; // distinguish between null supername, and unknown 158 Symbol* _supername; 159 Thread* _definer; // owner of define token 160 InstanceKlass* _instanceKlass; // InstanceKlass from successful define 161 SeenThread* _superThreadQ; // doubly-linked queue of Threads loading a superclass for this class 162 SeenThread* _loadInstanceThreadQ; // loadInstance thread 163 // can be multiple threads if classloader object lock broken by application 164 // or if classloader supports parallel classloading 165 166 SeenThread* _defineThreadQ; // queue of Threads trying to define this class 167 // including _definer 168 // _definer owns token 169 // queue waits for and returns results from _definer 170 171 public: 172 // Simple accessors, used only by SystemDictionary 173 Symbol* klassname() const { return literal(); } 174 175 ClassLoaderData* loader_data() const { return _loader_data; } 176 void set_loader_data(ClassLoaderData* loader_data) { _loader_data = loader_data; } 177 178 bool havesupername() const { return _havesupername; } 179 void set_havesupername(bool havesupername) { _havesupername = havesupername; } 180 181 Symbol* supername() const { return _supername; } 182 void set_supername(Symbol* supername) { 183 _supername = supername; 184 if (_supername != NULL) _supername->increment_refcount(); 185 } 186 187 Thread* definer() const {return _definer; } 188 void set_definer(Thread* definer) { _definer = definer; } 189 190 InstanceKlass* instance_klass() const {return _instanceKlass; } 191 void set_instance_klass(InstanceKlass* ik) { _instanceKlass = ik; } 192 193 SeenThread* superThreadQ() const { return _superThreadQ; } 194 void set_superThreadQ(SeenThread* SeenThread) { _superThreadQ = SeenThread; } 195 196 SeenThread* loadInstanceThreadQ() const { return _loadInstanceThreadQ; } 197 void set_loadInstanceThreadQ(SeenThread* SeenThread) { _loadInstanceThreadQ = SeenThread; } 198 199 SeenThread* defineThreadQ() const { return _defineThreadQ; } 200 void set_defineThreadQ(SeenThread* SeenThread) { _defineThreadQ = SeenThread; } 201 202 PlaceholderEntry* next() const { 203 return (PlaceholderEntry*)HashtableEntry<Symbol*, mtClass>::next(); 204 } 205 206 PlaceholderEntry** next_addr() { 207 return (PlaceholderEntry**)HashtableEntry<Symbol*, mtClass>::next_addr(); 208 } 209 210 // Test for equality 211 // Entries are unique for class/classloader name pair 212 bool equals(Symbol* class_name, ClassLoaderData* loader) const { 213 return (klassname() == class_name && loader_data() == loader); 214 } 215 216 SeenThread* actionToQueue(PlaceholderTable::classloadAction action) { 217 SeenThread* queuehead = NULL; 218 switch (action) { 219 case PlaceholderTable::LOAD_INSTANCE: 220 queuehead = _loadInstanceThreadQ; 221 break; 222 case PlaceholderTable::LOAD_SUPER: 223 queuehead = _superThreadQ; 224 break; 225 case PlaceholderTable::DEFINE_CLASS: 226 queuehead = _defineThreadQ; 227 break; 228 default: Unimplemented(); 229 } 230 return queuehead; 231 } 232 233 void set_threadQ(SeenThread* seenthread, PlaceholderTable::classloadAction action) { 234 switch (action) { 235 case PlaceholderTable::LOAD_INSTANCE: 236 _loadInstanceThreadQ = seenthread; 237 break; 238 case PlaceholderTable::LOAD_SUPER: 239 _superThreadQ = seenthread; 240 break; 241 case PlaceholderTable::DEFINE_CLASS: 242 _defineThreadQ = seenthread; 243 break; 244 default: Unimplemented(); 245 } 246 return; 247 } 248 249 bool super_load_in_progress() { 250 return (_superThreadQ != NULL); 251 } 252 253 bool instance_load_in_progress() { 254 return (_loadInstanceThreadQ != NULL); 255 } 256 257 bool define_class_in_progress() { 258 return (_defineThreadQ != NULL); 259 } 260 261 // Doubly-linked list of Threads per action for class/classloader pair 262 // Class circularity support: links in thread before loading superclass 263 // bootstrapsearchpath support: links in a thread before load_instance_class 264 // definers: use as queue of define requestors, including owner of 265 // define token. Appends for debugging of requestor order 266 void add_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) { 267 assert_lock_strong(SystemDictionary_lock); 268 SeenThread* threadEntry = new SeenThread(thread); 269 SeenThread* seen = actionToQueue(action); 270 271 if (seen == NULL) { 272 set_threadQ(threadEntry, action); 273 return; 274 } 275 SeenThread* next; 276 while ((next = seen->next()) != NULL) { 277 seen = next; 278 } 279 seen->set_next(threadEntry); 280 threadEntry->set_prev(seen); 281 return; 282 } 283 284 bool check_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) { 285 assert_lock_strong(SystemDictionary_lock); 286 SeenThread* threadQ = actionToQueue(action); 287 SeenThread* seen = threadQ; 288 while (seen) { 289 if (thread == seen->thread()) { 290 return true; 291 } 292 seen = seen->next(); 293 } 294 return false; 295 } 296 297 // returns true if seenthreadQ is now empty 298 // Note, caller must ensure probe still exists while holding 299 // SystemDictionary_lock 300 // ignores if cleanup has already been done 301 // if found, deletes SeenThread 302 bool remove_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) { 303 assert_lock_strong(SystemDictionary_lock); 304 SeenThread* threadQ = actionToQueue(action); 305 SeenThread* seen = threadQ; 306 SeenThread* prev = NULL; 307 while (seen) { 308 if (thread == seen->thread()) { 309 if (prev) { 310 prev->set_next(seen->next()); 311 } else { 312 set_threadQ(seen->next(), action); 313 } 314 if (seen->next()) { 315 seen->next()->set_prev(prev); 316 } 317 delete seen; 318 break; 319 } 320 prev = seen; 321 seen = seen->next(); 322 } 323 return (actionToQueue(action) == NULL); 324 } 325 326 // Print method doesn't append a cr 327 void print() const PRODUCT_RETURN; 328 void verify() const; 329 }; 330 331 #endif // SHARE_VM_CLASSFILE_PLACEHOLDERS_HPP