feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/tracing/MultiplexProviderFactory.java

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2008, 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 sun.tracing;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import com.sun.tracing.ProviderFactory;
+import com.sun.tracing.Provider;
+import com.sun.tracing.Probe;
+
+/**
+ * Factory class to create tracing Providers.
+ *
+ * This factory creates a "multiplex provider", which is a provider that
+ * encapsulates a list of providers and whose probes trigger a corresponding
+ * trigger in each of the encapsulated providers' probes.
+ *
+ * This is used when there are multiple tracing frameworks activated at once.
+ * A user-defined provider gets implementation for each of the activated
+ * frameworks and this multiplex framework is what is ultimately passed
+ * back to the user.  All probe triggers are multiplexed to each
+ * active framework.
+ *
+ * @since 1.7
+ */
+public class MultiplexProviderFactory extends ProviderFactory {
+
+    private Set<ProviderFactory> factories;
+
+    public MultiplexProviderFactory(Set<ProviderFactory> factories) {
+        this.factories = factories;
+    }
+
+    public <T extends Provider> T createProvider(Class<T> cls) {
+        HashSet<Provider> providers = new HashSet<Provider>();
+        for (ProviderFactory factory : factories) {
+            providers.add(factory.createProvider(cls));
+        }
+        MultiplexProvider provider = new MultiplexProvider(cls, providers);
+        provider.init();
+        return provider.newProxyInstance();
+    }
+}
+
+class MultiplexProvider extends ProviderSkeleton {
+
+    private Set<Provider> providers;
+
+    protected ProbeSkeleton createProbe(Method m) {
+        return new MultiplexProbe(m, providers);
+    }
+
+    MultiplexProvider(Class<? extends Provider> type, Set<Provider> providers) {
+        super(type);
+        this.providers = providers;
+    }
+
+    public void dispose() {
+        for (Provider p : providers) {
+            p.dispose();
+        }
+        super.dispose();
+    }
+}
+
+class MultiplexProbe extends ProbeSkeleton {
+
+    private Set<Probe> probes;
+
+    MultiplexProbe(Method m, Set<Provider> providers) {
+        super(m.getParameterTypes());
+        probes = new HashSet<Probe>();
+        for (Provider p : providers) {
+            Probe probe = p.getProbe(m);
+            if (probe != null) {
+                probes.add(probe);
+            }
+        }
+    }
+
+    public boolean isEnabled() {
+        for (Probe p : probes) {
+            if (p.isEnabled()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void uncheckedTrigger(Object[] args) {
+        for (Probe p : probes) {
+            try {
+                // try the fast path
+                ProbeSkeleton ps = (ProbeSkeleton)p;
+                ps.uncheckedTrigger(args);
+            } catch (ClassCastException e) {
+                // Probe.trigger takes an "Object ..." varargs parameter,
+                // so we can't call it directly.
+                try {
+                    Method m = Probe.class.getMethod(
+                        "trigger", Class.forName("[java.lang.Object"));
+                    m.invoke(p, args);
+                } catch (Exception e1) {
+                    assert false; // This shouldn't happen
+                }
+            }
+        }
+    }
+}
+

jdkSrc/jdk8/sun/tracing/NullProviderFactory.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2008, 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 sun.tracing;
+
+import java.lang.reflect.Method;
+
+import com.sun.tracing.ProviderFactory;
+import com.sun.tracing.Provider;
+
+/**
+ * Factory class to create tracing Providers.
+ *
+ * This factory will create tracing instances that do nothing.
+ * It is used when no tracing is desired, but Provider instances still
+ * must be generated so that tracing calls in the application continue to
+ * run.
+ *
+ * @since 1.7
+ */
+public class NullProviderFactory extends ProviderFactory {
+
+    /**
+     * Creates and returns a Null provider.
+     *
+     * See comments at {@code ProviderSkeleton.createProvider()} for more
+     * details.
+     *
+     * @return a provider whose probe trigger are no-ops.
+     */
+    public <T extends Provider> T createProvider(Class<T> cls) {
+        NullProvider provider = new NullProvider(cls);
+        provider.init();
+        return provider.newProxyInstance();
+    }
+}
+
+class NullProvider extends ProviderSkeleton {
+
+    NullProvider(Class<? extends Provider> type) {
+        super(type);
+    }
+
+    protected ProbeSkeleton createProbe(Method m) {
+        return new NullProbe(m.getParameterTypes());
+    }
+}
+
+class NullProbe extends ProbeSkeleton {
+
+    public NullProbe(Class<?>[] parameters) {
+        super(parameters);
+    }
+
+    public boolean isEnabled() {
+        return false;
+    }
+
+    public void uncheckedTrigger(Object[] args) {
+    }
+}
+

jdkSrc/jdk8/sun/tracing/PrintStreamProviderFactory.java

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2008, 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 sun.tracing;
+
+import java.lang.reflect.Method;
+import java.io.PrintStream;
+import java.util.HashMap;
+
+import com.sun.tracing.ProviderFactory;
+import com.sun.tracing.Provider;
+import com.sun.tracing.ProviderName;
+import com.sun.tracing.Probe;
+import com.sun.tracing.ProbeName;
+
+/**
+ * Factory class to create tracing Providers.
+ *
+ * This factory will create tracing instances that print to a PrintStream
+ * when activated.
+ *
+ * @since 1.7
+ */
+public class PrintStreamProviderFactory extends ProviderFactory {
+
+    private PrintStream stream;
+
+    public PrintStreamProviderFactory(PrintStream stream) {
+        this.stream = stream;
+    }
+
+    public <T extends Provider> T createProvider(Class<T> cls) {
+        PrintStreamProvider provider = new PrintStreamProvider(cls, stream);
+        provider.init();
+        return provider.newProxyInstance();
+    }
+}
+
+class PrintStreamProvider extends ProviderSkeleton {
+
+    private PrintStream stream;
+    private String providerName;
+
+    protected ProbeSkeleton createProbe(Method m) {
+        String probeName = getAnnotationString(m, ProbeName.class, m.getName());
+        return new PrintStreamProbe(this, probeName, m.getParameterTypes());
+    }
+
+    PrintStreamProvider(Class<? extends Provider> type, PrintStream stream) {
+        super(type);
+        this.stream = stream;
+        this.providerName = getProviderName();
+    }
+
+    PrintStream getStream() {
+        return stream;
+    }
+
+    String getName() {
+        return providerName;
+    }
+}
+
+class PrintStreamProbe extends ProbeSkeleton {
+
+    private PrintStreamProvider provider;
+    private String name;
+
+    PrintStreamProbe(PrintStreamProvider p, String name, Class<?>[] params) {
+        super(params);
+        this.provider = p;
+        this.name = name;
+    }
+
+    public boolean isEnabled() {
+        return true;
+    }
+
+    public void uncheckedTrigger(Object[] args) {
+        StringBuffer sb = new StringBuffer();
+        sb.append(provider.getName());
+        sb.append(".");
+        sb.append(name);
+        sb.append("(");
+        boolean first = true;
+        for (Object o : args) {
+            if (first == false) {
+                sb.append(",");
+            } else {
+                first = false;
+            }
+            sb.append(o.toString());
+        }
+        sb.append(")");
+        provider.getStream().println(sb.toString());
+    }
+}
+

jdkSrc/jdk8/sun/tracing/ProbeSkeleton.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2008, 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 sun.tracing;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+import com.sun.tracing.Probe;
+
+/**
+ * Provides common code for implementation of {@code Probe} classes.
+ *
+ * @since 1.7
+ */
+public abstract class ProbeSkeleton implements Probe {
+
+    protected Class<?>[] parameters;
+
+    protected ProbeSkeleton(Class<?>[] parameters) {
+        this.parameters = parameters;
+    }
+
+    public abstract boolean isEnabled();  // framework-dependent
+
+    /**
+     * Triggers the probe with verified arguments.
+     *
+     * The caller of this method must have already determined that the
+     * arity and types of the arguments match what the probe was
+     * declared with.
+     */
+    public abstract void uncheckedTrigger(Object[] args); // framework-dependent
+
+    private static boolean isAssignable(Object o, Class<?> formal) {
+        if (o != null) {
+            if ( !formal.isInstance(o) ) {
+                if ( formal.isPrimitive() ) { // o might be a boxed primitive
+                    try {
+                        // Yuck.  There must be a better way of doing this
+                        Field f = o.getClass().getField("TYPE");
+                        return formal.isAssignableFrom((Class<?>)f.get(null));
+                    } catch (Exception e) {
+                        /* fall-through. */
+                    }
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Performs a type-check of the parameters before triggering the probe.
+     */
+    public void trigger(Object ... args) {
+        if (args.length != parameters.length) {
+            throw new IllegalArgumentException("Wrong number of arguments");
+        } else {
+            for (int i = 0; i < parameters.length; ++i) {
+                if ( !isAssignable(args[i], parameters[i]) ) {
+                    throw new IllegalArgumentException(
+                            "Wrong type of argument at position " + i);
+                }
+            }
+            uncheckedTrigger(args);
+        }
+    }
+}

jdkSrc/jdk8/sun/tracing/ProviderSkeleton.java

@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) 2008, 2013, 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 sun.tracing;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.annotation.Annotation;
+import java.util.HashMap;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+import com.sun.tracing.Provider;
+import com.sun.tracing.Probe;
+import com.sun.tracing.ProviderName;
+
+/**
+ * Provides a common code for implementation of {@code Provider} classes.
+ *
+ * Each tracing subsystem needs to provide three classes, a factory
+ * (derived from {@code ProviderFactory}, a provider (a subclass of
+ * {@code Provider}, and a probe type (subclass of {@code ProbeSkeleton}).
+ *
+ * The factory object takes a user-defined interface and provides an
+ * implementation of it whose method calls will trigger probes in the
+ * tracing framework.
+ *
+ * The framework's provider class, and its instances, are not seen by the
+ * user at all -- they usually sit in the background and receive and dispatch
+ * the calls to the user's provider interface.  The {@code ProviderSkeleton}
+ * class provides almost all of the implementation needed by a framework
+ * provider.  Framework providers must only provide a constructor and
+ * disposal method, and implement the {@code createProbe} method to create
+ * an appropriate {@code ProbeSkeleton} subclass.
+ *
+ * The framework's probe class provides the implementation of the two
+ * probe methods, {@code isEnabled()} and {@code uncheckedTrigger()}.  Both are
+ * framework-dependent implementations.
+ *
+ * @since 1.7
+ */
+
+public abstract class ProviderSkeleton implements InvocationHandler, Provider {
+
+    protected boolean active; // set to false after dispose() is called
+    protected Class<? extends Provider> providerType; // user's interface
+    protected HashMap<Method, ProbeSkeleton> probes; // methods to probes
+
+
+    /**
+     * Creates a framework-specific probe subtype.
+     *
+     * This method is implemented by the framework's provider and returns
+     * framework-specific probes for a method.
+     *
+     * @param method A method in the user's interface
+     * @return a subclass of ProbeSkeleton for the particular framework.
+     */
+    protected abstract ProbeSkeleton createProbe(Method method);
+
+    /**
+     * Initializes the provider.
+     *
+     * @param type the user's interface
+     */
+    protected ProviderSkeleton(Class<? extends Provider> type) {
+        this.active = false; // in case of some error during initialization
+        this.providerType = type;
+        this.probes = new HashMap<Method,ProbeSkeleton>();
+    }
+
+    /**
+     * Post-constructor initialization routine.
+     *
+     * Subclass instances must be initialized before they can create probes.
+     * It is up to the factory implementations to call this after construction.
+     */
+    public void init() {
+        Method[] methods = AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
+            public Method[] run() {
+                return providerType.getDeclaredMethods();
+            }
+        });
+
+        for (Method m : methods) {
+            if ( m.getReturnType() != Void.TYPE ) {
+                throw new IllegalArgumentException(
+                   "Return value of method is not void");
+            } else {
+                probes.put(m, createProbe(m));
+            }
+        }
+        this.active = true;
+    }
+
+    /**
+     * Magic routine which creates an implementation of the user's interface.
+     *
+     * This method creates the instance of the user's interface which is
+     * passed back to the user.  Every call upon that interface will be
+     * redirected to the {@code invoke()} method of this class (until
+     * overridden by the VM).
+     *
+     * @return an implementation of the user's interface
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends Provider> T newProxyInstance() {
+        final InvocationHandler ih = this;
+        return AccessController.doPrivileged(new PrivilegedAction<T>() {
+            public T run() {
+               return (T)Proxy.newProxyInstance(providerType.getClassLoader(),
+                   new Class<?>[] { providerType }, ih);
+            }});
+    }
+
+    /**
+     * Triggers a framework probe when a user interface method is called.
+     *
+     * This method dispatches a user interface method call to the appropriate
+     * probe associated with this framework.
+     *
+     * If the invoked method is not a user-defined member of the interface,
+     * then it is a member of {@code Provider} or {@code Object} and we
+     * invoke the method directly.
+     *
+     * @param proxy the instance whose method was invoked
+     * @param method the method that was called
+     * @param args the arguments passed in the call.
+     * @return always null, if the method is a user-defined probe
+     */
+    public Object invoke(Object proxy, Method method, Object[] args) {
+        Class declaringClass = method.getDeclaringClass();
+        // not a provider subtype's own method
+        if (declaringClass != providerType) {
+            try {
+                // delegate only to methods declared by
+                // com.sun.tracing.Provider or java.lang.Object
+                if (declaringClass == Provider.class ||
+                    declaringClass == Object.class) {
+                    return method.invoke(this, args);
+                } else {
+                    // assert false : "this should never happen"
+                    //    reaching here would indicate a breach
+                    //    in security in the higher layers
+                    throw new SecurityException();
+                }
+            } catch (IllegalAccessException e) {
+                assert false;
+            } catch (InvocationTargetException e) {
+                assert false;
+            }
+        } else {
+            triggerProbe(method, args);
+        }
+        return null;
+    }
+
+    /**
+     * Direct accessor for {@code Probe} objects.
+     *
+     * @param m the method corresponding to a probe
+     * @return the method associated probe object, or null
+     */
+    public Probe getProbe(Method m) {
+        return active ? probes.get(m) : null;
+    }
+
+    /**
+     * Default provider disposal method.
+     *
+     * This is overridden in subclasses as needed.
+     */
+    public void dispose() {
+        active = false;
+        probes.clear();
+    }
+
+    /**
+     * Gets the user-specified provider name for the user's interface.
+     *
+     * If the user's interface has a {@ProviderName} annotation, that value
+     * is used.  Otherwise we use the simple name of the user interface's class.
+     * @return the provider name
+     */
+    protected String getProviderName() {
+        return getAnnotationString(
+                providerType, ProviderName.class, providerType.getSimpleName());
+    }
+
+    /**
+     * Utility method for getting a string value from an annotation.
+     *
+     * Used for getting a string value from an annotation with a 'value' method.
+     *
+     * @param element the element that was annotated, either a class or method
+     * @param annotation the class of the annotation we're interested in
+     * @param defaultValue the value to return if the annotation doesn't
+     * exist, doesn't have a "value", or the value is empty.
+     */
+    protected static String getAnnotationString(
+            AnnotatedElement element, Class<? extends Annotation> annotation,
+            String defaultValue) {
+        String ret = (String)getAnnotationValue(
+                element, annotation, "value", defaultValue);
+        return ret.isEmpty() ? defaultValue : ret;
+    }
+
+    /**
+     * Utility method for calling an arbitrary method in an annotation.
+     *
+     * @param element the element that was annotated, either a class or method
+     * @param annotation the class of the annotation we're interested in
+     * @param methodName the name of the method in the annotation we wish
+     * to call.
+     * @param defaultValue the value to return if the annotation doesn't
+     * exist, or we couldn't invoke the method for some reason.
+     * @return the result of calling the annotation method, or the default.
+     */
+    protected static Object getAnnotationValue(
+            AnnotatedElement element, Class<? extends Annotation> annotation,
+            String methodName, Object defaultValue) {
+        Object ret = defaultValue;
+        try {
+            Method m = annotation.getMethod(methodName);
+            Annotation a = element.getAnnotation(annotation);
+            ret = m.invoke(a);
+        } catch (NoSuchMethodException e) {
+            assert false;
+        } catch (IllegalAccessException e) {
+            assert false;
+        } catch (InvocationTargetException e) {
+            assert false;
+        } catch (NullPointerException e) {
+            assert false;
+        }
+        return ret;
+    }
+
+    protected void triggerProbe(Method method, Object[] args) {
+        if (active) {
+            ProbeSkeleton p = probes.get(method);
+            if (p != null) {
+                // Skips argument check -- already done by javac
+                p.uncheckedTrigger(args);
+            }
+        }
+    }
+}

jdkSrc/jdk8/sun/tracing/dtrace/Activation.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2008, 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 sun.tracing.dtrace;
+
+import java.lang.ref.WeakReference;
+import java.lang.ref.ReferenceQueue;
+import java.security.Permission;
+import java.util.HashSet;
+
+class Activation {
+    private SystemResource resource;
+    private int referenceCount;
+
+    Activation(String moduleName, DTraceProvider[] providers) {
+        SecurityManager security = System.getSecurityManager();
+        if (security != null) {
+            Permission perm =
+                new RuntimePermission("com.sun.tracing.dtrace.createProvider");
+            security.checkPermission(perm);
+        }
+        referenceCount = providers.length;
+        for (DTraceProvider p : providers) {
+            p.setActivation(this);
+        }
+        resource = new SystemResource(
+            this, JVM.activate(moduleName, providers));
+    }
+
+    void disposeProvider(DTraceProvider p) {
+        if (--referenceCount == 0) {
+            resource.dispose();
+        }
+    }
+}
+
+/**
+ * The native resource part of an Activation.
+ *
+ * This holds the native handle.
+ *
+ * If the user loses a reference to a set of Providers without disposing them,
+ * and GC determines the Activation is unreachable, then the next
+ * activation or flush call will automatically dispose the unreachable objects
+ *
+ * The SystemResource instances are creating during activation, and
+ * unattached during disposal.  When created, they always have a
+ * strong reference to them via the {@code resources} static member.  Explicit
+ * {@code dispose} calls will unregister the native resource and remove
+ * references to the SystemResource object.  Absent an explicit dispose,
+ * when their associated Activation object becomes garbage, the SystemResource
+ * object will be enqueued on the reference queue and disposed at the
+ * next call to {@code flush}.
+ */
+class SystemResource extends WeakReference<Activation> {
+
+    private long handle;
+
+    private static ReferenceQueue<Activation> referenceQueue =
+        referenceQueue = new ReferenceQueue<Activation>();
+    static HashSet<SystemResource> resources = new HashSet<SystemResource>();
+
+    SystemResource(Activation activation, long handle) {
+        super(activation, referenceQueue);
+        this.handle = handle;
+        flush();
+        resources.add(this);
+    }
+
+    void dispose() {
+        JVM.dispose(handle);
+        resources.remove(this);
+        handle = 0;
+    }
+
+    static void flush() {
+        SystemResource resource = null;
+        while ((resource = (SystemResource)referenceQueue.poll()) != null) {
+            if (resource.handle != 0) {
+                resource.dispose();
+            }
+        }
+    }
+}
+

jdkSrc/jdk8/sun/tracing/dtrace/DTraceProbe.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2008, 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 sun.tracing.dtrace;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+
+import sun.tracing.ProbeSkeleton;
+
+class DTraceProbe extends ProbeSkeleton {
+    private Object proxy;
+    private Method declared_method;
+    private Method implementing_method;
+
+    DTraceProbe(Object proxy, Method m) {
+        super(m.getParameterTypes());
+        this.proxy = proxy;
+        this.declared_method = m;
+        try {
+            // The JVM will override the proxy method's implementation with
+            // a version that will invoke the probe.
+            this.implementing_method =  proxy.getClass().getMethod(
+                m.getName(), m.getParameterTypes());
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Internal error, wrong proxy class");
+        }
+    }
+
+    public boolean isEnabled() {
+        return JVM.isEnabled(implementing_method);
+    }
+
+    public void uncheckedTrigger(Object[] args) {
+        try {
+            implementing_method.invoke(proxy, args);
+        } catch (IllegalAccessException e) {
+            assert false;
+        } catch (InvocationTargetException e) {
+            assert false;
+        }
+    }
+
+    String getProbeName() {
+        return DTraceProvider.getProbeName(declared_method);
+    }
+
+    String getFunctionName() {
+        return DTraceProvider.getFunctionName(declared_method);
+    }
+
+    Method getMethod() {
+        return implementing_method;
+    }
+
+    Class<?>[] getParameterTypes() {
+        return this.parameters;
+    }
+}
+

jdkSrc/jdk8/sun/tracing/dtrace/DTraceProvider.java

@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2008, 2013, 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 sun.tracing.dtrace;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.annotation.Annotation;
+
+import sun.tracing.ProviderSkeleton;
+import sun.tracing.ProbeSkeleton;
+import com.sun.tracing.Provider;
+import com.sun.tracing.ProbeName;
+import com.sun.tracing.dtrace.Attributes;
+import com.sun.tracing.dtrace.ModuleName;
+import com.sun.tracing.dtrace.FunctionName;
+import com.sun.tracing.dtrace.StabilityLevel;
+import com.sun.tracing.dtrace.DependencyClass;
+
+import sun.misc.ProxyGenerator;
+
+class DTraceProvider extends ProviderSkeleton {
+
+    private Activation activation;
+    private Object proxy;
+
+    // For proxy generation
+    private final static Class[] constructorParams = { InvocationHandler.class };
+    private final String proxyClassNamePrefix = "$DTraceTracingProxy";
+
+    static final String DEFAULT_MODULE = "java_tracing";
+    static final String DEFAULT_FUNCTION = "unspecified";
+
+    private static long nextUniqueNumber = 0;
+    private static synchronized long getUniqueNumber() {
+        return nextUniqueNumber++;
+    }
+
+    protected ProbeSkeleton createProbe(Method m) {
+        return new DTraceProbe(proxy, m);
+    }
+
+    DTraceProvider(Class<? extends Provider> type) {
+        super(type);
+    }
+
+    void setProxy(Object p) {
+        proxy = p;
+    }
+
+    void setActivation(Activation a) {
+        this.activation = a;
+    }
+
+    public void dispose() {
+        if (activation != null) {
+            activation.disposeProvider(this);
+            activation = null;
+        }
+        super.dispose();
+    }
+
+    /**
+     * Magic routine which creates an implementation of the user's interface.
+     *
+     * This method uses the ProxyGenerator directly to bypass the
+     * java.lang.reflect.proxy cache so that we get a unique class each
+     * time it's called and can't accidently reuse a $Proxy class.
+     *
+     * @return an implementation of the user's interface
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends Provider> T newProxyInstance() {
+        /*
+         * Choose a name for the proxy class to generate.
+         */
+        long num = getUniqueNumber();
+
+        String proxyPkg = "";
+        if (!Modifier.isPublic(providerType.getModifiers())) {
+            String name = providerType.getName();
+            int n = name.lastIndexOf('.');
+            proxyPkg = ((n == -1) ? "" : name.substring(0, n + 1));
+        }
+
+        String proxyName = proxyPkg + proxyClassNamePrefix + num;
+
+        /*
+         * Generate the specified proxy class.
+         */
+        Class<?> proxyClass = null;
+        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
+                proxyName, new Class<?>[] { providerType });
+        try {
+            proxyClass = JVM.defineClass(
+                providerType.getClassLoader(), proxyName,
+                proxyClassFile, 0, proxyClassFile.length);
+        } catch (ClassFormatError e) {
+            /*
+             * A ClassFormatError here means that (barring bugs in the
+             * proxy class generation code) there was some other
+             * invalid aspect of the arguments supplied to the proxy
+             * class creation (such as virtual machine limitations
+             * exceeded).
+             */
+            throw new IllegalArgumentException(e.toString());
+        }
+
+        /*
+         * Invoke its constructor with the designated invocation handler.
+         */
+        try {
+            Constructor cons = proxyClass.getConstructor(constructorParams);
+            return (T)cons.newInstance(new Object[] { this });
+        } catch (ReflectiveOperationException e) {
+            throw new InternalError(e.toString(), e);
+        }
+    }
+
+    // In the normal case, the proxy object's method implementations will call
+    // this method (it usually calls the ProviderSkeleton's version).  That
+    // method uses the passed 'method' object to lookup the associated
+    // 'ProbeSkeleton' and calls uncheckedTrigger() on that probe to cause the
+    // probe to fire.  DTrace probes are different in that the proxy class's
+    // methods are immediately overridden with native code to fire the probe
+    // directly.  So this method should never get invoked.  We also wire up the
+    // DTraceProbe.uncheckedTrigger() method to call the proxy method instead
+    // of doing the work itself.
+    protected void triggerProbe(Method method, Object[] args) {
+        assert false : "This method should have been overridden by the JVM";
+    }
+
+    public String getProviderName() {
+        return super.getProviderName();
+    }
+
+    String getModuleName() {
+        return getAnnotationString(
+            providerType, ModuleName.class, DEFAULT_MODULE);
+    }
+
+    static String getProbeName(Method method) {
+        return getAnnotationString(
+            method, ProbeName.class, method.getName());
+    }
+
+    static String getFunctionName(Method method) {
+        return getAnnotationString(
+            method, FunctionName.class, DEFAULT_FUNCTION);
+    }
+
+    DTraceProbe[] getProbes() {
+        return probes.values().toArray(new DTraceProbe[0]);
+    }
+
+    StabilityLevel getNameStabilityFor(Class<? extends Annotation> type) {
+        Attributes attrs = (Attributes)getAnnotationValue(
+            providerType, type, "value", null);
+        if (attrs == null) {
+            return StabilityLevel.PRIVATE;
+        } else {
+            return attrs.name();
+        }
+    }
+
+    StabilityLevel getDataStabilityFor(Class<? extends Annotation> type) {
+        Attributes attrs = (Attributes)getAnnotationValue(
+            providerType, type, "value", null);
+        if (attrs == null) {
+            return StabilityLevel.PRIVATE;
+        } else {
+            return attrs.data();
+        }
+    }
+
+    DependencyClass getDependencyClassFor(Class<? extends Annotation> type) {
+        Attributes attrs = (Attributes)getAnnotationValue(
+            providerType, type, "value", null);
+        if (attrs == null) {
+            return DependencyClass.UNKNOWN;
+        } else {
+            return attrs.dependency();
+        }
+    }
+}

jdkSrc/jdk8/sun/tracing/dtrace/DTraceProviderFactory.java

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2008, 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 sun.tracing.dtrace;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.security.Permission;
+
+import com.sun.tracing.ProviderFactory;
+import com.sun.tracing.Provider;
+
+/**
+ * Factory class to create JSDT Providers.
+ *
+ * This class contains methods to create an instance of a Provider
+ * interface which can be used to place tracepoints in an application.
+ * Method calls upon that instance trigger DTrace probes that
+ * are visible from DTrace scripts.   Such calls have no other
+ * side effects in the application.
+ * <p>
+ * The DTrace script mechanisms for listing and matching probes will not see
+ * nor match any probes until the provider they reside in is created by a
+ * call to {@code createProvider()} (or {@code createProviders()}).
+ * <p>
+ * Providers that are created should be disposed of when they are no longer
+ * needed to free up system resources, at which point the associated
+ * DTrace probes will no longer be available to DTrace.  One disposes a
+ * provider by calling
+ * {@link com.sun.tracing.Provider#dispose Provider.dispose()} on a
+ * created provider instance.
+ *
+ * @since 1.7
+ */
+public final class DTraceProviderFactory extends ProviderFactory {
+    /**
+     * Creates an instance of a provider which can then be used to trigger
+     * DTrace probes.
+     *
+     * The provider specification, provided as an argument, should only
+     * contain methods which have a 'void' return type and String or
+     * integer-based typed arguments (long, int, short, char, byte, or boolean).
+     *
+     * @param cls A user-defined interface which extends {@code Provider}.
+     * @return An instance of the interface which is used to trigger
+     * the DTrace probes.
+     * @throws java.lang.SecurityException if a security manager has been
+     * installed and it denies
+     * RuntimePermission("com.sun.dtrace.jsdt.createProvider")
+     * @throws java.lang.IllegalArgumentException if the interface contains
+     * methods that do not return null, or that contain arguments that are
+     * not String or integer types.
+     */
+    public <T extends Provider> T createProvider(Class<T> cls) {
+        DTraceProvider jsdt = new DTraceProvider(cls);
+        T proxy = jsdt.newProxyInstance();
+        jsdt.setProxy(proxy);
+        jsdt.init();
+        new Activation(jsdt.getModuleName(), new DTraceProvider[] { jsdt });
+        return proxy;
+    }
+
+    /**
+     * Creates multiple providers at once.
+     *
+     * This method batches together a number of provider instantiations.
+     * It works similarly
+     * to {@code createProvider}, but operates on a set of providers instead
+     * of one at a time.  This method is in place since some DTrace
+     * implementations limit the number of times that providers can be
+     * created.  When numerous providers can be created at once with this
+     * method, it will count only as a single creation point to DTrace, thus
+     * it uses less system resources.
+     * <p>
+     * All of the probes in the providers will be visible to DTrace after
+     * this call and all will remain visible until all of the providers
+     * are disposed.
+     * <p>
+     * The {@code moduleName} parameter will override any {@code ModuleName}
+     * annotation associated with any of the providers in the set.
+     * All of the probes created by this call will share the same
+     * module name.
+     * <p>
+     * @param providers a set of provider specification interfaces
+     * @param moduleName the module name to associate with all probes
+     * @return A map which maps the provider interface specification to an
+     * implementing instance.
+     * @throws java.lang.SecurityException if a security manager has been
+     * installed and it denies
+     * RuntimePermission("com.sun.dtrace.jsdt.createProvider")
+     * @throws java.lang.IllegalArgumentException if any of the interface
+     * contains methods that do not return null, or that contain arguments
+     * that are not String or integer types.
+     */
+    public Map<Class<? extends Provider>,Provider> createProviders(
+            Set<Class<? extends Provider>> providers, String moduleName) {
+        HashMap<Class<? extends Provider>,Provider> map =
+            new HashMap<Class<? extends Provider>,Provider>();
+        HashSet<DTraceProvider> jsdts = new HashSet<DTraceProvider>();
+        for (Class<? extends Provider> cls : providers) {
+            DTraceProvider jsdt = new DTraceProvider(cls);
+            jsdts.add(jsdt);
+            map.put(cls, jsdt.newProxyInstance());
+        }
+        new Activation(moduleName, jsdts.toArray(new DTraceProvider[0]));
+        return map;
+    }
+
+    /**
+     * Used to check the status of DTrace support in the underlying JVM and
+     * operating system.
+     *
+     * This is an informative method only - the Java-level effects of
+     * creating providers and triggering probes will not change whether or
+     * not DTrace is supported by the underlying systems.
+     *
+     * @return true if DTrace is supported
+     */
+    public static boolean isSupported() {
+        try {
+            SecurityManager security = System.getSecurityManager();
+            if (security != null) {
+                Permission perm = new RuntimePermission(
+                        "com.sun.tracing.dtrace.createProvider");
+                security.checkPermission(perm);
+            }
+            return JVM.isSupported();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+}

jdkSrc/jdk8/sun/tracing/dtrace/JVM.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2008, 2012, 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 sun.tracing.dtrace;
+
+import java.lang.reflect.Method;
+
+/**
+ * Container class for JVM interface native methods
+ *
+ * @since 1.7
+ */
+class JVM {
+
+    static {
+        java.security.AccessController.doPrivileged(
+            new java.security.PrivilegedAction<Void>() {
+                public Void run() {
+                    System.loadLibrary("jsdt");
+                    return null;
+                }
+            });
+    }
+
+    static long activate(String moduleName, DTraceProvider[] providers) {
+        return activate0(moduleName, providers);
+    }
+
+    static void dispose(long handle) {
+        dispose0(handle);
+    }
+
+    static boolean isEnabled(Method m) {
+        return isEnabled0(m);
+    }
+
+    static boolean isSupported() {
+        return isSupported0();
+    }
+
+    static Class<?> defineClass(
+            ClassLoader loader, String name, byte[] b, int off, int len) {
+        return defineClass0(loader, name, b, off, len);
+    }
+
+    private static native long activate0(
+        String moduleName, DTraceProvider[] providers);
+    private static native void dispose0(long activation_handle);
+    private static native boolean isEnabled0(Method m);
+    private static native boolean isSupported0();
+    private static native Class<?> defineClass0(
+        ClassLoader loader, String name, byte[] b, int off, int len);
+}

jdkSrc/jdk8/sun/tracing/package-info.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2008, 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.
+ */
+
+/**
+ * This package contains internal common code for implementing tracing
+ * frameworks, and defined a number of existing frameworks.
+ * <p>
+ * There are four tracing frameworks currently defined.  The "Null" and
+ * "Multiplex" frameworks are used internally as part of the implementation.
+ * The "DTrace" framework is the prime consumer framework at the moment,
+ * while the "PrintStream" framework is a functional, but hidden, framework
+ * which can be used to track probe firings.  All but the "DTrace" framework
+ * are defined in this package.  The "DTrace" framework is implemented in the
+ * {@code sun.tracing.dtrace} package.
+ * <p>
+ * This package also contains the {@code ProviderSkeleton} class, which
+ * holds most of the common code needed for implementing frameworks.
+ * <p>
+ * The "Null" framework is used when there are no other active frameworks.
+ * It accomplishes absolutely nothing and is merely a placeholder so that
+ * the application can call the tracing routines without error.
+ * <p>
+ * The "Multiplex" framework is used when there are multiple active frameworks.
+ * It is initialized with the framework factories and create providers and
+ * probes that dispatch to each active framework in turn.
+ * <p>
+ * The "PrintStream" framework is currently a debugging framework which
+ * dispatches trace calls to a user-defined PrintStream class, defined by
+ * a property.  It may some day be opened up to general use.
+ * <p>
+ * See the {@code sun.tracing.dtrace} and {@code com.sun.tracing.dtrace}
+ * packages for information on the "DTrace" framework.
+ */
+
+package sun.tracing;