1 /*
2 * Copyright (c) 2016, 2018, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.jfr.internal;
27
28 import static jdk.jfr.internal.LogLevel.DEBUG;
29 import static jdk.jfr.internal.LogLevel.WARN;
30 import static jdk.jfr.internal.LogTag.JFR;
31
32 import java.io.IOException;
33 import java.io.InputStream;
34 import java.nio.channels.FileChannel;
35 import java.nio.file.StandardOpenOption;
36 import java.security.AccessControlContext;
37 import java.security.AccessController;
38 import java.time.Duration;
39 import java.time.Instant;
40 import java.time.LocalDateTime;
41 import java.util.ArrayList;
42 import java.util.Collections;
43 import java.util.Date;
44 import java.util.HashMap;
45 import java.util.LinkedHashMap;
46 import java.util.LinkedList;
47 import java.util.List;
48 import java.util.Map;
49 import java.util.StringJoiner;
50 import java.util.TimerTask;
51 import java.util.TreeMap;
52
53 import jdk.jfr.Configuration;
54 import jdk.jfr.FlightRecorderListener;
55 import jdk.jfr.Recording;
56 import jdk.jfr.RecordingState;
57
58 public final class PlatformRecording implements AutoCloseable {
59
60 private final PlatformRecorder recorder;
61 private final long id;
62 // Recording settings
63 private Map<String, String> settings = new LinkedHashMap<>();
64 private Duration duration;
65 private Duration maxAge;
66 private long maxSize;
67
68 private WriteableUserPath destination;
69
70 private boolean toDisk = true;
71 private String name;
72 private boolean dumpOnExit;
73 // Timestamp information
74 private Instant stopTime;
75 private Instant startTime;
76
77 // Misc, information
78 private RecordingState state = RecordingState.NEW;
79 private long size;
80 private final LinkedList<RepositoryChunk> chunks = new LinkedList<>();
81 private volatile Recording recording;
82 private TimerTask stopTask;
83 private TimerTask startTask;
84 private AccessControlContext noDestinationDumpOnExitAccessControlContext;
85 private boolean shuoldWriteActiveRecordingEvent = true;
86
87 PlatformRecording(PlatformRecorder recorder, long id) {
88 // Typically the access control context is taken
89 // when you call dump(Path) or setDdestination(Path),
90 // but if no destination is set and dumponexit=true
91 // the control context of the recording is taken when the
92 // Recording object is constructed. This works well for
93 // -XX:StartFlightRecording and JFR.dump
94 this.noDestinationDumpOnExitAccessControlContext = AccessController.getContext();
95 this.id = id;
96 this.recorder = recorder;
97 this.name = String.valueOf(id);
98 }
99
100 public void start() {
101 RecordingState oldState;
102 RecordingState newState;
103 synchronized (recorder) {
104 oldState = recording.getState();
105 if (!Utils.isBefore(state, RecordingState.RUNNING)) {
106 throw new IllegalStateException("Recording can only be started once.");
107 }
108 if (startTask != null) {
109 startTask.cancel();
110 startTask = null;
111 startTime = null;
112 }
113 recorder.start(this);
114 Logger.log(LogTag.JFR, LogLevel.INFO, () -> {
115 // Only print non-default values so it easy to see
116 // which options were added
117 StringJoiner options = new StringJoiner(", ");
118 if (!toDisk) {
119 options.add("disk=false");
120 }
121 if (maxAge != null) {
122 options.add("maxage=" + Utils.formatTimespan(maxAge, ""));
123 }
124 if (maxSize != 0) {
125 options.add("maxsize=" + Utils.formatBytes(maxSize, ""));
126 }
127 if (dumpOnExit) {
128 options.add("dumponexit=true");
129 }
130 if (duration != null) {
131 options.add("duration=" + Utils.formatTimespan(duration, ""));
132 }
133 if (destination != null) {
134 options.add("filename=" + destination.getText());
135 }
136 String optionText = options.toString();
137 if (optionText.length() != 0) {
138 optionText = "{" + optionText + "}";
139 }
140 return "Started recording \"" + getName() + "\" (" + getId() + ") " + optionText;
141 });
142 newState = recording.getState();
143 }
144 notifyIfStateChanged(oldState, newState);
145 }
146
147 public boolean stop(String reason) {
148 return stop(reason, null);
149 }
150
151 public boolean stop(String reason, WriteableUserPath alternativePath) {
152 return stop(reason, alternativePath, Collections.emptyMap());
153 }
154
155 boolean stop(String reason, WriteableUserPath alternativePath, Map<String, String> overlaySettings) {
156 RecordingState oldState;
157 RecordingState newState;
158 synchronized (recorder) {
159 oldState = recording.getState();
160 if (stopTask != null) {
161 stopTask.cancel();
162 stopTask = null;
163 }
164 recorder.stop(this);
165 String endTExt = reason == null ? "" : ". Reason \"" + reason + "\".";
166 Logger.log(LogTag.JFR, LogLevel.INFO, "Stopped recording \"" + recording.getName() + "\" (" + recording.getId()+ ")" + endTExt);
167 this.stopTime = Instant.now();
168 newState = recording.getState();
169 }
170 WriteableUserPath dest = getDestination();
171 if (dest == null && alternativePath != null) {
172 dest = alternativePath;
173 }
174 if (dest != null) {
175 try {
176 copyTo(dest, reason, overlaySettings);
177 Logger.log(LogTag.JFR, LogLevel.INFO, "Wrote recording \"" + recording.getName() + "\" (" + recording.getId()+ ") to " + dest.getText());
178 notifyIfStateChanged(newState, oldState);
179 close(); // remove if copied out
180 } catch (IOException e) {
181 // throw e; // BUG8925030
182 }
183 } else {
184 notifyIfStateChanged(newState, oldState);
185 }
186 return true;
187 }
188
189 public void scheduleStart(Duration delay) {
190 synchronized (recorder) {
191 ensureOkForSchedule();
192
193 startTime = Instant.now().plus(delay);
194 LocalDateTime now = LocalDateTime.now().plus(delay);
195 setState(RecordingState.DELAYED);
196 startTask = createStartTask();
197 recorder.getTimer().schedule(startTask, delay.toMillis());
198 Logger.log(LogTag.JFR, LogLevel.INFO, "Scheduled recording \"" + recording.getName() + "\" (" + recording.getId()+ ") to start at " + now);
199 }
200 }
201
202 private void ensureOkForSchedule() {
203 if (getState() != RecordingState.NEW) {
204 throw new IllegalStateException("Only a new recoridng can be scheduled for start");
205 }
206 }
207
208 private TimerTask createStartTask() {
209 // Taking ref. to recording here.
210 // Opens up for memory leaks.
211 return new TimerTask() {
212 @Override
213 public void run() {
214 synchronized (recorder) {
215 if (getState() != RecordingState.DELAYED) {
216 return;
217 }
218 start();
219 }
220 }
221 };
222 }
223
224 void scheduleStart(Instant startTime) {
225 synchronized (recorder) {
226 ensureOkForSchedule();
227 this.startTime = startTime;
228 setState(RecordingState.DELAYED);
229 startTask = createStartTask();
230 recorder.getTimer().schedule(startTask, startTime.toEpochMilli());
231 }
232 }
233
234 public Map<String, String> getSettings() {
235 synchronized (recorder) {
236 return settings;
237 }
238 }
239
240 public long getSize() {
241 return size;
242 }
243
244 public Instant getStopTime() {
245 synchronized (recorder) {
246 return stopTime;
247 }
248 }
249
250 public Instant getStartTime() {
251 synchronized (recorder) {
252 return startTime;
253 }
254 }
255
256 public Long getMaxSize() {
257 synchronized (recorder) {
258 return maxSize;
259 }
260 }
261
262 public Duration getMaxAge() {
263 synchronized (recorder) {
264 return maxAge;
265 }
266 }
267
268 public String getName() {
269 synchronized (recorder) {
270 return name;
271 }
272 }
273
274
275 public RecordingState getState() {
276 synchronized (recorder) {
277 return state;
278 }
279 }
280
281 @Override
282 public void close() {
283 RecordingState oldState;
284 RecordingState newState;
285
286 synchronized (recorder) {
287 oldState = getState();
288 if (RecordingState.CLOSED != getState()) {
289 if (startTask != null) {
290 startTask.cancel();
291 startTask = null;
292 }
293 recorder.finish(this);
294 for (RepositoryChunk c : chunks) {
295 removed(c);
296 }
297 chunks.clear();
298 setState(RecordingState.CLOSED);
299 Logger.log(LogTag.JFR, LogLevel.INFO, "Closed recording \"" + getName() + "\" (" + getId()+ ")");
300 }
301 newState = getState();
302 }
303 notifyIfStateChanged(newState, oldState);
304 }
305
306 public void copyTo(WriteableUserPath path, String reason, Map<String, String> dumpSettings) throws IOException {
307 synchronized (recorder) {
308 RecordingState state = getState();
309 if (state == RecordingState.CLOSED) {
310 throw new IOException("Recording \"" + name + "\" (id=" + id + ") has been closed, no contents to write");
311 }
312 if (state == RecordingState.DELAYED || state == RecordingState.NEW) {
313 throw new IOException("Recording \"" + name + "\" (id=" + id + ") has not started, no contents to write");
314 }
315 if (state == RecordingState.STOPPED) {
316 // have all we need, just write it
317 dumpToFile(path, reason, getId());
318 return;
319 }
320
321 // Recording is RUNNING, create a clone
322 try(Recording r = new Recording()) {
323 PlatformRecording clone = PrivateAccess.getInstance().getPlatformRecording(r);
324 clone.setShouldWriteActiveRecordingEvent(false);
325 clone.setName(getName());
326 clone.setDestination(path);
327 clone.setToDisk(true);
328 // We purposely don't clone settings, since
329 // a union a == a
330 if (!isToDisk()) {
331 // force memory contents to disk
332 clone.start();
333 } else {
334 // using existing chunks on disk
335 for (RepositoryChunk c : chunks) {
336 clone.add(c);
337 }
338 clone.setState(RecordingState.RUNNING);
339 clone.setStartTime(getStartTime());
340 }
341 if (dumpSettings.isEmpty()) {
342 clone.setSettings(getSettings());
343 clone.stop(reason); // dumps to destination path here
344 } else {
345 // Risk of violating lock order here, since
346 // clone.stop() will take recorder lock inside
347 // metadata lock, but OK if we already
348 // have recorder lock when we entered metadata lock
349 Thread.holdsLock(recorder);
350 synchronized(MetadataRepository.getInstance()) {
351 Thread.holdsLock(recorder);
352 Map<String, String> oldSettings = getSettings();
353 Map<String, String> newSettings = new HashMap<>(oldSettings);
354 // replace with dump settings
355 newSettings.putAll(dumpSettings);
356 clone.setSettings(newSettings);
357 clone.stop(reason);
358 }
359 }
360 }
361 return;
362 }
363 }
364
365 private void dumpToFile(WriteableUserPath userPath, String reason, long id) throws IOException {
366 userPath.doPriviligedIO(() -> {
367 try (ChunksChannel cc = new ChunksChannel(chunks); FileChannel fc = FileChannel.open(userPath.getReal(), StandardOpenOption.WRITE, StandardOpenOption.APPEND)) {
368 cc.transferTo(fc);
369 fc.force(true);
370 }
371 return null;
372 });
373 }
374
375 public boolean isToDisk() {
376 synchronized (recorder) {
377 return toDisk;
378 }
379 }
380
381 public void setMaxSize(long maxSize) {
382 synchronized (recorder) {
383 if (getState() == RecordingState.CLOSED) {
384 throw new IllegalStateException("Can't set max age when recording is closed");
385 }
386 this.maxSize = maxSize;
387 trimToSize();
388 }
389 }
390
391 public void setDestination(WriteableUserPath userSuppliedPath) throws IOException {
392 synchronized (recorder) {
393 if (Utils.isState(getState(), RecordingState.STOPPED, RecordingState.CLOSED)) {
394 throw new IllegalStateException("Destination can't be set on a recording that has been stopped/closed");
395 }
396 this.destination = userSuppliedPath;
397 }
398 }
399
400 public WriteableUserPath getDestination() {
401 synchronized (recorder) {
402 return destination;
403 }
404 }
405
406 void setState(RecordingState state) {
407 synchronized (recorder) {
408 this.state = state;
409 }
410 }
411
412 void setStartTime(Instant startTime) {
413 synchronized (recorder) {
414 this.startTime = startTime;
415 }
416 }
417
418 void setStopTime(Instant timeStamp) {
419 synchronized (recorder) {
420 stopTime = timeStamp;
421 }
422 }
423
424 public long getId() {
425 synchronized (recorder) {
426 return id;
427 }
428 }
429
430 public void setName(String name) {
431 synchronized (recorder) {
432 ensureNotClosed();
433 this.name = name;
434 }
435 }
436
437 private void ensureNotClosed() {
438 if (getState() == RecordingState.CLOSED) {
439 throw new IllegalStateException("Can't change name on a closed recording");
440 }
441 }
442
443 public void setDumpOnExit(boolean dumpOnExit) {
444 synchronized (recorder) {
445 this.dumpOnExit = dumpOnExit;
446 }
447 }
448
449 public boolean getDumpOnExit() {
450 synchronized (recorder) {
451 return dumpOnExit;
452 }
453 }
454
455 public void setToDisk(boolean toDisk) {
456 synchronized (recorder) {
457 if (Utils.isState(getState(), RecordingState.NEW, RecordingState.DELAYED)) {
458 this.toDisk = toDisk;
459 } else {
460 throw new IllegalStateException("Recording option disk can't be changed after recording has started");
461 }
462 }
463 }
464
465 public void setSetting(String id, String value) {
466 synchronized (recorder) {
467 this.settings.put(id, value);
468 if (getState() == RecordingState.RUNNING) {
469 recorder.updateSettings();
470 }
471 }
472 }
473
474 public void setSettings(Map<String, String> settings) {
475 setSettings(settings, true);
476 }
477
478 private void setSettings(Map<String, String> settings, boolean update) {
479 if (LogTag.JFR_SETTING.shouldLog(LogLevel.INFO.level) && update) {
480 TreeMap<String, String> ordered = new TreeMap<>(settings);
481 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, "New settings for recording \"" + getName() + "\" (" + getId() + ")");
482 for (Map.Entry<String, String> entry : ordered.entrySet()) {
483 String text = entry.getKey() + "=\"" + entry.getValue() + "\"";
484 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, text);
485 }
486 }
487 synchronized (recorder) {
488 this.settings = new LinkedHashMap<>(settings);
489 if (getState() == RecordingState.RUNNING && update) {
490 recorder.updateSettings();
491 }
492 }
493 }
494
495
496 private void notifyIfStateChanged(RecordingState newState, RecordingState oldState) {
497 if (oldState == newState) {
498 return;
499 }
500 for (FlightRecorderListener cl : PlatformRecorder.getListeners()) {
501 try {
502 cl.recordingStateChanged(getRecording());
503 } catch (RuntimeException re) {
504 Logger.log(JFR, WARN, "Error notifying recorder listener:" + re.getMessage());
505 }
506 }
507 }
508
509 public void setRecording(Recording recording) {
510 this.recording = recording;
511 }
512
513 public Recording getRecording() {
514 return recording;
515 }
516
517 @Override
518 public String toString() {
519 return getName() + " (id=" + getId() + ") " + getState();
520 }
521
522 public void setConfiguration(Configuration c) {
523 setSettings(c.getSettings());
524 }
525
526 public void setMaxAge(Duration maxAge) {
527 synchronized (recorder) {
528 if (getState() == RecordingState.CLOSED) {
529 throw new IllegalStateException("Can't set max age when recording is closed");
530 }
531 this.maxAge = maxAge;
532 if (maxAge != null) {
533 trimToAge(Instant.now().minus(maxAge));
534 }
535 }
536 }
537
538 void appendChunk(RepositoryChunk chunk) {
539 if (!chunk.isFinished()) {
540 throw new Error("not finished chunk " + chunk.getStartTime());
541 }
542 synchronized (recorder) {
543 if (!toDisk) {
544 return;
545 }
546 if (maxAge != null) {
547 trimToAge(chunk.getEndTime().minus(maxAge));
548 }
549 chunks.addLast(chunk);
550 added(chunk);
551 trimToSize();
552 }
553 }
554
555 private void trimToSize() {
556 if (maxSize == 0) {
557 return;
558 }
559 while (size > maxSize && chunks.size() > 1) {
560 RepositoryChunk c = chunks.removeFirst();
561 removed(c);
562 }
563 }
564
565 private void trimToAge(Instant oldest) {
566 while (!chunks.isEmpty()) {
567 RepositoryChunk oldestChunk = chunks.peek();
568 if (oldestChunk.getEndTime().isAfter(oldest)) {
569 return;
570 }
571 chunks.removeFirst();
572 removed(oldestChunk);
573 }
574 }
575
576 void add(RepositoryChunk c) {
577 chunks.add(c);
578 added(c);
579 }
580
581 private void added(RepositoryChunk c) {
582 c.use();
583 size += c.getSize();
584 Logger.log(JFR, DEBUG, ()-> "Recording \"" + name + "\" (" + id + ") added chunk " + c.toString() + ", current size=" + size);
585 }
586
587 private void removed(RepositoryChunk c) {
588 size -= c.getSize();
589 Logger.log(JFR, DEBUG, ()-> "Recording \"" + name + "\" (" + id + ") removed chunk " + c.toString() + ", current size=" + size);
590 c.release();
591 }
592
593 public List<RepositoryChunk> getChunks() {
594 return chunks;
595 }
596
597 public InputStream open(Instant start, Instant end) throws IOException {
598 synchronized (recorder) {
599 if (getState() != RecordingState.STOPPED) {
600 throw new IOException("Recording must be stopped before it can be read.");
601 }
602 List<RepositoryChunk> chunksToUse = new ArrayList<RepositoryChunk>();
603 for (RepositoryChunk chunk : chunks) {
604 if (chunk.isFinished()) {
605 Instant chunkStart = chunk.getStartTime();
606 Instant chunkEnd = chunk.getEndTime();
607 if (start == null || !chunkEnd.isBefore(start)) {
608 if (end == null || !chunkStart.isAfter(end)) {
609 chunksToUse.add(chunk);
610 }
611 }
612 }
613 }
614 if (chunksToUse.isEmpty()) {
615 return null;
616 }
617 return new ChunkInputStream(chunksToUse);
618 }
619 }
620
621 public Duration getDuration() {
622 synchronized (recorder) {
623 return duration;
624 }
625 }
626
627 void setInternalDuration(Duration duration) {
628 this.duration = duration;
629 }
630
631 public void setDuration(Duration duration) {
632 synchronized (recorder) {
633 if (Utils.isState(getState(), RecordingState.STOPPED, RecordingState.CLOSED)) {
634 throw new IllegalStateException("Duration can't be set after a recording has been stopped/closed");
635 }
636 setInternalDuration(duration);
637 if (getState() != RecordingState.NEW) {
638 updateTimer();
639 }
640 }
641 }
642
643 void updateTimer() {
644 if (stopTask != null) {
645 stopTask.cancel();
646 stopTask = null;
647 }
648 if (getState() == RecordingState.CLOSED) {
649 return;
650 }
651 if (duration != null) {
652 stopTask = createStopTask();
653 recorder.getTimer().schedule(stopTask, new Date(startTime.plus(duration).toEpochMilli()));
654 }
655 }
656
657 TimerTask createStopTask() {
658 return new TimerTask() {
659 @Override
660 public void run() {
661 try {
662 stop("End of duration reached");
663 } catch (Throwable t) {
664 // Prevent malicious user to propagate exception callback in the wrong context
665 Logger.log(LogTag.JFR, LogLevel.ERROR, "Could not stop recording. " + t.getMessage());
666 }
667 }
668 };
669 }
670
671 public Recording newCopy(boolean stop) {
672 return recorder.newCopy(this, stop);
673 }
674
675 void setStopTask(TimerTask stopTask) {
676 synchronized (recorder) {
677 this.stopTask = stopTask;
678 }
679 }
680
681 void clearDestination() {
682 destination = null;
683 }
684
685 public AccessControlContext getNoDestinationDumpOnExitAccessControlContext() {
686 return noDestinationDumpOnExitAccessControlContext;
687 }
688
689 void setShouldWriteActiveRecordingEvent(boolean shouldWrite) {
690 this.shuoldWriteActiveRecordingEvent = shouldWrite;
691 }
692
693 boolean shouldWriteMetadataEvent() {
694 return shuoldWriteActiveRecordingEvent;
695 }
696 }