1 /*

     2  * Copyright (c) 2018, 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_CLASSLOADERDATAGRAPH_HPP

    26 #define SHARE_VM_CLASSFILE_CLASSLOADERDATAGRAPH_HPP

    27 

    28 #include "classfile/classLoaderData.hpp"

    29 #include "memory/allocation.hpp"

    30 #include "utilities/growableArray.hpp"

    31 #include "utilities/macros.hpp"

    32 

    33 // GC root for walking class loader data created

    34 

    35 class ClassLoaderDataGraph : public AllStatic {

    36   friend class ClassLoaderData;

    37   friend class ClassLoaderDataGraphMetaspaceIterator;

    38   friend class ClassLoaderDataGraphKlassIteratorAtomic;

    39   friend class ClassLoaderDataGraphKlassIteratorStatic;

    40   friend class ClassLoaderDataGraphIterator;

    41   friend class VMStructs;

    42  private:

    43   // All CLDs (except the null CLD) can be reached by walking _head->_next->...

    44   static ClassLoaderData* _head;

    45   static ClassLoaderData* _unloading;

    46   // CMS support.

    47   static ClassLoaderData* _saved_head;

    48   static ClassLoaderData* _saved_unloading;

    49   static bool _should_purge;

    50 

    51   // Set if there's anything to purge in the deallocate lists or previous versions

    52   // during a safepoint after class unloading in a full GC.

    53   static bool _should_clean_deallocate_lists;

    54   static bool _safepoint_cleanup_needed;

    55 

    56   // OOM has been seen in metaspace allocation. Used to prevent some

    57   // allocations until class unloading

    58   static bool _metaspace_oom;

    59 

    60   static volatile size_t  _num_instance_classes;

    61   static volatile size_t  _num_array_classes;

    62 

    63   static ClassLoaderData* add_to_graph(Handle class_loader, bool is_unsafe_anonymous);

    64   static ClassLoaderData* add(Handle class_loader, bool is_unsafe_anonymous);

    65 

    66  public:

    67   static ClassLoaderData* find_or_create(Handle class_loader);

    68   static void clean_module_and_package_info();

    69   static void purge();

    70   static void clear_claimed_marks();

    71   // Iteration through CLDG inside a safepoint; GC support

    72   static void cld_do(CLDClosure* cl);

    73   static void cld_unloading_do(CLDClosure* cl);

    74   static void roots_cld_do(CLDClosure* strong, CLDClosure* weak);

    75   static void always_strong_cld_do(CLDClosure* cl);

    76   // klass do

    77   // Walking classes through the ClassLoaderDataGraph include array classes.  It also includes

    78   // classes that are allocated but not loaded, classes that have errors, and scratch classes

    79   // for redefinition.  These classes are removed during the next class unloading.

    80   // Walking the ClassLoaderDataGraph also includes unsafe anonymous classes.

    81   static void classes_do(KlassClosure* klass_closure);

    82   static void classes_do(void f(Klass* const));

    83   static void methods_do(void f(Method*));

    84   static void modules_do(void f(ModuleEntry*));

    85   static void modules_unloading_do(void f(ModuleEntry*));

    86   static void packages_do(void f(PackageEntry*));

    87   static void packages_unloading_do(void f(PackageEntry*));

    88   static void loaded_classes_do(KlassClosure* klass_closure);

    89   static void unlocked_loaded_classes_do(KlassClosure* klass_closure);

    90   static void classes_unloading_do(void f(Klass* const));

    91   static bool do_unloading(bool do_cleaning);

    92 

    93   // Expose state to avoid logging overhead in safepoint cleanup tasks.

    94   static inline bool should_clean_metaspaces_and_reset();

    95   static void set_should_clean_deallocate_lists() { _should_clean_deallocate_lists = true; }

    96   static void clean_deallocate_lists(bool purge_previous_versions);

    97   static void walk_metadata_and_clean_metaspaces();

    98 

    99   // dictionary do

   100   // Iterate over all klasses in dictionary, but

   101   // just the classes from defining class loaders.

   102   static void dictionary_classes_do(void f(InstanceKlass*));

   103   // Added for initialize_itable_for_klass to handle exceptions.

   104   static void dictionary_classes_do(void f(InstanceKlass*, TRAPS), TRAPS);

   105 

   106   // VM_CounterDecay iteration support

   107   static InstanceKlass* try_get_next_class();

   108   static void adjust_saved_class(ClassLoaderData* cld);

   109   static void adjust_saved_class(Klass* klass);

   110 

   111   static void verify_dictionary();

   112   static void print_dictionary(outputStream* st);

   113   static void print_dictionary_statistics(outputStream* st);

   114 

   115   // CMS support.

   116   static void remember_new_clds(bool remember) { _saved_head = (remember ? _head : NULL); }

   117   static GrowableArray<ClassLoaderData*>* new_clds();

   118 

   119   static void set_should_purge(bool b) { _should_purge = b; }

   120   static void purge_if_needed() {

   121     // Only purge the CLDG for CMS if concurrent sweep is complete.

   122     if (_should_purge) {

   123       purge();

   124       // reset for next time.

   125       set_should_purge(false);

   126     }

   127   }

   128 

   129   static int resize_if_needed();

   130 

   131   static bool has_metaspace_oom()           { return _metaspace_oom; }

   132   static void set_metaspace_oom(bool value) { _metaspace_oom = value; }

   133 

   134   static void print_on(outputStream * const out) PRODUCT_RETURN;

   135   static void print() { print_on(tty); }

   136   static void verify();

   137 

   138   // instance and array class counters

   139   static inline size_t num_instance_classes();

   140   static inline size_t num_array_classes();

   141   static inline void inc_instance_classes(size_t count);

   142   static inline void dec_instance_classes(size_t count);

   143   static inline void inc_array_classes(size_t count);

   144   static inline void dec_array_classes(size_t count);

   145 

   146 #ifndef PRODUCT

   147   static bool contains_loader_data(ClassLoaderData* loader_data);

   148 #endif

   149 };

   150 

   151 class LockedClassesDo : public KlassClosure {

   152   typedef void (*classes_do_func_t)(Klass*);

   153   classes_do_func_t _function;

   154 public:

   155   LockedClassesDo();  // For callers who provide their own do_klass

   156   LockedClassesDo(classes_do_func_t function);

   157   ~LockedClassesDo();

   158 

   159   void do_klass(Klass* k) {

   160     (*_function)(k);

   161   }

   162 };

   163 

   164 // An iterator that distributes Klasses to parallel worker threads.

   165 class ClassLoaderDataGraphKlassIteratorAtomic : public StackObj {

   166  Klass* volatile _next_klass;

   167  public:

   168   ClassLoaderDataGraphKlassIteratorAtomic();

   169   Klass* next_klass();

   170  private:

   171   static Klass* next_klass_in_cldg(Klass* klass);

   172 };

   173 

   174 class ClassLoaderDataGraphMetaspaceIterator : public StackObj {

   175   ClassLoaderData* _data;

   176  public:

   177   ClassLoaderDataGraphMetaspaceIterator();

   178   ~ClassLoaderDataGraphMetaspaceIterator();

   179   bool repeat() { return _data != NULL; }

   180   ClassLoaderMetaspace* get_next();

   181 };

   182 #endif // SHARE_VM_CLASSFILE_CLASSLOADERDATAGRAPH_HPP