1 /*
   2  * Copyright (c) 2003, 2013, 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   // GC support.
 102   void classes_do(KlassClosure* f);
 103 
 104   // JVMTI support
 105   void entries_do(void f(Symbol*));
 106 
 107 #ifndef PRODUCT
 108   void print();
 109 #endif
 110   void verify();
 111 };
 112 
 113 // SeenThread objects represent list of threads that are
 114 // currently performing a load action on a class.
 115 // For class circularity, set before loading a superclass.
 116 // For bootclasssearchpath, set before calling load_instance_class.
 117 // Defining must be single threaded on a class/classloader basis
 118 // For DEFINE_CLASS, the head of the queue owns the
 119 // define token and the rest of the threads wait to return the
 120 // result the first thread gets.
 121 class SeenThread: public CHeapObj<mtInternal> {
 122 private:
 123    Thread *_thread;
 124    SeenThread* _stnext;
 125    SeenThread* _stprev;
 126 public:
 127    SeenThread(Thread *thread) {
 128        _thread = thread;
 129        _stnext = NULL;
 130        _stprev = NULL;
 131    }
 132    Thread* thread()                const { return _thread;}
 133    void set_thread(Thread *thread) { _thread = thread; }
 134 
 135    SeenThread* next()              const { return _stnext;}
 136    void set_next(SeenThread *seen) { _stnext = seen; }
 137    void set_prev(SeenThread *seen) { _stprev = seen; }
 138 
 139 #ifndef PRODUCT
 140   void printActionQ() {
 141     SeenThread* seen = this;
 142     while (seen != NULL) {
 143       seen->thread()->print_value();
 144       tty->print(", ");
 145       seen = seen->next();
 146     }
 147   }
 148 #endif // PRODUCT
 149 };
 150 
 151 // Placeholder objects represent classes currently being loaded.
 152 // All threads examining the placeholder table must hold the
 153 // SystemDictionary_lock, so we don't need special precautions
 154 // on store ordering here.
 155 // The system dictionary is the only user of this class.
 156 
 157 class PlaceholderEntry : public HashtableEntry<Symbol*, mtClass> {
 158   friend class VMStructs;
 159 
 160 
 161  private:
 162   ClassLoaderData*  _loader_data;   // initiating loader
 163   bool              _havesupername; // distinguish between null supername, and unknown
 164   Symbol*           _supername;
 165   Thread*           _definer;       // owner of define token
 166   Klass*            _instanceKlass; // InstanceKlass from successful define
 167   SeenThread*       _superThreadQ;  // doubly-linked queue of Threads loading a superclass for this class
 168   SeenThread*       _loadInstanceThreadQ;  // loadInstance thread
 169                                     // can be multiple threads if classloader object lock broken by application
 170                                     // or if classloader supports parallel classloading
 171 
 172   SeenThread*       _defineThreadQ; // queue of Threads trying to define this class
 173                                     // including _definer
 174                                     // _definer owns token
 175                                     // queue waits for and returns results from _definer
 176 
 177  public:
 178   // Simple accessors, used only by SystemDictionary
 179   Symbol*            klassname()           const { return literal(); }
 180 
 181   ClassLoaderData*   loader_data()         const { return _loader_data; }
 182   void               set_loader_data(ClassLoaderData* loader_data) { _loader_data = loader_data; }
 183 
 184   bool               havesupername()       const { return _havesupername; }
 185   void               set_havesupername(bool havesupername) { _havesupername = havesupername; }
 186 
 187   Symbol*            supername()           const { return _supername; }
 188   void               set_supername(Symbol* supername) {
 189     _supername = supername;
 190     if (_supername != NULL) _supername->increment_refcount();
 191   }
 192 
 193   Thread*            definer()             const {return _definer; }
 194   void               set_definer(Thread* definer) { _definer = definer; }
 195 
 196   Klass*             instance_klass()      const {return _instanceKlass; }
 197   void               set_instance_klass(Klass* ik) { _instanceKlass = ik; }
 198 
 199   SeenThread*        superThreadQ()        const { return _superThreadQ; }
 200   void               set_superThreadQ(SeenThread* SeenThread) { _superThreadQ = SeenThread; }
 201 
 202   SeenThread*        loadInstanceThreadQ() const { return _loadInstanceThreadQ; }
 203   void               set_loadInstanceThreadQ(SeenThread* SeenThread) { _loadInstanceThreadQ = SeenThread; }
 204 
 205   SeenThread*        defineThreadQ()        const { return _defineThreadQ; }
 206   void               set_defineThreadQ(SeenThread* SeenThread) { _defineThreadQ = SeenThread; }
 207 
 208   PlaceholderEntry* next() const {
 209     return (PlaceholderEntry*)HashtableEntry<Symbol*, mtClass>::next();
 210   }
 211 
 212   PlaceholderEntry** next_addr() {
 213     return (PlaceholderEntry**)HashtableEntry<Symbol*, mtClass>::next_addr();
 214   }
 215 
 216   // Test for equality
 217   // Entries are unique for class/classloader name pair
 218   bool equals(Symbol* class_name, ClassLoaderData* loader) const {
 219     return (klassname() == class_name && loader_data() == loader);
 220   }
 221 
 222   SeenThread* actionToQueue(PlaceholderTable::classloadAction action) {
 223     SeenThread* queuehead = NULL;
 224     switch (action) {
 225       case PlaceholderTable::LOAD_INSTANCE:
 226          queuehead = _loadInstanceThreadQ;
 227          break;
 228       case PlaceholderTable::LOAD_SUPER:
 229          queuehead = _superThreadQ;
 230          break;
 231       case PlaceholderTable::DEFINE_CLASS:
 232          queuehead = _defineThreadQ;
 233          break;
 234       default: Unimplemented();
 235     }
 236     return queuehead;
 237   }
 238 
 239   void set_threadQ(SeenThread* seenthread, PlaceholderTable::classloadAction action) {
 240     switch (action) {
 241       case PlaceholderTable::LOAD_INSTANCE:
 242          _loadInstanceThreadQ = seenthread;
 243          break;
 244       case PlaceholderTable::LOAD_SUPER:
 245          _superThreadQ = seenthread;
 246          break;
 247       case PlaceholderTable::DEFINE_CLASS:
 248          _defineThreadQ = seenthread;
 249          break;
 250       default: Unimplemented();
 251     }
 252     return;
 253   }
 254 
 255   bool super_load_in_progress() {
 256      return (_superThreadQ != NULL);
 257   }
 258 
 259   bool instance_load_in_progress() {
 260     return (_loadInstanceThreadQ != NULL);
 261   }
 262 
 263   bool define_class_in_progress() {
 264     return (_defineThreadQ != NULL);
 265   }
 266 
 267 // Doubly-linked list of Threads per action for class/classloader pair
 268 // Class circularity support: links in thread before loading superclass
 269 // bootstrapsearchpath support: links in a thread before load_instance_class
 270 // definers: use as queue of define requestors, including owner of
 271 // define token. Appends for debugging of requestor order
 272   void add_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) {
 273     assert_lock_strong(SystemDictionary_lock);
 274     SeenThread* threadEntry = new SeenThread(thread);
 275     SeenThread* seen = actionToQueue(action);
 276 
 277     if (seen == NULL) {
 278       set_threadQ(threadEntry, action);
 279       return;
 280     }
 281     SeenThread* next;
 282     while ((next = seen->next()) != NULL) {
 283       seen = next;
 284     }
 285     seen->set_next(threadEntry);
 286     threadEntry->set_prev(seen);
 287     return;
 288   }
 289 
 290   bool check_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) {
 291     assert_lock_strong(SystemDictionary_lock);
 292     SeenThread* threadQ = actionToQueue(action);
 293     SeenThread* seen = threadQ;
 294     while (seen) {
 295       if (thread == seen->thread()) {
 296         return true;
 297       }
 298       seen = seen->next();
 299     }
 300     return false;
 301   }
 302 
 303   // returns true if seenthreadQ is now empty
 304   // Note, caller must ensure probe still exists while holding
 305   // SystemDictionary_lock
 306   // ignores if cleanup has already been done
 307   // if found, deletes SeenThread
 308   bool remove_seen_thread(Thread* thread, PlaceholderTable::classloadAction action) {
 309     assert_lock_strong(SystemDictionary_lock);
 310     SeenThread* threadQ = actionToQueue(action);
 311     SeenThread* seen = threadQ;
 312     SeenThread* prev = NULL;
 313     while (seen) {
 314       if (thread == seen->thread()) {
 315         if (prev) {
 316           prev->set_next(seen->next());
 317         } else {
 318           set_threadQ(seen->next(), action);
 319         }
 320         if (seen->next()) {
 321           seen->next()->set_prev(prev);
 322         }
 323         delete seen;
 324         break;
 325       }
 326       prev = seen;
 327       seen = seen->next();
 328     }
 329     return (actionToQueue(action) == NULL);
 330   }
 331 
 332   // GC support
 333   // Applies "f->do_oop" to all root oops in the placeholder table.
 334   void classes_do(KlassClosure* closure);
 335 
 336   // Print method doesn't append a cr
 337   void print() const  PRODUCT_RETURN;
 338   void verify() const;
 339 };
 340 
 341 #endif // SHARE_VM_CLASSFILE_PLACEHOLDERS_HPP