| /* |
| * Copyright (c) 2007, 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. |
| * |
| * 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 nsk.jvmti.SetNativeMethodPrefix; |
| |
| import java.io.*; |
| import nsk.share.Consts; |
| |
| /* ============================================================================== */ |
| /* Quote from JVMTI specification v.1.1.102: |
| * |
| * Since native methods cannot be directly instrumented (they have no |
| * bytecodes), they must be wrapped with a non-native method which can be |
| * instrumented. For example, if we had: |
| * native boolean foo(int x); |
| * |
| * We could transform the class file (with the ClassFileLoadHook event) so |
| * that this becomes: |
| * boolean foo(int x) { |
| * ... record entry to foo ... |
| * return wrapped_foo(x); |
| * } |
| * |
| * native boolean wrapped_foo(int x); |
| * |
| * Where foo becomes a wrapper for the actual native method with the appended |
| * prefix "wrapped_". |
| * |
| * The wrapper will allow data to be collected on the native method call, but |
| * now the problem becomes linking up the wrapped method with the native |
| * implementation. That is, the method wrapped_foo needs to be resolved to the |
| * native implementation of foo, which might be: |
| * |
| * Java_somePackage_someClass_foo(JNIEnv* env, jint x) |
| * |
| * This function allows the prefix to be specified and the proper resolution |
| * to occur. Specifically, when the standard resolution fails, the resolution |
| * is retried taking the prefix into consideration. There are two ways that |
| * resolution occurs, explicit resolution with the JNI function |
| * RegisterNatives and the normal automatic resolution. For RegisterNatives, |
| * the VM will attempt this association: |
| * |
| * method(foo) -> nativeImplementation(foo) |
| * |
| * When this fails, the resolution will be retried with the specified prefix |
| * prepended to the method name, yielding the correct resolution: |
| * |
| * method(wrapped_foo) -> nativeImplementation(foo) |
| * |
| * For automatic resolution, the VM will attempt: |
| * |
| * method(wrapped_foo) -> nativeImplementation(wrapped_foo) |
| * |
| * When this fails, the resolution will be retried with the specified prefix |
| * deleted from the implementation name, yielding the correct resolution: |
| * |
| * method(wrapped_foo) -> nativeImplementation(foo) |
| * |
| * Note that since the prefix is only used when standard resolution fails, |
| * native methods can be wrapped selectively. |
| */ |
| /* ============================================================================== */ |
| |
| |
| /* ======================================================= */ |
| // Auxiliary classes for explicit method resolution |
| /* ======================================================= */ |
| class ExplicitResolution1 { |
| static public int foo() { return wrapped_foo(); } |
| native static public int wrapped_foo(); |
| } |
| |
| /* ======================================================= */ |
| class ExplicitResolution2 { |
| native static public int wrapped_foo(); |
| } |
| |
| /* ======================================================= */ |
| // Auxiliary classes for automatic resolution |
| /* ======================================================= */ |
| class AutomaticResolution1 { |
| static public int foo() { return wrapped_foo(); } |
| native static public int wrapped_foo(); |
| } |
| |
| /* ======================================================= */ |
| class AutomaticResolution2 { |
| static public int foo() { return wrapped_foo(); } |
| native static public int wrapped_foo(); |
| } |
| |
| /* ======================================================= */ |
| class AutomaticResolution3 { |
| static public int foo() { return wrapped_foo(); } |
| native static public int wrapped_foo(); |
| } |
| |
| /* ======================================================= */ |
| public class SetNativeMethodPrefix001 { |
| PrintStream out = System.out; |
| |
| static public final String prefix = "wrapped_"; |
| |
| /* ============================================================ */ |
| // |
| // For RegisterNatives, the VM will attempt this association: |
| // |
| // method(foo) -> nativeImplementation(foo) |
| // |
| // When this fails, the resolution will be retried with the specified |
| // prefix prepended to the method name, yielding the correct resolution: |
| // |
| // method(wrapped_foo) -> nativeImplementation(foo) |
| // |
| // The prefix is only used when standard resolution fails. |
| // |
| /* ============================================================ */ |
| public boolean checkExplicitResolution1(boolean isPrefixSet) { |
| |
| // Initiate class A loading and initialization |
| // See CR 6493522 for details |
| new ExplicitResolution1(); |
| |
| // Bind ExplicitResolution1.foo() to a native function. |
| // If the prefix isn't set, this code should fail since ExplicitResolution1.foo() isn't native. |
| if (Binder.registerMethod(ExplicitResolution1.class, "foo", "()I", Binder.FUNCTION_FOO) != isPrefixSet) |
| { |
| out.println("ERROR: unexpected RegisterNatives() behavior."); |
| return false; |
| } |
| |
| if (isPrefixSet) { |
| if (ExplicitResolution1.foo() != Binder.FOO_RETURN) { |
| out.println("ERROR: native method wrapped_foo() wasn't correctly bound."); |
| return false; |
| } |
| } |
| |
| // Bind ExplicitResolution1.wrapped_foo() to a native fucntion. |
| // This code should succeed since ExplicitResolution1.wrapped_foo() is native. |
| if (!Binder.registerMethod(ExplicitResolution1.class, "wrapped_foo", "()I", Binder.FUNCTION_WRAPPED_FOO)) |
| { |
| out.println("ERROR: RegisterNative() failed for native method ExplicitResolution1.wrapped_foo()."); |
| return false; |
| } |
| |
| if (ExplicitResolution1.foo() != Binder.WRAPPED_FOO_RETURN) { |
| out.println("ERROR: native method wrapped_foo() wasn't correctly bound."); |
| return false; |
| } |
| return true; |
| } |
| |
| /* ============================================================ */ |
| public boolean checkExplicitResolution2() { |
| // Initiate class ExplicitResolution2 loading and initialization |
| // See CR 6493522 for details |
| new ExplicitResolution2(); |
| |
| // This binding should fail whether the prefix is set or not since: |
| // - there's no Java_nsk_jvmti_SetNativeMethodPrefix_ExplicitResolution2_wrapped_1foo defined |
| // - class ExplicitResolution2 doesn't have java method foo() |
| if (Binder.registerMethod(ExplicitResolution2.class, "foo", "()I", Binder.FUNCTION_WRAPPED_FOO)) { |
| out.println("ERROR: unexpected RegisterNatives() behavior."); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* ============================================================ */ |
| public boolean checkExplicitResolution (boolean isMultiplePrefixes) { |
| // Setting method prefix |
| out.println("\tSetting prefix: "+prefix); |
| if (isMultiplePrefixes) { |
| if (!Binder.setMultiplePrefixes(prefix)) { return false; } |
| } else { |
| if (!Binder.setMethodPrefix(prefix)) { return false; } |
| } |
| |
| // Check the behavior |
| out.println("\t\tChecking resolution for ExplicitResolution1"); |
| if (!checkExplicitResolution1(true)) { return false; } |
| out.println("\t\tChecking resolution for ExplicitResolution2"); |
| if (!checkExplicitResolution2()) { return false; } |
| |
| // Resetting method prefix |
| out.println("\tResetting prefix"); |
| if (isMultiplePrefixes) { |
| if (!Binder.setMultiplePrefixes(null)) { return false; } |
| } else { |
| if (!Binder.setMethodPrefix(null)) { return false; } |
| } |
| |
| // Check the behavior |
| out.println("\t\tChecking resolution for ExplicitResolution1"); |
| if (!checkExplicitResolution1(false)) { return false; } |
| out.println("\t\tChecking resolution for ExplicitResolution2"); |
| if (!checkExplicitResolution2()) { return false; } |
| |
| return true; |
| } |
| |
| /* ============================================================ */ |
| // For automatic resolution, the VM will attempt: |
| // |
| // method(wrapped_foo) -> nativeImplementation(wrapped_foo) |
| // |
| // When this fails, the resolution will be retried with the specified |
| // prefix deleted from the implementation name, yielding the correct |
| // resolution: |
| // |
| // method(wrapped_foo) -> nativeImplementation(foo) |
| // |
| // The prefix is only used when standard resolution fails. |
| /* ============================================================ */ |
| public boolean checkAutomaticResolution1() { |
| if (AutomaticResolution1.foo() != Binder.WRAPPED_FOO_RETURN) { |
| out.println("ERROR: native method AutomaticResolution1.wrapped_foo() wasn't correctly bound."); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* ============================================================ */ |
| public boolean checkAutomaticResolution2 (boolean isPrefixSet) { |
| if (isPrefixSet) { |
| if (AutomaticResolution2.foo() != Binder.FOO_RETURN) { |
| out.println("ERROR: native method AutomaticResolution2.wrapped_foo() wasn't correctly bound."); |
| return false; |
| } |
| } else { |
| try { |
| AutomaticResolution3.foo(); |
| out.println("ERROR: native method AutomaticResolution3.wrapped_foo() was bound."); |
| return false; |
| } catch (UnsatisfiedLinkError e) { |
| out.println(String.format("The method isn't bound: %s %s\n", e.getClass().getName(), e.getMessage())); |
| return true; |
| } |
| } |
| |
| return true; |
| } |
| |
| /* ============================================================ */ |
| public boolean checkAutomaticResolution (boolean isMultiplePrefixes) { |
| // Setting method prefix |
| out.println("\tSetting prefix: "+prefix); |
| if (isMultiplePrefixes) { |
| if (!Binder.setMultiplePrefixes(prefix)) { return false; } |
| } else { |
| if (!Binder.setMethodPrefix(prefix)) { return false; } |
| } |
| |
| // Check the behavior |
| out.println("\t\tChecking resolution for AutomaticResolution1"); |
| if (!checkAutomaticResolution1()) { return false; } |
| out.println("\t\tChecking resolution for AutomaticResolution2"); |
| if (!checkAutomaticResolution2(true)) { return false; } |
| |
| // Resetting method prefix |
| out.println("\tResetting prefix"); |
| if (isMultiplePrefixes) { |
| if (!Binder.setMultiplePrefixes(null)) { return false; } |
| } else { |
| if (!Binder.setMethodPrefix(null)) { return false; } |
| } |
| |
| // Check the behavior |
| out.println("\t\tChecking resolution for AutomaticResolution1"); |
| if (!checkAutomaticResolution1()) { return false; } |
| out.println("\t\tChecking resolution for AutomaticResolution2"); |
| if (!checkAutomaticResolution2(false)) { return false; } |
| |
| return true; |
| } |
| |
| /* ============================================================ */ |
| public boolean runIt(String [] args, PrintStream _out) { |
| if (_out != null) { |
| out = _out; |
| } |
| |
| out.println("\nAutomatic resolution; SetMethodPrefix is used"); |
| if (!checkAutomaticResolution(true)) { return false; } |
| |
| out.println("\nAutomatic resolution; SetMultiplePrefixes is used"); |
| if (!checkAutomaticResolution(false)) { return false; } |
| |
| out.println("\nExplicit resolution; SetMethodPrefix is used"); |
| if (!checkExplicitResolution(true)) { return false; } |
| |
| out.println("\nExplicit resolution; SetMultiplePrefixes is used"); |
| if (!checkExplicitResolution(false)) { return false; } |
| |
| |
| return true; |
| } |
| |
| /* ============================================================ */ |
| public static int run(String argv[], PrintStream out) { |
| if ((new SetNativeMethodPrefix001()).runIt(argv, out)) { |
| out.println("TEST PASSED"); |
| return Consts.TEST_PASSED; |
| } else { |
| out.println("TEST FAILED"); |
| return Consts.TEST_FAILED; |
| } |
| } |
| |
| /* ============================================================ */ |
| public static void main(String[] argv) { |
| argv = nsk.share.jvmti.JVMTITest.commonInit(argv); |
| |
| System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE); |
| } |
| } |
