/*

 * Copyright (c) 2003, 2018, 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 "classfile/javaClasses.inline.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "logging/log.hpp"

#include "logging/logConfiguration.hpp"

#include "memory/resourceArea.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

  }

  // Enable UL for JVMTI tracing

  if (strlen(curr) > 0) {

    if (!log_is_enabled(Trace, jvmti)) {

      log_warning(arguments)("-XX:+TraceJVMTI specified, "

         "but no log output configured for the 'jvmti' tag on Trace level. "

         "Defaulting to -Xlog:jvmti=trace");

      LogConfiguration::configure_stdout(LogLevel::Trace, true, LOG_TAGS(jvmti));

    }

  }

  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:

        log_warning(jvmti)("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;

      log_trace(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) {

          log_trace(jvmti)("Tracing all significant functions");

        } else {

          log_trace(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) {

                log_trace(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) {

        log_trace(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) {

              log_trace(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))) {

      log_warning(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";

  }

  oop name = java_lang_Thread::name(threadObj);

  if (name == NULL) {

    return "<NOT FILLED IN>";

  }

  return java_lang_String::as_utf8_string(name);

}

// 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_or_null());

  } 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 */