Mercurial > jdk8-mips64-public > hotspot / file comparison
comparison: src/share/vm/prims/jvmtiTrace.cpp
src/share/vm/prims/jvmtiTrace.cpp
- changeset 435
- a61af66fc99e
- child 805
- 885fe0f95828
equal
deleted
inserted
replaced
| -1:000000000000 | 435:a61af66fc99e |
|---|---|
| 1 /* | |
| 2 * Copyright 2003-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 # include "incls/_precompiled.incl" | |
| 26 # include "incls/_jvmtiTrace.cpp.incl" | |
| 27 | |
| 28 // | |
| 29 // class JvmtiTrace | |
| 30 // | |
| 31 // Support for JVMTI tracing code | |
| 32 // | |
| 33 // ------------ | |
| 34 // Usage: | |
| 35 // -XX:TraceJVMTI=DESC,DESC,DESC | |
| 36 // | |
| 37 // DESC is DOMAIN ACTION KIND | |
| 38 // | |
| 39 // DOMAIN is function name | |
| 40 // event name | |
| 41 // "all" (all functions and events) | |
| 42 // "func" (all functions except boring) | |
| 43 // "allfunc" (all functions) | |
| 44 // "event" (all events) | |
| 45 // "ec" (event controller) | |
| 46 // | |
| 47 // ACTION is "+" (add) | |
| 48 // "-" (remove) | |
| 49 // | |
| 50 // KIND is | |
| 51 // for func | |
| 52 // "i" (input params) | |
| 53 // "e" (error returns) | |
| 54 // "o" (output) | |
| 55 // for event | |
| 56 // "t" (event triggered aka posted) | |
| 57 // "s" (event sent) | |
| 58 // | |
| 59 // Example: | |
| 60 // -XX:TraceJVMTI=ec+,GetCallerFrame+ie,Breakpoint+s | |
| 61 | |
| 62 #ifdef JVMTI_TRACE | |
| 63 | |
| 64 bool JvmtiTrace::_initialized = false; | |
| 65 bool JvmtiTrace::_on = false; | |
| 66 bool JvmtiTrace::_trace_event_controller = false; | |
| 67 | |
| 68 void JvmtiTrace::initialize() { | |
| 69 if (_initialized) { | |
| 70 return; | |
| 71 } | |
| 72 SafeResourceMark rm; | |
| 73 | |
| 74 const char *very_end; | |
| 75 const char *curr; | |
| 76 if (strlen(TraceJVMTI)) { | |
| 77 curr = TraceJVMTI; | |
| 78 } else { | |
| 79 curr = ""; // hack in fixed tracing here | |
| 80 } | |
| 81 very_end = curr + strlen(curr); | |
| 82 while (curr < very_end) { | |
| 83 const char *curr_end = strchr(curr, ','); | |
| 84 if (curr_end == NULL) { | |
| 85 curr_end = very_end; | |
| 86 } | |
| 87 const char *op_pos = strchr(curr, '+'); | |
| 88 const char *minus_pos = strchr(curr, '-'); | |
| 89 if (minus_pos != NULL && (minus_pos < op_pos || op_pos == NULL)) { | |
| 90 op_pos = minus_pos; | |
| 91 } | |
| 92 char op; | |
| 93 const char *flags = op_pos + 1; | |
| 94 const char *flags_end = curr_end; | |
| 95 if (op_pos == NULL || op_pos > curr_end) { | |
| 96 flags = "ies"; | |
| 97 flags_end = flags + strlen(flags); | |
| 98 op_pos = curr_end; | |
| 99 op = '+'; | |
| 100 } else { | |
| 101 op = *op_pos; | |
| 102 } | |
| 103 jbyte bits = 0; | |
| 104 for (; flags < flags_end; ++flags) { | |
| 105 switch (*flags) { | |
| 106 case 'i': | |
| 107 bits |= SHOW_IN; | |
| 108 break; | |
| 109 case 'I': | |
| 110 bits |= SHOW_IN_DETAIL; | |
| 111 break; | |
| 112 case 'e': | |
| 113 bits |= SHOW_ERROR; | |
| 114 break; | |
| 115 case 'o': | |
| 116 bits |= SHOW_OUT; | |
| 117 break; | |
| 118 case 'O': | |
| 119 bits |= SHOW_OUT_DETAIL; | |
| 120 break; | |
| 121 case 't': | |
| 122 bits |= SHOW_EVENT_TRIGGER; | |
| 123 break; | |
| 124 case 's': | |
| 125 bits |= SHOW_EVENT_SENT; | |
| 126 break; | |
| 127 default: | |
| 128 tty->print_cr("Invalid trace flag '%c'", *flags); | |
| 129 break; | |
| 130 } | |
| 131 } | |
| 132 const int FUNC = 1; | |
| 133 const int EXCLUDE = 2; | |
| 134 const int ALL_FUNC = 4; | |
| 135 const int EVENT = 8; | |
| 136 const int ALL_EVENT = 16; | |
| 137 int domain = 0; | |
| 138 size_t len = op_pos - curr; | |
| 139 if (op_pos == curr) { | |
| 140 domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT | EXCLUDE; | |
| 141 } else if (len==3 && strncmp(curr, "all", 3)==0) { | |
| 142 domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT; | |
| 143 } else if (len==7 && strncmp(curr, "allfunc", 7)==0) { | |
| 144 domain = ALL_FUNC | FUNC; | |
| 145 } else if (len==4 && strncmp(curr, "func", 4)==0) { | |
| 146 domain = ALL_FUNC | FUNC | EXCLUDE; | |
| 147 } else if (len==8 && strncmp(curr, "allevent", 8)==0) { | |
| 148 domain = ALL_EVENT | EVENT; | |
| 149 } else if (len==5 && strncmp(curr, "event", 5)==0) { | |
| 150 domain = ALL_EVENT | EVENT; | |
| 151 } else if (len==2 && strncmp(curr, "ec", 2)==0) { | |
| 152 _trace_event_controller = true; | |
| 153 tty->print_cr("JVMTI Tracing the event controller"); | |
| 154 } else { | |
| 155 domain = FUNC | EVENT; // go searching | |
| 156 } | |
| 157 | |
| 158 int exclude_index = 0; | |
| 159 if (domain & FUNC) { | |
| 160 if (domain & ALL_FUNC) { | |
| 161 if (domain & EXCLUDE) { | |
| 162 tty->print("JVMTI Tracing all significant functions"); | |
| 163 } else { | |
| 164 tty->print_cr("JVMTI Tracing all functions"); | |
| 165 } | |
| 166 } | |
| 167 for (int i = 0; i <= _max_function_index; ++i) { | |
| 168 if (domain & EXCLUDE && i == _exclude_functions[exclude_index]) { | |
| 169 ++exclude_index; | |
| 170 } else { | |
| 171 bool do_op = false; | |
| 172 if (domain & ALL_FUNC) { | |
| 173 do_op = true; | |
| 174 } else { | |
| 175 const char *fname = function_name(i); | |
| 176 if (fname != NULL) { | |
| 177 size_t fnlen = strlen(fname); | |
| 178 if (len==fnlen && strncmp(curr, fname, fnlen)==0) { | |
| 179 tty->print_cr("JVMTI Tracing the function: %s", fname); | |
| 180 do_op = true; | |
| 181 } | |
| 182 } | |
| 183 } | |
| 184 if (do_op) { | |
| 185 if (op == '+') { | |
| 186 _trace_flags[i] |= bits; | |
| 187 } else { | |
| 188 _trace_flags[i] &= ~bits; | |
| 189 } | |
| 190 _on = true; | |
| 191 } | |
| 192 } | |
| 193 } | |
| 194 } | |
| 195 if (domain & EVENT) { | |
| 196 if (domain & ALL_EVENT) { | |
| 197 tty->print_cr("JVMTI Tracing all events"); | |
| 198 } | |
| 199 for (int i = 0; i <= _max_event_index; ++i) { | |
| 200 bool do_op = false; | |
| 201 if (domain & ALL_EVENT) { | |
| 202 do_op = true; | |
| 203 } else { | |
| 204 const char *ename = event_name(i); | |
| 205 if (ename != NULL) { | |
| 206 size_t evtlen = strlen(ename); | |
| 207 if (len==evtlen && strncmp(curr, ename, evtlen)==0) { | |
| 208 tty->print_cr("JVMTI Tracing the event: %s", ename); | |
| 209 do_op = true; | |
| 210 } | |
| 211 } | |
| 212 } | |
| 213 if (do_op) { | |
| 214 if (op == '+') { | |
| 215 _event_trace_flags[i] |= bits; | |
| 216 } else { | |
| 217 _event_trace_flags[i] &= ~bits; | |
| 218 } | |
| 219 _on = true; | |
| 220 } | |
| 221 } | |
| 222 } | |
| 223 if (!_on && (domain & (FUNC|EVENT))) { | |
| 224 tty->print_cr("JVMTI Trace domain not found"); | |
| 225 } | |
| 226 curr = curr_end + 1; | |
| 227 } | |
| 228 _initialized = true; | |
| 229 } | |
| 230 | |
| 231 | |
| 232 void JvmtiTrace::shutdown() { | |
| 233 int i; | |
| 234 _on = false; | |
| 235 _trace_event_controller = false; | |
| 236 for (i = 0; i <= _max_function_index; ++i) { | |
| 237 _trace_flags[i] = 0; | |
| 238 } | |
| 239 for (i = 0; i <= _max_event_index; ++i) { | |
| 240 _event_trace_flags[i] = 0; | |
| 241 } | |
| 242 } | |
| 243 | |
| 244 | |
| 245 const char* JvmtiTrace::enum_name(const char** names, const jint* values, jint value) { | |
| 246 for (int index = 0; names[index] != 0; ++index) { | |
| 247 if (values[index] == value) { | |
| 248 return names[index]; | |
| 249 } | |
| 250 } | |
| 251 return "*INVALID-ENUM-VALUE*"; | |
| 252 } | |
| 253 | |
| 254 | |
| 255 // return a valid string no matter what state the thread is in | |
| 256 const char *JvmtiTrace::safe_get_thread_name(Thread *thread) { | |
| 257 if (thread == NULL) { | |
| 258 return "NULL"; | |
| 259 } | |
| 260 if (!thread->is_Java_thread()) { | |
| 261 return thread->name(); | |
| 262 } | |
| 263 JavaThread *java_thread = (JavaThread *)thread; | |
| 264 oop threadObj = java_thread->threadObj(); | |
| 265 if (threadObj == NULL) { | |
| 266 return "NULL"; | |
| 267 } | |
| 268 typeArrayOop name = java_lang_Thread::name(threadObj); | |
| 269 if (name == NULL) { | |
| 270 return "<NOT FILLED IN>"; | |
| 271 } | |
| 272 return UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
| 273 } | |
| 274 | |
| 275 | |
| 276 // return the name of the current thread | |
| 277 const char *JvmtiTrace::safe_get_current_thread_name() { | |
| 278 if (JvmtiEnv::is_vm_live()) { | |
| 279 return JvmtiTrace::safe_get_thread_name(Thread::current()); | |
| 280 } else { | |
| 281 return "VM not live"; | |
| 282 } | |
| 283 } | |
| 284 | |
| 285 // return a valid string no matter what the state of k_mirror | |
| 286 const char * JvmtiTrace::get_class_name(oop k_mirror) { | |
| 287 if (java_lang_Class::is_primitive(k_mirror)) { | |
| 288 return "primitive"; | |
| 289 } | |
| 290 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); | |
| 291 if (k_oop == NULL) { | |
| 292 return "INVALID"; | |
| 293 } | |
| 294 return Klass::cast(k_oop)->external_name(); | |
| 295 } | |
| 296 | |
| 297 #endif /*JVMTI_TRACE */ |
