--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.jfr/share/classes/jdk/jfr/internal/Options.java	Tue May 15 20:24:34 2018 +0200
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.jfr.internal;
+
+import jdk.jfr.internal.SecuritySupport.SafePath;
+import jdk.internal.misc.Unsafe;
+
+/**
+ * Options that control Flight Recorder.
+ *
+ * Can be set using JFR.configure
+ *
+ */
+public final class Options {
+
+    private final static JVM jvm = JVM.getJVM();
+    private final static long WAIT_INTERVAL = 1000; // ms;
+
+    private final static long MIN_MAX_CHUNKSIZE = 1024 * 1024;
+
+    private static final long DEFAULT_GLOBAL_BUFFER_COUNT = 20;
+    private static final long DEFAULT_GLOBAL_BUFFER_SIZE = 524288;
+    private static final long DEFAULT_MEMORY_SIZE = DEFAULT_GLOBAL_BUFFER_COUNT * DEFAULT_GLOBAL_BUFFER_SIZE;
+    private static long DEFAULT_THREAD_BUFFER_SIZE;
+    private static final int DEFAULT_STACK_DEPTH = 64;
+    private static final boolean DEFAULT_SAMPLE_THREADS = true;
+    private static final long DEFAULT_MAX_CHUNK_SIZE = 12 * 1024 * 1024;
+    private static final SafePath DEFAULT_DUMP_PATH = SecuritySupport.USER_HOME;
+
+    private static long memorySize;
+    private static long globalBufferSize;
+    private static long globalBufferCount;
+    private static long threadBufferSize;
+    private static int stackDepth;
+    private static boolean sampleThreads;
+    private static long maxChunkSize;
+    private static SafePath dumpPath;
+
+    static {
+        final long pageSize = Unsafe.getUnsafe().pageSize();
+        DEFAULT_THREAD_BUFFER_SIZE = pageSize > 8 * 1024 ? pageSize : 8 * 1024;
+        reset();
+    }
+
+    public static synchronized void setMaxChunkSize(long max) {
+        if (max < MIN_MAX_CHUNKSIZE) {
+            throw new IllegalArgumentException("Max chunk size must be at least " + MIN_MAX_CHUNKSIZE);
+        }
+        jvm.setFileNotification(max);
+        maxChunkSize = max;
+    }
+
+    public static synchronized long getMaxChunkSize() {
+        return maxChunkSize;
+    }
+
+    public static synchronized void setMemorySize(long memSize) {
+        jvm.setMemorySize(memSize);
+        memorySize = memSize;
+    }
+
+    public static synchronized long getMemorySize() {
+        return memorySize;
+    }
+
+    public static synchronized void setThreadBufferSize(long threadBufSize) {
+        jvm.setThreadBufferSize(threadBufSize);
+        threadBufferSize = threadBufSize;
+    }
+
+    public static synchronized long getThreadBufferSize() {
+        return threadBufferSize;
+    }
+
+    public static synchronized long getGlobalBufferSize() {
+        return globalBufferSize;
+    }
+
+    public static synchronized void setGlobalBufferCount(long globalBufCount) {
+        jvm.setGlobalBufferCount(globalBufCount);
+        globalBufferCount = globalBufCount;
+    }
+
+    public static synchronized long getGlobalBufferCount() {
+        return globalBufferCount;
+    }
+
+    public static synchronized void setGlobalBufferSize(long globalBufsize) {
+        jvm.setGlobalBufferSize(globalBufsize);
+        globalBufferSize = globalBufsize;
+    }
+
+    public static synchronized void setDumpPath(SafePath path) {
+        dumpPath = path;
+    }
+
+    public static synchronized SafePath getDumpPath() {
+        return dumpPath;
+    }
+
+    public static synchronized void setStackDepth(Integer stackTraceDepth) {
+        jvm.setStackDepth(stackTraceDepth);
+        stackDepth = stackTraceDepth;
+    }
+
+    public static synchronized int getStackDepth() {
+        return stackDepth;
+    }
+
+    public static synchronized void setSampleThreads(Boolean sample) {
+        jvm.setSampleThreads(sample);
+        sampleThreads = sample;
+    }
+
+    public static synchronized boolean getSampleThreads() {
+        return sampleThreads;
+    }
+
+    private static synchronized void reset() {
+        setMaxChunkSize(DEFAULT_MAX_CHUNK_SIZE);
+        setMemorySize(DEFAULT_MEMORY_SIZE);
+        setGlobalBufferSize(DEFAULT_GLOBAL_BUFFER_SIZE);
+        setGlobalBufferCount(DEFAULT_GLOBAL_BUFFER_COUNT);
+        setDumpPath(DEFAULT_DUMP_PATH);
+        setSampleThreads(DEFAULT_SAMPLE_THREADS);
+        setStackDepth(DEFAULT_STACK_DEPTH);
+        setThreadBufferSize(DEFAULT_THREAD_BUFFER_SIZE);
+    }
+
+    static synchronized long getWaitInterval() {
+        return WAIT_INTERVAL;
+    }
+
+    static void ensureInitialized() {
+        // trigger clinit which will setup JVM defaults.
+    }
+
+
+}