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
--- EOF ---