jdk8-mips64-public/hotspot: src/share/vm/prims/jvmtiTrace.cpp@833b0f92429a (annotated)

src/share/vm/prims/jvmtiTrace.cpp@833b0f92429a (annotated)

src/share/vm/prims/jvmtiTrace.cpp

Wed, 27 Aug 2014 08:19:12 -0400

author: zgu
date: Wed, 27 Aug 2014 08:19:12 -0400
changeset 7074: 833b0f92429a
parent 4278: 070d523b96a7
child 6876: 710a3c8b516e
child 8288: efe013052465
permissions: -rw-r--r--

8046598: Scalable Native memory tracking development
Summary: Enhance scalability of native memory tracking
Reviewed-by: coleenp, ctornqvi, gtriantafill

 /*
  * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "jvmtifiles/jvmtiEnv.hpp"
 #include "prims/jvmtiTrace.hpp"
 //
 // class JvmtiTrace
 //
 // Support for JVMTI tracing code
 //
 // ------------
 // Usage:
 //    -XX:TraceJVMTI=DESC,DESC,DESC
 //
 //    DESC is   DOMAIN ACTION KIND
 //
 //    DOMAIN is function name
 //              event name
 //              "all" (all functions and events)
 //              "func" (all functions except boring)
 //              "allfunc" (all functions)
 //              "event" (all events)
 //              "ec" (event controller)
 //
 //    ACTION is "+" (add)
 //              "-" (remove)
 //
 //    KIND is
 //     for func
 //              "i" (input params)
 //              "e" (error returns)
 //              "o" (output)
 //     for event
 //              "t" (event triggered aka posted)
 //              "s" (event sent)
 //
 // Example:
 //            -XX:TraceJVMTI=ec+,GetCallerFrame+ie,Breakpoint+s
 #ifdef JVMTI_TRACE
 bool JvmtiTrace::_initialized = false;
 bool JvmtiTrace::_on = false;
 bool JvmtiTrace::_trace_event_controller = false;
 void JvmtiTrace::initialize() {
   if (_initialized) {
     return;
   }
   SafeResourceMark rm;
   const char *very_end;
   const char *curr;
   if (TraceJVMTI != NULL) {
     curr = TraceJVMTI;
   } else {
     curr = "";  // hack in fixed tracing here
   }
   very_end = curr + strlen(curr);
   while (curr < very_end) {
     const char *curr_end = strchr(curr, ',');
     if (curr_end == NULL) {
       curr_end = very_end;
     }
     const char *op_pos = strchr(curr, '+');
     const char *minus_pos = strchr(curr, '-');
     if (minus_pos != NULL && (minus_pos < op_pos || op_pos == NULL)) {
       op_pos = minus_pos;
     }
     char op;
     const char *flags = op_pos + 1;
     const char *flags_end = curr_end;
     if (op_pos == NULL || op_pos > curr_end) {
       flags = "ies";
       flags_end = flags + strlen(flags);
       op_pos = curr_end;
       op = '+';
     } else {
       op = *op_pos;
     }
     jbyte bits = 0;
     for (; flags < flags_end; ++flags) {
       switch (*flags) {
       case 'i':
         bits |= SHOW_IN;
         break;
       case 'I':
         bits |= SHOW_IN_DETAIL;
         break;
       case 'e':
         bits |= SHOW_ERROR;
         break;
       case 'o':
         bits |= SHOW_OUT;
         break;
       case 'O':
         bits |= SHOW_OUT_DETAIL;
         break;
       case 't':
         bits |= SHOW_EVENT_TRIGGER;
         break;
       case 's':
         bits |= SHOW_EVENT_SENT;
         break;
       default:
         tty->print_cr("Invalid trace flag '%c'", *flags);
         break;
       }
     }
     const int FUNC = 1;
     const int EXCLUDE  = 2;
     const int ALL_FUNC = 4;
     const int EVENT = 8;
     const int ALL_EVENT = 16;
     int domain = 0;
     size_t len = op_pos - curr;
     if (op_pos == curr) {
       domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT | EXCLUDE;
     } else if (len==3 && strncmp(curr, "all", 3)==0) {
       domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT;
     } else if (len==7 && strncmp(curr, "allfunc", 7)==0) {
       domain = ALL_FUNC | FUNC;
     } else if (len==4 && strncmp(curr, "func", 4)==0) {
       domain = ALL_FUNC | FUNC | EXCLUDE;
     } else if (len==8 && strncmp(curr, "allevent", 8)==0) {
       domain = ALL_EVENT | EVENT;
     } else if (len==5 && strncmp(curr, "event", 5)==0) {
       domain = ALL_EVENT | EVENT;
     } else if (len==2 && strncmp(curr, "ec", 2)==0) {
       _trace_event_controller = true;
       tty->print_cr("JVMTI Tracing the event controller");
     } else {
       domain = FUNC | EVENT;  // go searching
     }
     int exclude_index = 0;
     if (domain & FUNC) {
       if (domain & ALL_FUNC) {
         if (domain & EXCLUDE) {
           tty->print("JVMTI Tracing all significant functions");
         } else {
           tty->print_cr("JVMTI Tracing all functions");
         }
       }
       for (int i = 0; i <= _max_function_index; ++i) {
         if (domain & EXCLUDE && i == _exclude_functions[exclude_index]) {
           ++exclude_index;
         } else {
           bool do_op = false;
           if (domain & ALL_FUNC) {
             do_op = true;
           } else {
             const char *fname = function_name(i);
             if (fname != NULL) {
               size_t fnlen = strlen(fname);
               if (len==fnlen && strncmp(curr, fname, fnlen)==0) {
                 tty->print_cr("JVMTI Tracing the function: %s", fname);
                 do_op = true;
               }
             }
           }
           if (do_op) {
             if (op == '+') {
               _trace_flags[i] |= bits;
             } else {
               _trace_flags[i] &= ~bits;
             }
             _on = true;
           }
         }
       }
     }
     if (domain & EVENT) {
       if (domain & ALL_EVENT) {
         tty->print_cr("JVMTI Tracing all events");
       }
       for (int i = 0; i <= _max_event_index; ++i) {
         bool do_op = false;
         if (domain & ALL_EVENT) {
           do_op = true;
         } else {
           const char *ename = event_name(i);
           if (ename != NULL) {
             size_t evtlen = strlen(ename);
             if (len==evtlen && strncmp(curr, ename, evtlen)==0) {
               tty->print_cr("JVMTI Tracing the event: %s", ename);
               do_op = true;
             }
           }
         }
         if (do_op) {
           if (op == '+') {
             _event_trace_flags[i] |= bits;
           } else {
             _event_trace_flags[i] &= ~bits;
           }
           _on = true;
         }
       }
     }
     if (!_on && (domain & (FUNC|EVENT))) {
       tty->print_cr("JVMTI Trace domain not found");
     }
     curr = curr_end + 1;
   }
   _initialized = true;
 }
 void JvmtiTrace::shutdown() {
   int i;
   _on = false;
   _trace_event_controller = false;
   for (i = 0; i <= _max_function_index; ++i) {
     _trace_flags[i] = 0;
   }
   for (i = 0; i <= _max_event_index; ++i) {
     _event_trace_flags[i] = 0;
   }
 }
 const char* JvmtiTrace::enum_name(const char** names, const jint* values, jint value) {
   for (int index = 0; names[index] != 0; ++index) {
     if (values[index] == value) {
       return names[index];
     }
   }
   return "*INVALID-ENUM-VALUE*";
 }
 // return a valid string no matter what state the thread is in
 const char *JvmtiTrace::safe_get_thread_name(Thread *thread) {
   if (thread == NULL) {
     return "NULL";
   }
   if (!thread->is_Java_thread()) {
     return thread->name();
   }
   JavaThread *java_thread = (JavaThread *)thread;
   oop threadObj = java_thread->threadObj();
   if (threadObj == NULL) {
     return "NULL";
   }
   typeArrayOop name = java_lang_Thread::name(threadObj);
   if (name == NULL) {
     return "<NOT FILLED IN>";
   }
   return UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
 }
 // return the name of the current thread
 const char *JvmtiTrace::safe_get_current_thread_name() {
   if (JvmtiEnv::is_vm_live()) {
     return JvmtiTrace::safe_get_thread_name(Thread::current());
   } else {
     return "VM not live";
   }
 }
 // return a valid string no matter what the state of k_mirror
 const char * JvmtiTrace::get_class_name(oop k_mirror) {
   if (java_lang_Class::is_primitive(k_mirror)) {
     return "primitive";
   }
   Klass* k_oop = java_lang_Class::as_Klass(k_mirror);
   if (k_oop == NULL) {
     return "INVALID";
   }
   return k_oop->external_name();
 }
 #endif /*JVMTI_TRACE */

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/prims/jvmtiTrace.cpp@833b0f92429a (annotated)

src/share/vm/prims/jvmtiTrace.cpp