jdk-sandbox: comparison src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecording.java

equal deleted inserted replaced

-:6c306d54366d
+:a390cbb82d47
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
-import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.StringJoiner;
 import jdk.jfr.Configuration;
 import jdk.jfr.FlightRecorderListener;
 import jdk.jfr.Recording;
 import jdk.jfr.RecordingState;
+import jdk.jfr.internal.SecuritySupport.SafePath;
 public final class PlatformRecording implements AutoCloseable {
 private final PlatformRecorder recorder;
 private final long id;
 private WriteableUserPath destination;
 private boolean toDisk = true;
 private String name;
 private boolean dumpOnExit;
+private SafePath dumpOnExitDirectory = new SafePath(".");
 // Timestamp information
 private Instant stopTime;
 private Instant startTime;
 // Misc, information
 PlatformRecording(PlatformRecorder recorder, long id) {
 // Typically the access control context is taken
 // when you call dump(Path) or setDdestination(Path),
 // but if no destination is set and dumponexit=true
 // the control context of the recording is taken when the
-// Recording object is constructed.  This works well for
+// Recording object is constructed. This works well for
 // -XX:StartFlightRecording and JFR.dump
 this.noDestinationDumpOnExitAccessControlContext = AccessController.getContext();
 this.id = id;
 this.recorder = recorder;
 this.name = String.valueOf(id);
 }
 recorder.start(this);
 Logger.log(LogTag.JFR, LogLevel.INFO, () -> {
 // Only print non-default values so it easy to see
 // which options were added
 StringJoiner options = new StringJoiner(", ");
 if (!toDisk) {
 options.add("disk=false");
 }
 if (maxAge != null) {
 options.add("maxage=" + Utils.formatTimespan(maxAge, ""));
 }
 if (maxSize != 0) {
 options.add("maxsize=" + Utils.formatBytes(maxSize, ""));
 }
 if (dumpOnExit) {
 options.add("dumponexit=true");
 }
 if (duration != null) {
 options.add("duration=" + Utils.formatTimespan(duration, ""));
 }
 if (destination != null) {
 options.add("filename=" + destination.getText());
 }
 String optionText = options.toString();
 if (optionText.length() != 0) {
 optionText = "{" + optionText + "}";
 }
 return "Started recording \"" + getName() + "\" (" + getId() + ") " + optionText;
 });
 newState = getState();
 }
 notifyIfStateChanged(oldState, newState);
 }
 public boolean stop(String reason) {
-return stop(reason, null);
-}
-public boolean stop(String reason, WriteableUserPath alternativePath) {
-return stop(reason, alternativePath, Collections.emptyMap());
-}
-boolean stop(String reason, WriteableUserPath alternativePath, Map<String, String> overlaySettings) {
 RecordingState oldState;
 RecordingState newState;
 synchronized (recorder) {
 oldState = getState();
 if (stopTask != null) {
 stopTask.cancel();
 stopTask = null;
 }
-recorder.stop(this, alternativePath);
+recorder.stop(this);
 String endText = reason == null ? "" : ". Reason \"" + reason + "\".";
-Logger.log(LogTag.JFR, LogLevel.INFO, "Stopped recording \"" + getName() + "\" (" + getId()+ ")" + endText);
+Logger.log(LogTag.JFR, LogLevel.INFO, "Stopped recording \"" + getName() + "\" (" + getId() + ")" + endText);
 this.stopTime = Instant.now();
 newState = getState();
 }
 WriteableUserPath dest = getDestination();
-if (dest == null && alternativePath != null) {
-dest = alternativePath;
-}
 if (dest != null) {
 try {
-copyTo(dest, reason, overlaySettings);
+dumpStopped(dest);
-Logger.log(LogTag.JFR, LogLevel.INFO, "Wrote recording \"" + getName() + "\" (" + getId()+ ") to " + dest.getText());
+Logger.log(LogTag.JFR, LogLevel.INFO, "Wrote recording \"" + getName() + "\" (" + getId() + ") to " + dest.getText());
 notifyIfStateChanged(newState, oldState);
 close(); // remove if copied out
-} catch (IOException e) {
+} catch(IOException e) {
 // throw e; // BUG8925030
 }
 } else {
 notifyIfStateChanged(newState, oldState);
 }
 startTime = Instant.now().plus(delay);
 LocalDateTime now = LocalDateTime.now().plus(delay);
 setState(RecordingState.DELAYED);
 startTask = createStartTask();
 recorder.getTimer().schedule(startTask, delay.toMillis());
-Logger.log(LogTag.JFR, LogLevel.INFO, "Scheduled recording \"" + getName() + "\" (" + getId()+ ") to start at " + now);
+Logger.log(LogTag.JFR, LogLevel.INFO, "Scheduled recording \"" + getName() + "\" (" + getId() + ") to start at " + now);
 }
 }
 private void ensureOkForSchedule() {
 if (getState() != RecordingState.NEW) {
 synchronized (recorder) {
 return name;
 }
 }
 public RecordingState getState() {
 synchronized (recorder) {
 return state;
 }
 }
 for (RepositoryChunk c : chunks) {
 removed(c);
 }
 chunks.clear();
 setState(RecordingState.CLOSED);
-Logger.log(LogTag.JFR, LogLevel.INFO, "Closed recording \"" + getName() + "\" (" + getId()+ ")");
+Logger.log(LogTag.JFR, LogLevel.INFO, "Closed recording \"" + getName() + "\" (" + getId() + ")");
 }
 newState = getState();
 }
 notifyIfStateChanged(newState, oldState);
 }
-public void copyTo(WriteableUserPath path, String reason, Map<String, String> dumpSettings) throws IOException {
+// To be used internally when doing dumps.
-synchronized (recorder) {
+// Caller must have recorder lock and close recording before releasing lock
-RecordingState state = getState();
+public PlatformRecording newSnapshotClone(String reason, Boolean pathToGcRoots) throws IOException {
-if (state == RecordingState.CLOSED) {
+if(!Thread.holdsLock(recorder)) {
-throw new IOException("Recording \"" + name + "\" (id=" + id + ") has been closed, no contents to write");
+throw new InternalError("Caller must have recorder lock");
 }
-if (state == RecordingState.DELAYED || state == RecordingState.NEW) {
+RecordingState state = getState();
-throw new IOException("Recording \"" + name + "\" (id=" + id + ") has not started, no contents to write");
+if (state == RecordingState.CLOSED) {
-}
+throw new IOException("Recording \"" + name + "\" (id=" + id + ") has been closed, no contents to write");
-if (state == RecordingState.STOPPED) {
+}
-// have all we need, just write it
+if (state == RecordingState.DELAYED || state == RecordingState.NEW) {
-dumpToFile(path, reason, getId());
+throw new IOException("Recording \"" + name + "\" (id=" + id + ") has not started, no contents to write");
-return;
+}
-}
+if (state == RecordingState.STOPPED) {
+PlatformRecording clone = recorder.newTemporaryRecording();
-// Recording is RUNNING, create a clone
+for (RepositoryChunk r : chunks) {
-try(PlatformRecording clone = recorder.newRecording(Collections.emptyMap(), 0)) {
+clone.add(r);
-clone.setShouldWriteActiveRecordingEvent(false);
+}
-clone.setName(getName());
+return clone;
-clone.setDestination(path);
+}
-clone.setToDisk(true);
-// We purposely don't clone settings, since
+// Recording is RUNNING, create a clone
-// a union a == a
+PlatformRecording clone = recorder.newTemporaryRecording();
-if (!isToDisk()) {
+clone.setShouldWriteActiveRecordingEvent(false);
-// force memory contents to disk
+clone.setName(getName());
-clone.start();
+clone.setDestination(this.destination);
-} else {
+clone.setToDisk(true);
-// using existing chunks on disk
+// We purposely don't clone settings here, since
-for (RepositoryChunk c : chunks) {
+// a union a == a
-clone.add(c);
+if (!isToDisk()) {
-}
+// force memory contents to disk
-clone.setState(RecordingState.RUNNING);
+clone.start();
-clone.setStartTime(getStartTime());
+} else {
-}
+// using existing chunks on disk
-if (dumpSettings.isEmpty()) {
+for (RepositoryChunk c : chunks) {
-clone.setSettings(getSettings());
+clone.add(c);
-clone.stop(reason); // dumps to destination path here
+}
-} else {
+clone.setState(RecordingState.RUNNING);
-// Risk of violating lock order here, since
+clone.setStartTime(getStartTime());
-// clone.stop() will take recorder lock inside
+}
-// metadata lock, but OK if we already
+if (pathToGcRoots == null) {
-// have recorder lock when we entered metadata lock
+clone.setSettings(getSettings()); // needed for old object sample
-Thread.holdsLock(recorder);
+clone.stop(reason); // dumps to destination path here
-synchronized(MetadataRepository.getInstance()) {
+} else {
-Thread.holdsLock(recorder);
+// Risk of violating lock order here, since
-Map<String, String> oldSettings = getSettings();
+// clone.stop() will take recorder lock inside
-Map<String, String> newSettings = new HashMap<>(oldSettings);
+// metadata lock, but OK if we already
-// replace with dump settings
+// have recorder lock when we entered metadata lock
-newSettings.putAll(dumpSettings);
+synchronized (MetadataRepository.getInstance()) {
-clone.setSettings(newSettings);
+clone.setSettings(OldObjectSample.createSettingsForSnapshot(this, pathToGcRoots));
 clone.stop(reason);
 }
 }
-}
+return clone;
-return;
-}
-}
-private void dumpToFile(WriteableUserPath userPath, String reason, long id) throws IOException {
-userPath.doPriviligedIO(() -> {
-try (ChunksChannel cc = new ChunksChannel(chunks); FileChannel fc = FileChannel.open(userPath.getReal(), StandardOpenOption.WRITE, StandardOpenOption.APPEND)) {
-cc.transferTo(fc);
-fc.force(true);
-}
-return null;
-});
 }
 public boolean isToDisk() {
 synchronized (recorder) {
 return toDisk;
 this.maxSize = maxSize;
 trimToSize();
 }
 }
 public void setDestination(WriteableUserPath userSuppliedPath) throws IOException {
 synchronized (recorder) {
 if (Utils.isState(getState(), RecordingState.STOPPED, RecordingState.CLOSED)) {
 throw new IllegalStateException("Destination can't be set on a recording that has been stopped/closed");
 }
 this.destination = userSuppliedPath;
 private void setSettings(Map<String, String> settings, boolean update) {
 if (LogTag.JFR_SETTING.shouldLog(LogLevel.INFO.level) && update) {
 TreeMap<String, String> ordered = new TreeMap<>(settings);
 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, "New settings for recording \"" + getName() + "\" (" + getId() + ")");
 for (Map.Entry<String, String> entry : ordered.entrySet()) {
-String text =  entry.getKey() + "=\"" + entry.getValue() + "\"";
+String text = entry.getKey() + "=\"" + entry.getValue() + "\"";
 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, text);
 }
 }
 synchronized (recorder) {
 this.settings = new LinkedHashMap<>(settings);
 if (getState() == RecordingState.RUNNING && update) {
 recorder.updateSettings();
 }
 }
 }
 private void notifyIfStateChanged(RecordingState newState, RecordingState oldState) {
 if (oldState == newState) {
 return;
 }
 }
 private void added(RepositoryChunk c) {
 c.use();
 size += c.getSize();
-Logger.log(JFR, DEBUG,  ()-> "Recording \"" + name + "\" (" + id + ") added chunk " + c.toString() + ", current size=" + size);
+Logger.log(JFR, DEBUG, () -> "Recording \"" + name + "\" (" + id + ") added chunk " + c.toString() + ", current size=" + size);
 }
 private void removed(RepositoryChunk c) {
 size -= c.getSize();
-Logger.log(JFR, DEBUG,  ()->  "Recording \"" + name + "\" (" + id + ") removed chunk " + c.toString() + ", current size=" + size);
+Logger.log(JFR, DEBUG, () -> "Recording \"" + name + "\" (" + id + ") removed chunk " + c.toString() + ", current size=" + size);
 c.release();
 }
 public List<RepositoryChunk> getChunks() {
 return chunks;
 public void run() {
 try {
 stop("End of duration reached");
 } catch (Throwable t) {
 // Prevent malicious user to propagate exception callback in the wrong context
-Logger.log(LogTag.JFR, LogLevel.ERROR, "Could not stop recording. " + t.getMessage());
+Logger.log(LogTag.JFR, LogLevel.ERROR, "Could not stop recording.");
 }
 }
 };
 }
 this.stopTask = stopTask;
 }
 }
 void clearDestination() {
 destination = null;
 }
 public AccessControlContext getNoDestinationDumpOnExitAccessControlContext() {
 return noDestinationDumpOnExitAccessControlContext;
 }
 void setShouldWriteActiveRecordingEvent(boolean shouldWrite) {
 this.shuoldWriteActiveRecordingEvent = shouldWrite;
 }
 boolean shouldWriteMetadataEvent() {
 return shuoldWriteActiveRecordingEvent;
 }
+// Dump running and stopped recordings
+public void dump(WriteableUserPath writeableUserPath) throws IOException {
+synchronized (recorder) {
+try(PlatformRecording p = newSnapshotClone("Dumped by user", null))  {
+p.dumpStopped(writeableUserPath);
+}
+}
+}
+public void dumpStopped(WriteableUserPath userPath) throws IOException {
+synchronized (recorder) {
+userPath.doPriviligedIO(() -> {
+try (ChunksChannel cc = new ChunksChannel(chunks); FileChannel fc = FileChannel.open(userPath.getReal(), StandardOpenOption.WRITE, StandardOpenOption.APPEND)) {
+cc.transferTo(fc);
+fc.force(true);
+}
+return null;
+});
+}
+}
+public void filter(Instant begin, Instant end, Long maxSize) {
+synchronized (recorder) {
+List<RepositoryChunk> result = removeAfter(end, removeBefore(begin, new ArrayList<>(chunks)));
+if (maxSize != null) {
+if (begin != null && end == null) {
+result = reduceFromBeginning(maxSize, result);
+} else {
+result = reduceFromEnd(maxSize, result);
+}
+}
+int size = 0;
+for (RepositoryChunk r : result) {
+size += r.getSize();
+r.use();
+}
+this.size = size;
+for (RepositoryChunk r : chunks) {
+r.release();
+}
+chunks.clear();
+chunks.addAll(result);
+}
+}
+private static List<RepositoryChunk> removeBefore(Instant time, List<RepositoryChunk> input) {
+if (time == null) {
+return input;
+}
+List<RepositoryChunk> result = new ArrayList<>(input.size());
+for (RepositoryChunk r : input) {
+if (!r.getEndTime().isBefore(time)) {
+result.add(r);
+}
+}
+return result;
+}
+private static List<RepositoryChunk> removeAfter(Instant time, List<RepositoryChunk> input) {
+if (time == null) {
+return input;
+}
+List<RepositoryChunk> result = new ArrayList<>(input.size());
+for (RepositoryChunk r : input) {
+if (!r.getStartTime().isAfter(time)) {
+result.add(r);
+}
+}
+return result;
+}
+private static List<RepositoryChunk> reduceFromBeginning(Long maxSize, List<RepositoryChunk> input) {
+if (maxSize == null || input.isEmpty()) {
+return input;
+}
+List<RepositoryChunk> result = new ArrayList<>(input.size());
+long total = 0;
+for (RepositoryChunk r : input) {
+total += r.getSize();
+if (total > maxSize) {
+break;
+}
+result.add(r);
+}
+// always keep at least one chunk
+if (result.isEmpty()) {
+result.add(input.get(0));
+}
+return result;
+}
+private static List<RepositoryChunk> reduceFromEnd(Long maxSize, List<RepositoryChunk> input) {
+Collections.reverse(input);
+List<RepositoryChunk> result = reduceFromBeginning(maxSize, input);
+Collections.reverse(result);
+return result;
+}
+public void setDumpOnExitDirectory(SafePath directory) {
+this.dumpOnExitDirectory = directory;
+}
+public SafePath getDumpOnExitDirectory()  {
+return this.dumpOnExitDirectory;
+}
 }

changeset 50745	a390cbb82d47
parent 50197	f4735ff8d17d
child 52413	6372f5af9612