1 /*
2 * Copyright (c) 1997, 2019, 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_UTILITIES_EVENTS_HPP
26 #define SHARE_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 _mutex(Mutex::event, name, false, Monitor::_safepoint_check_never),
90 _name(name),
91 _length(length),
92 _index(0),
93 _count(0) {
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 template <size_t bufsz>
139 class TemplatedStringLogMessage : public FormatBuffer<bufsz> {
140 public:
141 // Wrap this buffer in a stringStream.
142 stringStream stream() {
143 return stringStream(this->_buf, this->size());
144 }
145 };
146 typedef TemplatedStringLogMessage<256> StringLogMessage;
147 typedef TemplatedStringLogMessage<512> ExtendedStringLogMessage;
148
149 // A simple ring buffer of fixed size text messages.
150 template <size_t bufsz>
151 class TemplatedStringEventLog : public EventLogBase< TemplatedStringLogMessage<bufsz> > {
152 public:
153 TemplatedStringEventLog(const char* name, int count = LogEventsBufferEntries) : EventLogBase< TemplatedStringLogMessage<bufsz> >(name, count) {}
154
155 void logv(Thread* thread, const char* format, va_list ap) ATTRIBUTE_PRINTF(3, 0) {
156 if (!this->should_log()) return;
157
158 double timestamp = this->fetch_timestamp();
159 MutexLockerEx ml(&this->_mutex, Mutex::_no_safepoint_check_flag);
160 int index = this->compute_log_index();
161 this->_records[index].thread = thread;
162 this->_records[index].timestamp = timestamp;
163 this->_records[index].data.printv(format, ap);
164 }
165
166 void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(3, 4) {
167 va_list ap;
168 va_start(ap, format);
169 this->logv(thread, format, ap);
170 va_end(ap);
171 }
172 };
173 typedef TemplatedStringEventLog<256> StringEventLog;
174 typedef TemplatedStringEventLog<512> ExtendedStringEventLog;
175
176 class InstanceKlass;
177
178 // Event log for class unloading events to materialize the class name in place in the log stream.
179 class UnloadingEventLog : public EventLogBase<StringLogMessage> {
180 public:
181 UnloadingEventLog(const char* name, int count = LogEventsBufferEntries) : EventLogBase<StringLogMessage>(name, count) {}
182
183 void log(Thread* thread, InstanceKlass* ik);
184 };
185
186
187 class Events : AllStatic {
188 friend class EventLog;
189
190 private:
191 static EventLog* _logs;
192
193 // A log for generic messages that aren't well categorized.
194 static StringEventLog* _messages;
195
196 // A log for internal exception related messages, like internal
197 // throws and implicit exceptions.
198 static ExtendedStringEventLog* _exceptions;
199
200 // Deoptization related messages
201 static StringEventLog* _deopt_messages;
202
203 // Redefinition related messages
204 static StringEventLog* _redefinitions;
205
206 // Class unloading events
207 static UnloadingEventLog* _class_unloading;
208 public:
209 static void print_all(outputStream* out);
210
211 // Dump all events to the tty
212 static void print();
213
214 // Logs a generic message with timestamp and format as printf.
215 static void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
216
217 // Log exception related message
218 static void log_exception(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
219
220 static void log_redefinition(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
221
222 static void log_class_unloading(Thread* thread, InstanceKlass* ik);
223
224 static void log_deopt_message(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
225
226 // Register default loggers
227 static void init();
228 };
229
230 inline void Events::log(Thread* thread, const char* format, ...) {
231 if (LogEvents) {
232 va_list ap;
233 va_start(ap, format);
234 _messages->logv(thread, format, ap);
235 va_end(ap);
236 }
237 }
238
239 inline void Events::log_exception(Thread* thread, const char* format, ...) {
240 if (LogEvents) {
241 va_list ap;
242 va_start(ap, format);
243 _exceptions->logv(thread, format, ap);
244 va_end(ap);
245 }
246 }
247
248 inline void Events::log_redefinition(Thread* thread, const char* format, ...) {
249 if (LogEvents) {
250 va_list ap;
251 va_start(ap, format);
252 _redefinitions->logv(thread, format, ap);
253 va_end(ap);
254 }
255 }
256
257 inline void Events::log_class_unloading(Thread* thread, InstanceKlass* ik) {
258 if (LogEvents) {
259 _class_unloading->log(thread, ik);
260 }
261 }
262
263 inline void Events::log_deopt_message(Thread* thread, const char* format, ...) {
264 if (LogEvents) {
265 va_list ap;
266 va_start(ap, format);
267 _deopt_messages->logv(thread, format, ap);
268 va_end(ap);
269 }
270 }
271
272
273 template <class T>
274 inline void EventLogBase<T>::print_log_on(outputStream* out) {
275 if (Thread::current_or_null() == NULL) {
276 // Not yet attached? Don't try to use locking
277 print_log_impl(out);
278 } else {
279 MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);
280 print_log_impl(out);
281 }
282 }
283
284 // Dump the ring buffer entries that current have entries.
285 template <class T>
286 inline void EventLogBase<T>::print_log_impl(outputStream* out) {
287 out->print_cr("%s (%d events):", _name, _count);
288 if (_count == 0) {
289 out->print_cr("No events");
290 out->cr();
291 return;
292 }
293
294 if (_count < _length) {
295 for (int i = 0; i < _count; i++) {
296 print(out, _records[i]);
297 }
298 } else {
299 for (int i = _index; i < _length; i++) {
300 print(out, _records[i]);
301 }
302 for (int i = 0; i < _index; i++) {
303 print(out, _records[i]);
304 }
305 }
306 out->cr();
307 }
308
309 // Implement a printing routine for the StringLogMessage
310 template <>
311 inline void EventLogBase<StringLogMessage>::print(outputStream* out, StringLogMessage& lm) {
312 out->print_raw(lm);
313 out->cr();
314 }
315
316 // Implement a printing routine for the ExtendedStringLogMessage
317 template <>
318 inline void EventLogBase<ExtendedStringLogMessage>::print(outputStream* out, ExtendedStringLogMessage& lm) {
319 out->print_raw(lm);
320 out->cr();
321 }
322
323 // Place markers for the beginning and end up of a set of events.
324 // These end up in the default log.
325 class EventMark : public StackObj {
326 StringLogMessage _buffer;
327
328 public:
329 // log a begin event, format as printf
330 EventMark(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
331 // log an end event
332 ~EventMark();
333 };
334
335 #endif // SHARE_UTILITIES_EVENTS_HPP