1 /*

     2  * Copyright (c) 1997, 2017, 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_UTILITIES_EVENTS_HPP

    26 #define SHARE_VM_UTILITIES_EVENTS_HPP

    27 

    28 #include "memory/allocation.hpp"

    29 #include "runtime/mutexLocker.hpp"

    30 #include "runtime/thread.hpp"

    31 #include "utilities/formatBuffer.hpp"

    32 #include "utilities/vmError.hpp"

    33 

    34 // Events and EventMark provide interfaces to log events taking place in the vm.

    35 // This facility is extremly useful for post-mortem debugging. The eventlog

    36 // often provides crucial information about events leading up to the crash.

    37 //

    38 // Abstractly the logs can record whatever they way but normally they

    39 // would record at least a timestamp and the current Thread, along

    40 // with whatever data they need in a ring buffer.  Commonly fixed

    41 // length text messages are recorded for simplicity but other

    42 // strategies could be used.  Several logs are provided by default but

    43 // new instances can be created as needed.

    44 

    45 // The base event log dumping class that is registered for dumping at

    46 // crash time.  This is a very generic interface that is mainly here

    47 // for completeness.  Normally the templated EventLogBase would be

    48 // subclassed to provide different log types.

    49 class EventLog : public CHeapObj<mtInternal> {

    50   friend class Events;

    51 

    52  private:

    53   EventLog* _next;

    54 

    55   EventLog* next() const { return _next; }

    56 

    57  public:

    58   // Automatically registers the log so that it will be printed during

    59   // crashes.

    60   EventLog();

    61 

    62   virtual void print_log_on(outputStream* out) = 0;

    63 };

    64 

    65 

    66 // A templated subclass of EventLog that provides basic ring buffer

    67 // functionality.  Most event loggers should subclass this, possibly

    68 // providing a more featureful log function if the existing copy

    69 // semantics aren't appropriate.  The name is used as the label of the

    70 // log when it is dumped during a crash.

    71 template <class T> class EventLogBase : public EventLog {

    72   template <class X> class EventRecord : public CHeapObj<mtInternal> {

    73    public:

    74     double  timestamp;

    75     Thread* thread;

    76     X       data;

    77   };

    78 

    79  protected:

    80   Mutex           _mutex;

    81   const char*     _name;

    82   int             _length;

    83   int             _index;

    84   int             _count;

    85   EventRecord<T>* _records;

    86 

    87  public:

    88   EventLogBase<T>(const char* name, int length = LogEventsBufferEntries):

    89     _name(name),

    90     _length(length),

    91     _count(0),

    92     _index(0),

    93     _mutex(Mutex::event, name, false, Monitor::_safepoint_check_never) {

    94     _records = new EventRecord<T>[length];

    95   }

    96 

    97   double fetch_timestamp() {

    98     return os::elapsedTime();

    99   }

   100 

   101   // move the ring buffer to next open slot and return the index of

   102   // the slot to use for the current message.  Should only be called

   103   // while mutex is held.

   104   int compute_log_index() {

   105     int index = _index;

   106     if (_count < _length) _count++;

   107     _index++;

   108     if (_index >= _length) _index = 0;

   109     return index;

   110   }

   111 

   112   bool should_log() {

   113     // Don't bother adding new entries when we're crashing.  This also

   114     // avoids mutating the ring buffer when printing the log.

   115     return !VMError::fatal_error_in_progress();

   116   }

   117 

   118   // Print the contents of the log

   119   void print_log_on(outputStream* out);

   120 

   121  private:

   122   void print_log_impl(outputStream* out);

   123 

   124   // Print a single element.  A templated implementation might need to

   125   // be declared by subclasses.

   126   void print(outputStream* out, T& e);

   127 

   128   void print(outputStream* out, EventRecord<T>& e) {

   129     out->print("Event: %.3f ", e.timestamp);

   130     if (e.thread != NULL) {

   131       out->print("Thread " INTPTR_FORMAT " ", p2i(e.thread));

   132     }

   133     print(out, e.data);

   134   }

   135 };

   136 

   137 // A simple wrapper class for fixed size text messages.

   138 class StringLogMessage : public FormatBuffer<256> {

   139  public:

   140   // Wrap this buffer in a stringStream.

   141   stringStream stream() {

   142     return stringStream(_buf, size());

   143   }

   144 };

   145 

   146 // A simple ring buffer of fixed size text messages.

   147 class StringEventLog : public EventLogBase<StringLogMessage> {

   148  public:

   149   StringEventLog(const char* name, int count = LogEventsBufferEntries) : EventLogBase<StringLogMessage>(name, count) {}

   150 

   151   void logv(Thread* thread, const char* format, va_list ap) ATTRIBUTE_PRINTF(3, 0) {

   152     if (!should_log()) return;

   153 

   154     double timestamp = fetch_timestamp();

   155     MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);

   156     int index = compute_log_index();

   157     _records[index].thread = thread;

   158     _records[index].timestamp = timestamp;

   159     _records[index].data.printv(format, ap);

   160   }

   161 

   162   void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(3, 4) {

   163     va_list ap;

   164     va_start(ap, format);

   165     logv(thread, format, ap);

   166     va_end(ap);

   167   }

   168 

   169 };

   170 

   171 

   172 

   173 class Events : AllStatic {

   174   friend class EventLog;

   175 

   176  private:

   177   static EventLog* _logs;

   178 

   179   // A log for generic messages that aren't well categorized.

   180   static StringEventLog* _messages;

   181 

   182   // A log for internal exception related messages, like internal

   183   // throws and implicit exceptions.

   184   static StringEventLog* _exceptions;

   185 

   186   // Deoptization related messages

   187   static StringEventLog* _deopt_messages;

   188 

   189   // Redefinition related messages

   190   static StringEventLog* _redefinitions;

   191 

   192  public:

   193   static void print_all(outputStream* out);

   194 

   195   // Dump all events to the tty

   196   static void print();

   197 

   198   // Logs a generic message with timestamp and format as printf.

   199   static void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);

   200 

   201   // Log exception related message

   202   static void log_exception(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);

   203 

   204   static void log_redefinition(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);

   205 

   206   static void log_deopt_message(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);

   207 

   208   // Register default loggers

   209   static void init();

   210 };

   211 

   212 inline void Events::log(Thread* thread, const char* format, ...) {

   213   if (LogEvents) {

   214     va_list ap;

   215     va_start(ap, format);

   216     _messages->logv(thread, format, ap);

   217     va_end(ap);

   218   }

   219 }

   220 

   221 inline void Events::log_exception(Thread* thread, const char* format, ...) {

   222   if (LogEvents) {

   223     va_list ap;

   224     va_start(ap, format);

   225     _exceptions->logv(thread, format, ap);

   226     va_end(ap);

   227   }

   228 }

   229 

   230 inline void Events::log_redefinition(Thread* thread, const char* format, ...) {

   231   if (LogEvents) {

   232     va_list ap;

   233     va_start(ap, format);

   234     _redefinitions->logv(thread, format, ap);

   235     va_end(ap);

   236   }

   237 }

   238 

   239 inline void Events::log_deopt_message(Thread* thread, const char* format, ...) {

   240   if (LogEvents) {

   241     va_list ap;

   242     va_start(ap, format);

   243     _deopt_messages->logv(thread, format, ap);

   244     va_end(ap);

   245   }

   246 }

   247 

   248 

   249 template <class T>

   250 inline void EventLogBase<T>::print_log_on(outputStream* out) {

   251   if (Thread::current_or_null() == NULL) {

   252     // Not yet attached? Don't try to use locking

   253     print_log_impl(out);

   254   } else {

   255     MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);

   256     print_log_impl(out);

   257   }

   258 }

   259 

   260 // Dump the ring buffer entries that current have entries.

   261 template <class T>

   262 inline void EventLogBase<T>::print_log_impl(outputStream* out) {

   263   out->print_cr("%s (%d events):", _name, _count);

   264   if (_count == 0) {

   265     out->print_cr("No events");

   266     out->cr();

   267     return;

   268   }

   269 

   270   if (_count < _length) {

   271     for (int i = 0; i < _count; i++) {

   272       print(out, _records[i]);

   273     }

   274   } else {

   275     for (int i = _index; i < _length; i++) {

   276       print(out, _records[i]);

   277     }

   278     for (int i = 0; i < _index; i++) {

   279       print(out, _records[i]);

   280     }

   281   }

   282   out->cr();

   283 }

   284 

   285 // Implement a printing routine for the StringLogMessage

   286 template <>

   287 inline void EventLogBase<StringLogMessage>::print(outputStream* out, StringLogMessage& lm) {

   288   out->print_raw(lm);

   289   out->cr();

   290 }

   291 

   292 // Place markers for the beginning and end up of a set of events.

   293 // These end up in the default log.

   294 class EventMark : public StackObj {

   295   StringLogMessage _buffer;

   296 

   297  public:

   298   // log a begin event, format as printf

   299   EventMark(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);

   300   // log an end event

   301   ~EventMark();

   302 };

   303 

   304 #endif // SHARE_VM_UTILITIES_EVENTS_HPP