1 /* 2 * Copyright (c) 2003, 2019, 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_CLASSFILE_PLACEHOLDERS_HPP 26 #define SHARE_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 Hashtable<Symbol*, mtClass> { 38 39 public: 40 PlaceholderTable(int table_size); 41 42 PlaceholderEntry* new_entry(int hash, Symbol* name, ClassLoaderData* loader_data, bool havesupername, Symbol* supername); 43 void free_entry(PlaceholderEntry* entry); 44 45 PlaceholderEntry* bucket(int i) const { 46 return (PlaceholderEntry*)Hashtable<Symbol*, mtClass>::bucket(i); 47 } 48 49 PlaceholderEntry** bucket_addr(int i) { 50 return (PlaceholderEntry**)Hashtable<Symbol*, mtClass>::bucket_addr(i); 51 } 52 53 void add_entry(int index, PlaceholderEntry* new_entry) { 54 Hashtable<Symbol*, mtClass>::add_entry(index, (HashtableEntry<Symbol*, mtClass>*)new_entry); 55 } 56 57 void add_entry(int index, unsigned int hash, Symbol* name, 58 ClassLoaderData* loader_data, bool havesupername, Symbol* supername); 59 60 // This returns a Symbol* to match type for SystemDictionary 61 Symbol* find_entry(int index, unsigned int hash, 62 Symbol* name, ClassLoaderData* loader_data); 63 64 PlaceholderEntry* get_entry(int index, unsigned int hash, 65 Symbol* name, ClassLoaderData* loader_data); 66 67 // caller to create a placeholder entry must enumerate an action 68 // caller claims ownership of that action 69 // For parallel classloading: 70 // multiple LOAD_INSTANCE threads can proceed in parallel 71 // multiple LOAD_SUPER threads can proceed in parallel 72 // LOAD_SUPER needed to check for class circularity 73 // DEFINE_CLASS: ultimately define class must be single threaded 74 // on a class/classloader basis 75 // so the head of that queue owns the token 76 // and the rest of the threads return the result the first thread gets 77 // FLATTENABLE_FIELD: needed to check for value type flattenable fields circularity 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 FLATTENABLE_FIELD = 4 // flattenable value type fields 83 }; 84 85 // find_and_add returns probe pointer - old or new 86 // If no entry exists, add a placeholder entry and push SeenThread for classloadAction 87 // If entry exists, reuse entry and push SeenThread for classloadAction 88 PlaceholderEntry* find_and_add(int index, unsigned int hash, 89 Symbol* name, ClassLoaderData* loader_data, 90 classloadAction action, Symbol* supername, 91 Thread* thread); 92 93 void remove_entry(int index, unsigned int hash, 94 Symbol* name, ClassLoaderData* loader_data); 95 96 // find_and_remove first removes SeenThread for classloadAction 97 // If all queues are empty and definer is null, remove the PlacheholderEntry completely 98 void find_and_remove(int index, unsigned int hash, 99 Symbol* name, ClassLoaderData* loader_data, 100 classloadAction action, Thread* thread); 101 102 void print_on(outputStream* st) const; 103 void verify(); 104 }; 105 106 // SeenThread objects represent list of threads that are 107 // currently performing a load action on a class. 108 // For class circularity, set before loading a superclass. 109 // For bootclasssearchpath, set before calling load_instance_class. 110 // Defining must be single threaded on a class/classloader basis 111 // For DEFINE_CLASS, the head of the queue owns the 112 // define token and the rest of the threads wait to return the 113 // result the first thread gets. 114 // For FLATTENABLE_FIELD, set when loading value type fields for 115 // class circularity checking. 116 class SeenThread: public CHeapObj<mtInternal> { 117 private: 118 Thread *_thread; 119 SeenThread* _stnext; 120 SeenThread* _stprev; 121 public: 122 SeenThread(Thread *thread) { 123 _thread = thread; 124 _stnext = NULL; 125 _stprev = NULL; 126 } 127 Thread* thread() const { return _thread;} 128 void set_thread(Thread *thread) { _thread = thread; } 129 130 SeenThread* next() const { return _stnext;} 131 void set_next(SeenThread *seen) { _stnext = seen; } 132 void set_prev(SeenThread *seen) { _stprev = seen; } 133 134 void print_action_queue(outputStream* st) { 135 SeenThread* seen = this; 136 while (seen != NULL) { 137 seen->thread()->print_value_on(st); 138 st->print(", "); 139 seen = seen->next(); 140 } 141 } 142 }; 143 144 // Placeholder objects represent classes currently being loaded. 145 // All threads examining the placeholder table must hold the 146 // SystemDictionary_lock, so we don't need special precautions 147 // on store ordering here. 148 // The system dictionary is the only user of this class. 149 150 class PlaceholderEntry : public HashtableEntry<Symbol*, mtClass> { 151 152 private: 153 ClassLoaderData* _loader_data; // initiating loader 154 bool _havesupername; // distinguish between null supername, and unknown 155 Symbol* _supername; 156 Thread* _definer; // owner of define token 157 InstanceKlass* _instanceKlass; // InstanceKlass from successful define 158 SeenThread* _superThreadQ; // doubly-linked queue of Threads loading a superclass for this class 159 SeenThread* _loadInstanceThreadQ; // loadInstance thread 160 // can be multiple threads if classloader object lock broken by application 161 // or if classloader supports parallel classloading 162 163 SeenThread* _defineThreadQ; // queue of Threads trying to define this class 164 // including _definer 165 // _definer owns token 166 // queue waits for and returns results from _definer 167 SeenThread* _flattenableFieldQ; // queue of value types for circularity checking 168 169 public: 170 // Simple accessors, used only by SystemDictionary 171 Symbol* klassname() const { return literal(); } 172 173 ClassLoaderData* loader_data() const { return _loader_data; } 174 void set_loader_data(ClassLoaderData* loader_data) { _loader_data = loader_data; } 175 176 bool havesupername() const { return _havesupername; } 177 void set_havesupername(bool havesupername) { _havesupername = havesupername; } 178 179 Symbol* supername() const { return _supername; } 180 void set_supername(Symbol* supername) { 181 _supername = supername; 182 if (_supername != NULL) _supername->increment_refcount(); 183 } 184 185 Thread* definer() const {return _definer; } 186 void set_definer(Thread* definer) { _definer = definer; } 187 188 InstanceKlass* instance_klass() const {return _instanceKlass; } 189 void set_instance_klass(InstanceKlass* ik) { _instanceKlass = ik; } 190 191 SeenThread* superThreadQ() const { return _superThreadQ; } 192 void set_superThreadQ(SeenThread* SeenThread) { _superThreadQ = SeenThread; } 193 194 SeenThread* loadInstanceThreadQ() const { return _loadInstanceThreadQ; } 195 void set_loadInstanceThreadQ(SeenThread* SeenThread) { _loadInstanceThreadQ = SeenThread; } 196 197 SeenThread* defineThreadQ() const { return _defineThreadQ; } 198 void set_defineThreadQ(SeenThread* SeenThread) { _defineThreadQ = SeenThread; } 199 200 SeenThread* flattenableFieldQ() const { return _flattenableFieldQ; } 201 void set_flattenableFieldQ(SeenThread* SeenThread) { _flattenableFieldQ = SeenThread; } 202 203 PlaceholderEntry* next() const { 204 return (PlaceholderEntry*)HashtableEntry<Symbol*, mtClass>::next(); 205 } 206 207 PlaceholderEntry** next_addr() { 208 return (PlaceholderEntry**)HashtableEntry<Symbol*, mtClass>::next_addr(); 209 } 210 211 // Test for equality 212 // Entries are unique for class/classloader name pair 213 bool equals(Symbol* class_name, ClassLoaderData* loader) const { 214 return (klassname() == class_name && loader_data() == loader); 215 } 216 217 SeenThread* actionToQueue(PlaceholderTable::classloadAction action) { 218 SeenThread* queuehead = NULL; 219 switch (action) { 220 case PlaceholderTable::LOAD_INSTANCE: 221 queuehead = _loadInstanceThreadQ; 222 break; 223 case PlaceholderTable::LOAD_SUPER: 224 queuehead = _superThreadQ; 225 break; 226 case PlaceholderTable::DEFINE_CLASS: 227 queuehead = _defineThreadQ; 228 break; 229 case PlaceholderTable::FLATTENABLE_FIELD: 230 queuehead = _flattenableFieldQ; 231 break; 232 default: Unimplemented(); 233 } 234 return queuehead; 235 } 236 237 void set_threadQ(SeenThread* seenthread, PlaceholderTable::classloadAction action) { 238 switch (action) { 239 case PlaceholderTable::LOAD_INSTANCE: 240 _loadInstanceThreadQ = seenthread; 241 break; 242 case PlaceholderTable::LOAD_SUPER: 243 _superThreadQ = seenthread; 244 break; 245 case PlaceholderTable::DEFINE_CLASS: 246 _defineThreadQ = seenthread; 247 break; 248 case PlaceholderTable::FLATTENABLE_FIELD: 249 _flattenableFieldQ = seenthread; 250 break; 251 default: Unimplemented(); 252 } 253 return; 254 } 255 256 bool super_load_in_progress() { 257 return (_superThreadQ != NULL); 258 } 259 260 bool instance_load_in_progress() { 261 return (_loadInstanceThreadQ != NULL); 262 } 263 264 bool define_class_in_progress() { 265 return (_defineThreadQ != NULL); 266 } 267 268 bool flattenable_field_in_progress() { 269 return (_flattenableFieldQ != NULL); 270 } 271 272 // Doubly-linked list of Threads per action for class/classloader pair 273 // Class circularity support: links in thread before loading superclass 274 // bootstrapsearchpath support: links in a thread before load_instance_class 275 // definers: use as queue of define requestors, including owner of 276 // define token. Appends for debugging of requestor order 277 void add_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) { 278 assert_lock_strong(SystemDictionary_lock); 279 SeenThread* threadEntry = new SeenThread(thread); 280 SeenThread* seen = actionToQueue(action); 281 282 if (seen == NULL) { 283 set_threadQ(threadEntry, action); 284 return; 285 } 286 SeenThread* next; 287 while ((next = seen->next()) != NULL) { 288 seen = next; 289 } 290 seen->set_next(threadEntry); 291 threadEntry->set_prev(seen); 292 return; 293 } 294 295 bool check_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) { 296 assert_lock_strong(SystemDictionary_lock); 297 SeenThread* threadQ = actionToQueue(action); 298 SeenThread* seen = threadQ; 299 while (seen) { 300 if (thread == seen->thread()) { 301 return true; 302 } 303 seen = seen->next(); 304 } 305 return false; 306 } 307 308 // returns true if seenthreadQ is now empty 309 // Note, caller must ensure probe still exists while holding 310 // SystemDictionary_lock 311 // ignores if cleanup has already been done 312 // if found, deletes SeenThread 313 bool remove_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) { 314 assert_lock_strong(SystemDictionary_lock); 315 SeenThread* threadQ = actionToQueue(action); 316 SeenThread* seen = threadQ; 317 SeenThread* prev = NULL; 318 while (seen) { 319 if (thread == seen->thread()) { 320 if (prev) { 321 prev->set_next(seen->next()); 322 } else { 323 set_threadQ(seen->next(), action); 324 } 325 if (seen->next()) { 326 seen->next()->set_prev(prev); 327 } 328 delete seen; 329 break; 330 } 331 prev = seen; 332 seen = seen->next(); 333 } 334 return (actionToQueue(action) == NULL); 335 } 336 337 // Print method doesn't append a cr 338 void print_entry(outputStream* st) const; 339 void verify() const; 340 }; 341 342 #endif // SHARE_CLASSFILE_PLACEHOLDERS_HPP