1 /*

     2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright (c) 2018 SAP SE. All rights reserved.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    25 

    26 #include "precompiled.hpp"

    27 

    28 #include "classfile/classLoaderData.inline.hpp"

    29 #include "classfile/classLoaderHierarchyDCmd.hpp"

    30 #include "memory/allocation.hpp"

    31 #include "memory/resourceArea.hpp"

    32 #include "runtime/safepoint.hpp"

    33 #include "utilities/globalDefinitions.hpp"

    34 #include "utilities/ostream.hpp"

    35 

    36 

    37 ClassLoaderHierarchyDCmd::ClassLoaderHierarchyDCmd(outputStream* output, bool heap)

    38   : DCmdWithParser(output, heap)

    39   , _show_classes("show-classes", "Print loaded classes.", "BOOLEAN", false, "false")

    40   , _verbose("verbose", "Print detailed information.", "BOOLEAN", false, "false") {

    41   _dcmdparser.add_dcmd_option(&_show_classes);

    42   _dcmdparser.add_dcmd_option(&_verbose);

    43 }

    44 

    45 

    46 int ClassLoaderHierarchyDCmd::num_arguments() {

    47   ResourceMark rm;

    48   ClassLoaderHierarchyDCmd* dcmd = new ClassLoaderHierarchyDCmd(NULL, false);

    49   if (dcmd != NULL) {

    50     DCmdMark mark(dcmd);

    51     return dcmd->_dcmdparser.num_arguments();

    52   } else {

    53     return 0;

    54   }

    55 }

    56 

    57 // Helper class for drawing the branches to the left of a node.

    58 class BranchTracker : public StackObj {

    59   //       "<x>"

    60   //       " |---<y>"

    61   //       " |    |

    62   //       " |   <z>"

    63   //       " |    |---<z1>

    64   //       " |    |---<z2>

    65   //       ^^^^^^^ ^^^

    66   //        A       B

    67 

    68   // Some terms for the graphics:

    69   // - branch: vertical connection between a node's ancestor to a later sibling.

    70   // - branchwork: (A) the string to print as a prefix at the start of each line, contains all branches.

    71   // - twig (B): Length of the dashed line connecting a node to its branch.

    72   // - branch spacing: how many spaces between branches are printed.

    73 

    74 public:

    75 

    76   enum { max_depth = 64, twig_len = 2, branch_spacing = 5 };

    77 

    78 private:

    79 

    80   char _branches[max_depth];

    81   int _pos;

    82 

    83 public:

    84   BranchTracker()

    85     : _pos(0) {}

    86 

    87   void push(bool has_branch) {

    88     if (_pos < max_depth) {

    89       _branches[_pos] = has_branch ? '|' : ' ';

    90     }

    91     _pos ++; // beyond max depth, omit branch drawing but do count on.

    92   }

    93 

    94   void pop() {

    95     assert(_pos > 0, "must be");

    96     _pos --;

    97   }

    98 

    99   void print(outputStream* st) {

   100     for (int i = 0; i < _pos; i ++) {

   101       st->print("%c%.*s", _branches[i], branch_spacing, "          ");

   102     }

   103   }

   104 

   105   class Mark {

   106     BranchTracker& _tr;

   107   public:

   108     Mark(BranchTracker& tr, bool has_branch_here)

   109       : _tr(tr)  { _tr.push(has_branch_here); }

   110     ~Mark() { _tr.pop(); }

   111   };

   112 

   113 }; // end: BranchTracker

   114 

   115 struct LoadedClassInfo : public ResourceObj {

   116 public:

   117   LoadedClassInfo* _next;

   118   Klass* const _klass;

   119   const ClassLoaderData* const _cld;

   120 

   121   LoadedClassInfo(Klass* klass, const ClassLoaderData* cld)

   122     : _klass(klass), _cld(cld) {}

   123 

   124 };

   125 

   126 class LoaderTreeNode : public ResourceObj {

   127 

   128   // We walk the CLDG and, for each CLD which is non-anonymous, add

   129   // a tree node. To add a node we need its parent node; if it itself

   130   // does not exist yet, we add a preliminary node for it. This preliminary

   131   // node just contains its loader oop; later, when encountering its CLD in

   132   // our CLDG walk, we complete the missing information in this node.

   133 

   134   const oop _loader_oop;

   135   const ClassLoaderData* _cld;

   136 

   137   LoaderTreeNode* _child;

   138   LoaderTreeNode* _next;

   139 

   140   LoadedClassInfo* _classes;

   141   int _num_classes;

   142 

   143   LoadedClassInfo* _anon_classes;

   144   int _num_anon_classes;

   145 

   146   void print_with_childs(outputStream* st, BranchTracker& branchtracker,

   147       bool print_classes, bool verbose) const {

   148 

   149     ResourceMark rm;

   150 

   151     if (_cld == NULL) {

   152       // Not sure how this could happen: we added a preliminary node for a parent but then never encountered

   153       // its CLD?

   154       return;

   155     }

   156 

   157     // Retrieve information.

   158     const Klass* const loader_klass = _cld->class_loader_klass();

   159     const Symbol* const loader_name = _cld->class_loader_name();

   160 

   161     branchtracker.print(st);

   162 

   163     // e.g. "+--- jdk.internal.reflect.DelegatingClassLoader"

   164     st->print("+%.*s", BranchTracker::twig_len, "----------");

   165     if (_cld->is_the_null_class_loader_data()) {

   166       st->print(" <bootstrap>");

   167     } else {

   168       if (loader_name != NULL) {

   169         st->print(" \"%s\",", loader_name->as_C_string());

   170       }

   171       st->print(" %s", loader_klass != NULL ? loader_klass->external_name() : "??");

   172       st->print(" {" PTR_FORMAT "}", p2i(_loader_oop));

   173     }

   174     st->cr();

   175 

   176     // Output following this node (node details and child nodes) - up to the next sibling node

   177     // needs to be prefixed with "|" if there is a follow up sibling.

   178     const bool have_sibling = _next != NULL;

   179     BranchTracker::Mark trm(branchtracker, have_sibling);

   180 

   181     {

   182       // optional node details following this node needs to be prefixed with "|"

   183       // if there are follow up child nodes.

   184       const bool have_child = _child != NULL;

   185       BranchTracker::Mark trm(branchtracker, have_child);

   186 

   187       // Empty line

   188       branchtracker.print(st);

   189       st->cr();

   190 

   191       const int indentation = 18;

   192 

   193       if (verbose) {

   194         branchtracker.print(st);

   195         st->print_cr("%*s " PTR_FORMAT, indentation, "Loader Data:", p2i(_cld));

   196         branchtracker.print(st);

   197         st->print_cr("%*s " PTR_FORMAT, indentation, "Loader Klass:", p2i(loader_klass));

   198 

   199         // Empty line

   200         branchtracker.print(st);

   201         st->cr();

   202       }

   203 

   204       if (print_classes) {

   205 

   206         if (_classes != NULL) {

   207           for (LoadedClassInfo* lci = _classes; lci; lci = lci->_next) {

   208             branchtracker.print(st);

   209             if (lci == _classes) { // first iteration

   210               st->print("%*s ", indentation, "Classes:");

   211             } else {

   212               st->print("%*s ", indentation, "");

   213             }

   214             st->print("%s", lci->_klass->external_name());

   215             st->cr();

   216             // Non-anonymous classes should live in the primary CLD of its loader

   217             assert(lci->_cld == _cld, "must be");

   218           }

   219           branchtracker.print(st);

   220           st->print("%*s ", indentation, "");

   221           st->print_cr("(%u class%s)", _num_classes, (_num_classes == 1) ? "" : "es");

   222 

   223           // Empty line

   224           branchtracker.print(st);

   225           st->cr();

   226         }

   227 

   228         if (_anon_classes != NULL) {

   229           for (LoadedClassInfo* lci = _anon_classes; lci; lci = lci->_next) {

   230             branchtracker.print(st);

   231             if (lci == _anon_classes) { // first iteration

   232               st->print("%*s ", indentation, "Anonymous Classes:");

   233             } else {

   234               st->print("%*s ", indentation, "");

   235             }

   236             st->print("%s", lci->_klass->external_name());

   237             // For anonymous classes, also print CLD if verbose. Should be a different one than the primary CLD.

   238             assert(lci->_cld != _cld, "must be");

   239             if (verbose) {

   240               st->print("  (CLD: " PTR_FORMAT ")", p2i(lci->_cld));

   241             }

   242             st->cr();

   243           }

   244           branchtracker.print(st);

   245           st->print("%*s ", indentation, "");

   246           st->print_cr("(%u anonymous class%s)", _num_anon_classes, (_num_anon_classes == 1) ? "" : "es");

   247 

   248           // Empty line

   249           branchtracker.print(st);

   250           st->cr();

   251         }

   252 

   253       } // end: print_classes

   254 

   255     } // Pop branchtracker mark

   256 

   257     // Print children, recursively

   258     LoaderTreeNode* c = _child;

   259     while (c != NULL) {

   260       c->print_with_childs(st, branchtracker, print_classes, verbose);

   261       c = c->_next;

   262     }

   263 

   264   }

   265 

   266 public:

   267 

   268   LoaderTreeNode(const oop loader_oop)

   269     : _loader_oop(loader_oop), _cld(NULL)

   270     , _child(NULL), _next(NULL)

   271     , _classes(NULL), _anon_classes(NULL)

   272     , _num_classes(0), _num_anon_classes(0) {}

   273 

   274   void set_cld(const ClassLoaderData* cld) {

   275     _cld = cld;

   276   }

   277 

   278   void add_child(LoaderTreeNode* info) {

   279     info->_next = _child;

   280     _child = info;

   281   }

   282 

   283   void add_sibling(LoaderTreeNode* info) {

   284     assert(info->_next == NULL, "must be");

   285     info->_next = _next;

   286     _next = info;

   287   }

   288 

   289   void add_classes(LoadedClassInfo* first_class, int num_classes, bool anonymous) {

   290     LoadedClassInfo** p_list_to_add_to = anonymous ? &_anon_classes : &_classes;

   291     // Search tail.

   292     while ((*p_list_to_add_to) != NULL) {

   293       p_list_to_add_to = &(*p_list_to_add_to)->_next;

   294     }

   295     *p_list_to_add_to = first_class;

   296     if (anonymous) {

   297       _num_anon_classes += num_classes;

   298     } else {

   299       _num_classes += num_classes;

   300     }

   301   }

   302 

   303   const ClassLoaderData* cld() const {

   304     return _cld;

   305   }

   306 

   307   const oop loader_oop() const {

   308     return _loader_oop;

   309   }

   310 

   311   LoaderTreeNode* find(const oop loader_oop) {

   312     LoaderTreeNode* result = NULL;

   313     if (_loader_oop == loader_oop) {

   314       result = this;

   315     } else {

   316       LoaderTreeNode* c = _child;

   317       while (c != NULL && result == NULL) {

   318         result = c->find(loader_oop);

   319         c = c->_next;

   320       }

   321     }

   322     return result;

   323   }

   324 

   325   void print_with_childs(outputStream* st, bool print_classes, bool print_add_info) const {

   326     BranchTracker bwt;

   327     print_with_childs(st, bwt, print_classes, print_add_info);

   328   }

   329 

   330 };

   331 

   332 class LoadedClassCollectClosure : public KlassClosure {

   333 public:

   334   LoadedClassInfo* _list;

   335   const ClassLoaderData* _cld;

   336   int _num_classes;

   337   LoadedClassCollectClosure(const ClassLoaderData* cld)

   338     : _list(NULL), _cld(cld), _num_classes(0) {}

   339   void do_klass(Klass* k) {

   340     LoadedClassInfo* lki = new LoadedClassInfo(k, _cld);

   341     lki->_next = _list;

   342     _list = lki;

   343     _num_classes ++;

   344   }

   345 };

   346 

   347 class LoaderInfoScanClosure : public CLDClosure {

   348 

   349   const bool _print_classes;

   350   const bool _verbose;

   351   LoaderTreeNode* _root;

   352 

   353   static void fill_in_classes(LoaderTreeNode* info, const ClassLoaderData* cld) {

   354     assert(info != NULL && cld != NULL, "must be");

   355     LoadedClassCollectClosure lccc(cld);

   356     const_cast<ClassLoaderData*>(cld)->classes_do(&lccc);

   357     if (lccc._num_classes > 0) {

   358       info->add_classes(lccc._list, lccc._num_classes, cld->is_anonymous());

   359     }

   360   }

   361 

   362   LoaderTreeNode* find_node_or_add_empty_node(oop loader_oop) {

   363 

   364     assert(_root != NULL, "root node must exist");

   365 

   366     if (loader_oop == NULL) {

   367       return _root;

   368     }

   369 

   370     // Check if a node for this oop already exists.

   371     LoaderTreeNode* info = _root->find(loader_oop);

   372 

   373     if (info == NULL) {

   374       // It does not. Create a node.

   375       info = new LoaderTreeNode(loader_oop);

   376 

   377       // Add it to tree.

   378       LoaderTreeNode* parent_info = NULL;

   379 

   380       // Recursively add parent nodes if needed.

   381       const oop parent_oop = java_lang_ClassLoader::parent(loader_oop);

   382       if (parent_oop == NULL) {

   383         parent_info = _root;

   384       } else {

   385         parent_info = find_node_or_add_empty_node(parent_oop);

   386       }

   387       assert(parent_info != NULL, "must be");

   388 

   389       parent_info->add_child(info);

   390     }

   391     return info;

   392   }

   393 

   394 

   395 public:

   396   LoaderInfoScanClosure(bool print_classes, bool verbose)

   397     : _print_classes(print_classes), _verbose(verbose), _root(NULL) {

   398     _root = new LoaderTreeNode(NULL);

   399   }

   400 

   401   void print_results(outputStream* st) const {

   402     _root->print_with_childs(st, _print_classes, _verbose);

   403   }

   404 

   405   void do_cld (ClassLoaderData* cld) {

   406 

   407     // We do not display unloading loaders, for now.

   408     if (cld->is_unloading()) {

   409       return;

   410     }

   411 

   412     const oop loader_oop = cld->class_loader();

   413 

   414     LoaderTreeNode* info = find_node_or_add_empty_node(loader_oop);

   415     assert(info != NULL, "must be");

   416 

   417     // Update CLD in node, but only if this is the primary CLD for this loader.

   418     if (cld->is_anonymous() == false) {

   419       assert(info->cld() == NULL, "there should be only one primary CLD per loader");

   420       info->set_cld(cld);

   421     }

   422 

   423     // Add classes.

   424     fill_in_classes(info, cld);

   425   }

   426 

   427 };

   428 

   429 

   430 class ClassLoaderHierarchyVMOperation : public VM_Operation {

   431   outputStream* const _out;

   432   const bool _show_classes;

   433   const bool _verbose;

   434 public:

   435   ClassLoaderHierarchyVMOperation(outputStream* out, bool show_classes, bool verbose) :

   436     _out(out), _show_classes(show_classes), _verbose(verbose)

   437   {}

   438 

   439   VMOp_Type type() const {

   440     return VMOp_ClassLoaderHierarchyOperation;

   441   }

   442 

   443   void doit() {

   444     assert(SafepointSynchronize::is_at_safepoint(), "must be a safepoint");

   445     ResourceMark rm;

   446     LoaderInfoScanClosure cl (_show_classes, _verbose);

   447     ClassLoaderDataGraph::cld_do(&cl);

   448     cl.print_results(_out);

   449   }

   450 };

   451 

   452 // This command needs to be executed at a safepoint.

   453 void ClassLoaderHierarchyDCmd::execute(DCmdSource source, TRAPS) {

   454   ClassLoaderHierarchyVMOperation op(output(), _show_classes.value(), _verbose.value());

   455   VMThread::execute(&op);

   456 }