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.
49class 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.
71template <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.
138class 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.
147class 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
173class 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
212inline 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
221inline 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
230inline 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
239inline 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
249template <class T>
250inline 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.
261template <class T>
262inline 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
286template <>
287inline 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.
294class 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
305