1 /*

     2  * Copyright (c) 2008, 2014, 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 sun.tracing.dtrace;

    27 

    28 import java.lang.reflect.Method;

    29 import java.lang.reflect.Modifier;

    30 import java.lang.reflect.Constructor;

    31 import java.lang.reflect.InvocationHandler;

    32 import java.lang.reflect.InvocationTargetException;

    33 import java.lang.annotation.Annotation;

    34 

    35 import sun.tracing.ProviderSkeleton;

    36 import sun.tracing.ProbeSkeleton;

    37 import com.sun.tracing.Provider;

    38 import com.sun.tracing.ProbeName;

    39 import com.sun.tracing.dtrace.Attributes;

    40 import com.sun.tracing.dtrace.ModuleName;

    41 import com.sun.tracing.dtrace.FunctionName;

    42 import com.sun.tracing.dtrace.StabilityLevel;

    43 import com.sun.tracing.dtrace.DependencyClass;

    44 

    45 import sun.misc.ProxyGenerator;

    46 

    47 class DTraceProvider extends ProviderSkeleton {

    48 

    49     private Activation activation;

    50     private Object proxy;

    51 

    52     // For proxy generation

    53     private final static Class<?>[] constructorParams = { InvocationHandler.class };

    54     private final String proxyClassNamePrefix = "$DTraceTracingProxy";

    55 

    56     static final String DEFAULT_MODULE = "java_tracing";

    57     static final String DEFAULT_FUNCTION = "unspecified";

    58 

    59     private static long nextUniqueNumber = 0;

    60     private static synchronized long getUniqueNumber() {

    61         return nextUniqueNumber++;

    62     }

    63 

    64     protected ProbeSkeleton createProbe(Method m) {

    65         return new DTraceProbe(proxy, m);

    66     }

    67 

    68     DTraceProvider(Class<? extends Provider> type) {

    69         super(type);

    70     }

    71 

    72     void setProxy(Object p) {

    73         proxy = p;

    74     }

    75 

    76     void setActivation(Activation a) {

    77         this.activation = a;

    78     }

    79 

    80     public void dispose() {

    81         if (activation != null) {

    82             activation.disposeProvider(this);

    83             activation = null;

    84         }

    85         super.dispose();

    86     }

    87 

    88     /**

    89      * Magic routine which creates an implementation of the user's interface.

    90      *

    91      * This method uses the ProxyGenerator directly to bypass the

    92      * java.lang.reflect.proxy cache so that we get a unique class each

    93      * time it's called and can't accidently reuse a $Proxy class.

    94      *

    95      * @return an implementation of the user's interface

    96      */

    97     @SuppressWarnings("unchecked")

    98     public <T extends Provider> T newProxyInstance() {

    99         /*

   100          * Choose a name for the proxy class to generate.

   101          */

   102         long num = getUniqueNumber();

   103 

   104         String proxyPkg = "";

   105         if (!Modifier.isPublic(providerType.getModifiers())) {

   106             String name = providerType.getName();

   107             int n = name.lastIndexOf('.');

   108             proxyPkg = ((n == -1) ? "" : name.substring(0, n + 1));

   109         }

   110 

   111         String proxyName = proxyPkg + proxyClassNamePrefix + num;

   112 

   113         /*

   114          * Generate the specified proxy class.

   115          */

   116         Class<?> proxyClass = null;

   117         byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

   118                 proxyName, new Class<?>[] { providerType });

   119         try {

   120             proxyClass = JVM.defineClass(

   121                 providerType.getClassLoader(), proxyName,

   122                 proxyClassFile, 0, proxyClassFile.length);

   123         } catch (ClassFormatError e) {

   124             /*

   125              * A ClassFormatError here means that (barring bugs in the

   126              * proxy class generation code) there was some other

   127              * invalid aspect of the arguments supplied to the proxy

   128              * class creation (such as virtual machine limitations

   129              * exceeded).

   130              */

   131             throw new IllegalArgumentException(e.toString());

   132         }

   133 

   134         /*

   135          * Invoke its constructor with the designated invocation handler.

   136          */

   137         try {

   138             Constructor<?> cons = proxyClass.getConstructor(constructorParams);

   139             return (T)cons.newInstance(new Object[] { this });

   140         } catch (ReflectiveOperationException e) {

   141             throw new InternalError(e.toString(), e);

   142         }

   143     }

   144 

   145     // In the normal case, the proxy object's method implementations will call

   146     // this method (it usually calls the ProviderSkeleton's version).  That

   147     // method uses the passed 'method' object to lookup the associated

   148     // 'ProbeSkeleton' and calls uncheckedTrigger() on that probe to cause the

   149     // probe to fire.  DTrace probes are different in that the proxy class's

   150     // methods are immediately overridden with native code to fire the probe

   151     // directly.  So this method should never get invoked.  We also wire up the

   152     // DTraceProbe.uncheckedTrigger() method to call the proxy method instead

   153     // of doing the work itself.

   154     protected void triggerProbe(Method method, Object[] args) {

   155         assert false : "This method should have been overridden by the JVM";

   156     }

   157 

   158     public String getProviderName() {

   159         return super.getProviderName();

   160     }

   161 

   162     String getModuleName() {

   163         return getAnnotationString(

   164             providerType, ModuleName.class, DEFAULT_MODULE);

   165     }

   166 

   167     static String getProbeName(Method method) {

   168         return getAnnotationString(

   169             method, ProbeName.class, method.getName());

   170     }

   171 

   172     static String getFunctionName(Method method) {

   173         return getAnnotationString(

   174             method, FunctionName.class, DEFAULT_FUNCTION);

   175     }

   176 

   177     DTraceProbe[] getProbes() {

   178         return probes.values().toArray(new DTraceProbe[0]);

   179     }

   180 

   181     StabilityLevel getNameStabilityFor(Class<? extends Annotation> type) {

   182         Attributes attrs = (Attributes)getAnnotationValue(

   183             providerType, type, "value", null);

   184         if (attrs == null) {

   185             return StabilityLevel.PRIVATE;

   186         } else {

   187             return attrs.name();

   188         }

   189     }

   190 

   191     StabilityLevel getDataStabilityFor(Class<? extends Annotation> type) {

   192         Attributes attrs = (Attributes)getAnnotationValue(

   193             providerType, type, "value", null);

   194         if (attrs == null) {

   195             return StabilityLevel.PRIVATE;

   196         } else {

   197             return attrs.data();

   198         }

   199     }

   200 

   201     DependencyClass getDependencyClassFor(Class<? extends Annotation> type) {

   202         Attributes attrs = (Attributes)getAnnotationValue(

   203             providerType, type, "value", null);

   204         if (attrs == null) {

   205             return DependencyClass.UNKNOWN;

   206         } else {

   207             return attrs.dependency();

   208         }

   209     }

   210 }