1 /*
2 * Copyright (c) 1997, 2023, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmClasses.hpp"
30 #include "classfile/vmSymbols.hpp"
31 #include "logging/log.hpp"
32 #include "logging/logTag.hpp"
33 #include "memory/oopFactory.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "oops/instanceKlass.hpp"
36 #include "oops/klass.inline.hpp"
37 #include "oops/method.hpp"
38 #include "oops/oop.inline.hpp"
39 #include "oops/symbol.hpp"
40 #include "prims/jvmtiAgentList.hpp"
41 #include "prims/jvm_misc.hpp"
42 #include "prims/jvmtiExport.hpp"
43 #include "prims/nativeLookup.hpp"
44 #include "prims/unsafe.hpp"
45 #include "prims/scopedMemoryAccess.hpp"
46 #include "runtime/arguments.hpp"
47 #include "runtime/handles.inline.hpp"
48 #include "runtime/interfaceSupport.inline.hpp"
49 #include "runtime/javaCalls.hpp"
50 #include "runtime/os.hpp"
51 #include "runtime/sharedRuntime.hpp"
52 #include "runtime/signature.hpp"
53 #include "utilities/macros.hpp"
54 #include "utilities/utf8.hpp"
55 #if INCLUDE_JFR
56 #include "jfr/jfr.hpp"
57 #endif
58
59 /*
60
61 The JNI specification defines the mapping from a Java native method name to
62 a C native library implementation function name as follows:
63
64 The mapping produces a native method name by concatenating the following components
65 derived from a `native` method declaration:
66
67 1. the prefix Java_
68 2. given the binary name, in internal form, of the class which declares the native method:
69 the result of escaping the name.
70 3. an underscore ("_")
71 4. the escaped method name
72 5. if the native method declaration is overloaded: two underscores ("__") followed by the
73 escaped parameter descriptor (JVMS 4.3.3) of the method declaration.
74
75 Escaping leaves every alphanumeric ASCII character (A-Za-z0-9) unchanged, and replaces each
76 UTF-16 code unit n the table below with the corresponding escape sequence. If the name to be
77 escaped contains a surrogate pair, then the high-surrogate code unit and the low-surrogate code
78 unit are escaped separately. The result of escaping is a string consisting only of the ASCII
79 characters A-Za-z0-9 and underscore.
80
81 ------------------------------ ------------------------------------
82 UTF-16 code unit Escape sequence
83 ------------------------------ ------------------------------------
84 Forward slash (/, U+002F) _
85 Underscore (_, U+005F) _1
86 Semicolon (;, U+003B) _2
87 Left square bracket ([, U+005B) _3
88 Any UTF-16 code unit \u_WXYZ_ that does not _0wxyz where w, x, y, and z are the lower-case
89 represent alphanumeric ASCII (A-Za-z0-9), forms of the hexadecimal digits W, X, Y, and Z.
90 forward slash, underscore, semicolon, (For example, U+ABCD becomes _0abcd.)
91 or left square bracket
92 ------------------------------ ------------------------------------
93
94 Note that escape sequences can safely begin _0, _1, etc, because class and method
95 names in Java source code never begin with a number. However, that is not the case in
96 class files that were not generated from Java source code.
97
98 To preserve the 1:1 mapping to a native method name, the VM checks the resulting name as
99 follows. If the process of escaping any precursor string from the native method declaration
100 (class or method name, or argument type) causes a "0", "1", "2", or "3" character
101 from the precursor string to appear unchanged in the result *either* immediately after an
102 underscore *or* at the beginning of the escaped string (where it will follow an underscore
103 in the fully assembled name), then the escaping process is said to have "failed".
104 In such cases, no native library search is performed, and the attempt to link the native
105 method invocation will throw UnsatisfiedLinkError.
106
107
108 For example:
109
110 package/my_class/method
111
112 and
113
114 package/my/1class/method
115
116 both map to
117
118 Java_package_my_1class_method
119
120 To address this potential conflict we need only check if the character after
121 / is a digit 0..3, or if the first character after an injected '_' separator
122 is a digit 0..3. If we encounter an invalid identifier we reset the
123 stringStream and return false. Otherwise the stringStream contains the mapped
124 name and we return true.
125
126 */
127 static bool map_escaped_name_on(stringStream* st, Symbol* name, int begin, int end) {
128 char* bytes = (char*)name->bytes() + begin;
129 char* end_bytes = (char*)name->bytes() + end;
130 bool check_escape_char = true; // initially true as first character here follows '_'
131 while (bytes < end_bytes) {
132 jchar c;
133 bytes = UTF8::next(bytes, &c);
134 if (c <= 0x7f && isalnum(c)) {
135 if (check_escape_char && (c >= '0' && c <= '3')) {
136 // This is a non-Java identifier and we won't escape it to
137 // ensure no name collisions with a Java identifier.
138 if (log_is_enabled(Debug, jni, resolve)) {
139 ResourceMark rm;
140 log_debug(jni, resolve)("[Lookup of native method with non-Java identifier rejected: %s]",
141 name->as_C_string());
142 }
143 st->reset(); // restore to "" on error
144 return false;
145 }
146 st->put((char) c);
147 check_escape_char = false;
148 } else {
149 check_escape_char = false;
150 if (c == '_') st->print("_1");
151 else if (c == '/') {
152 st->print("_");
153 // Following a / we must have non-escape character
154 check_escape_char = true;
155 }
156 else if (c == ';') st->print("_2");
157 else if (c == '[') st->print("_3");
158 else st->print("_%.5x", c);
159 }
160 }
161 return true;
162 }
163
164
165 static bool map_escaped_name_on(stringStream* st, Symbol* name) {
166 return map_escaped_name_on(st, name, 0, name->utf8_length());
167 }
168
169
170 char* NativeLookup::pure_jni_name(const methodHandle& method) {
171 stringStream st;
172 // Prefix
173 st.print("Java_");
174 // Klass name
175 if (!map_escaped_name_on(&st, method->klass_name())) {
176 return nullptr;
177 }
178 st.print("_");
179 // Method name
180 if (!map_escaped_name_on(&st, method->name())) {
181 return nullptr;
182 }
183 return st.as_string();
184 }
185
186 char* NativeLookup::long_jni_name(const methodHandle& method) {
187 // Signatures ignore the wrapping parentheses and the trailing return type
188 stringStream st;
189 Symbol* signature = method->signature();
190 st.print("__");
191 // find ')'
192 int end;
193 for (end = 0; end < signature->utf8_length() && signature->char_at(end) != JVM_SIGNATURE_ENDFUNC; end++);
194 // skip first '('
195 if (!map_escaped_name_on(&st, signature, 1, end)) {
196 return nullptr;
197 }
198
199 return st.as_string();
200 }
201
202 extern "C" {
203 void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls);
204 void JNICALL JVM_RegisterReferencesMethods(JNIEnv *env, jclass unsafecls);
205 void JNICALL JVM_RegisterUpcallHandlerMethods(JNIEnv *env, jclass unsafecls);
206 void JNICALL JVM_RegisterUpcallLinkerMethods(JNIEnv *env, jclass unsafecls);
207 void JNICALL JVM_RegisterNativeEntryPointMethods(JNIEnv *env, jclass unsafecls);
208 void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass);
209 void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass);
210 void JNICALL JVM_RegisterVectorSupportMethods(JNIEnv *env, jclass vsclass);
211 #if INCLUDE_JVMCI
212 jobject JNICALL JVM_GetJVMCIRuntime(JNIEnv *env, jclass c);
213 jlong JNICALL JVM_ReadSystemPropertiesInfo(JNIEnv *env, jclass c, jintArray offsets);
214 void JNICALL JVM_RegisterJVMCINatives(JNIEnv *env, jclass compilerToVMClass);
215 #endif
216 }
217
218 #define CC (char*) /* cast a literal from (const char*) */
219 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
220
221 static JNINativeMethod lookup_special_native_methods[] = {
222 { CC"Java_jdk_internal_misc_Unsafe_registerNatives", nullptr, FN_PTR(JVM_RegisterJDKInternalMiscUnsafeMethods) },
223 { CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", nullptr, FN_PTR(JVM_RegisterMethodHandleMethods) },
224 { CC"Java_jdk_internal_foreign_abi_UpcallStubs_registerNatives", nullptr, FN_PTR(JVM_RegisterUpcallHandlerMethods) },
225 { CC"Java_jdk_internal_foreign_abi_UpcallLinker_registerNatives", nullptr, FN_PTR(JVM_RegisterUpcallLinkerMethods) },
226 { CC"Java_jdk_internal_foreign_abi_NativeEntryPoint_registerNatives", nullptr, FN_PTR(JVM_RegisterNativeEntryPointMethods) },
227 { CC"Java_jdk_internal_perf_Perf_registerNatives", nullptr, FN_PTR(JVM_RegisterPerfMethods) },
228 { CC"Java_sun_hotspot_WhiteBox_registerNatives", nullptr, FN_PTR(JVM_RegisterWhiteBoxMethods) },
229 { CC"Java_jdk_test_whitebox_WhiteBox_registerNatives", nullptr, FN_PTR(JVM_RegisterWhiteBoxMethods) },
230 { CC"Java_jdk_internal_vm_vector_VectorSupport_registerNatives", nullptr, FN_PTR(JVM_RegisterVectorSupportMethods)},
231 #if INCLUDE_JVMCI
232 { CC"Java_jdk_vm_ci_runtime_JVMCI_initializeRuntime", nullptr, FN_PTR(JVM_GetJVMCIRuntime) },
233 { CC"Java_jdk_vm_ci_services_Services_readSystemPropertiesInfo", nullptr, FN_PTR(JVM_ReadSystemPropertiesInfo) },
234 { CC"Java_jdk_vm_ci_hotspot_CompilerToVM_registerNatives", nullptr, FN_PTR(JVM_RegisterJVMCINatives) },
235 #endif
236 #if INCLUDE_JFR
237 { CC"Java_jdk_jfr_internal_JVM_registerNatives", nullptr, FN_PTR(jfr_register_natives) },
238 #endif
239 { CC"Java_jdk_internal_misc_ScopedMemoryAccess_registerNatives", nullptr, FN_PTR(JVM_RegisterJDKInternalMiscScopedMemoryAccessMethods) },
240 };
241
242 static address lookup_special_native(const char* jni_name) {
243 int count = sizeof(lookup_special_native_methods) / sizeof(JNINativeMethod);
244 for (int i = 0; i < count; i++) {
245 // NB: To ignore the jni prefix and jni postfix strstr is used matching.
246 if (strstr(jni_name, lookup_special_native_methods[i].name) != nullptr) {
247 return CAST_FROM_FN_PTR(address, lookup_special_native_methods[i].fnPtr);
248 }
249 }
250 return nullptr;
251 }
252
253 address NativeLookup::lookup_style(const methodHandle& method, char* pure_name, const char* long_name, int args_size, bool os_style, TRAPS) {
254 address entry;
255 const char* jni_name = compute_complete_jni_name(pure_name, long_name, args_size, os_style);
256
257
258 // If the loader is null we have a system class, so we attempt a lookup in
259 // the native Java library. This takes care of any bootstrapping problems.
260 // Note: It is critical for bootstrapping that Java_java_lang_ClassLoader_findNative
261 // gets found the first time around - otherwise an infinite loop can occur. This is
262 // another VM/library dependency
263 Handle loader(THREAD, method->method_holder()->class_loader());
264 if (loader.is_null()) {
265 entry = lookup_special_native(jni_name);
266 if (entry == nullptr) {
267 entry = (address) os::dll_lookup(os::native_java_library(), jni_name);
268 }
269 if (entry != nullptr) {
270 return entry;
271 }
272 }
273
274 // Otherwise call static method findNative in ClassLoader
275 Klass* klass = vmClasses::ClassLoader_klass();
276 Handle name_arg = java_lang_String::create_from_str(jni_name, CHECK_NULL);
277
278 JavaValue result(T_LONG);
279 JavaCalls::call_static(&result,
280 klass,
281 vmSymbols::findNative_name(),
282 vmSymbols::classloader_string_long_signature(),
283 // Arguments
284 loader,
285 name_arg,
286 CHECK_NULL);
287 entry = (address) (intptr_t) result.get_jlong();
288
289 if (entry == nullptr) {
290 // findNative didn't find it, if there are any agent libraries look in them
291 JvmtiAgentList::Iterator it = JvmtiAgentList::agents();
292 while (it.has_next()) {
293 entry = (address)os::dll_lookup(it.next()->os_lib(), jni_name);
294 if (entry != nullptr) {
295 return entry;
296 }
297 }
298 }
299
300 return entry;
301 }
302
303 const char* NativeLookup::compute_complete_jni_name(const char* pure_name, const char* long_name, int args_size, bool os_style) {
304 stringStream st;
305 if (os_style) {
306 os::print_jni_name_prefix_on(&st, args_size);
307 }
308
309 st.print_raw(pure_name);
310 st.print_raw(long_name);
311 if (os_style) {
312 os::print_jni_name_suffix_on(&st, args_size);
313 }
314
315 return st.as_string();
316 }
317
318 // Check all the formats of native implementation name to see if there is one
319 // for the specified method.
320 address NativeLookup::lookup_entry(const methodHandle& method, TRAPS) {
321 address entry = nullptr;
322 // Compute pure name
323 char* pure_name = pure_jni_name(method);
324 if (pure_name == nullptr) {
325 // JNI name mapping rejected this method so return
326 // null to indicate UnsatisfiedLinkError should be thrown.
327 return nullptr;
328 }
329
330 // Compute argument size
331 int args_size = 1 // JNIEnv
332 + (method->is_static() ? 1 : 0) // class for static methods
333 + method->size_of_parameters(); // actual parameters
334
335 // 1) Try JNI short style
336 entry = lookup_style(method, pure_name, "", args_size, true, CHECK_NULL);
337 if (entry != nullptr) return entry;
338
339 // Compute long name
340 char* long_name = long_jni_name(method);
341 if (long_name == nullptr) {
342 // JNI name mapping rejected this method so return
343 // null to indicate UnsatisfiedLinkError should be thrown.
344 return nullptr;
345 }
346
347 // 2) Try JNI long style
348 entry = lookup_style(method, pure_name, long_name, args_size, true, CHECK_NULL);
349 if (entry != nullptr) return entry;
350
351 // 3) Try JNI short style without os prefix/suffix
352 entry = lookup_style(method, pure_name, "", args_size, false, CHECK_NULL);
353 if (entry != nullptr) return entry;
354
355 // 4) Try JNI long style without os prefix/suffix
356 entry = lookup_style(method, pure_name, long_name, args_size, false, CHECK_NULL);
357
358 return entry; // null indicates not found
359 }
360
361 // Check if there are any JVM TI prefixes which have been applied to the native method name.
362 // If any are found, remove them before attempting the look up of the
363 // native implementation again.
364 // See SetNativeMethodPrefix in the JVM TI Spec for more details.
365 address NativeLookup::lookup_entry_prefixed(const methodHandle& method, TRAPS) {
366 #if INCLUDE_JVMTI
367 ResourceMark rm(THREAD);
368
369 int prefix_count;
370 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
371 char* in_name = method->name()->as_C_string();
372 char* wrapper_name = in_name;
373 // last applied prefix will be first -- go backwards
374 for (int i = prefix_count-1; i >= 0; i--) {
375 char* prefix = prefixes[i];
376 size_t prefix_len = strlen(prefix);
377 if (strncmp(prefix, wrapper_name, prefix_len) == 0) {
378 // has this prefix remove it
379 wrapper_name += prefix_len;
380 }
381 }
382 if (wrapper_name != in_name) {
383 // we have a name for a wrapping method
384 int wrapper_name_len = (int)strlen(wrapper_name);
385 TempNewSymbol wrapper_symbol = SymbolTable::probe(wrapper_name, wrapper_name_len);
386 if (wrapper_symbol != nullptr) {
387 Klass* k = method->method_holder();
388 Method* wrapper_method = k->lookup_method(wrapper_symbol, method->signature());
389 if (wrapper_method != nullptr && !wrapper_method->is_native()) {
390 // we found a wrapper method, use its native entry
391 method->set_is_prefixed_native();
392 return lookup_entry(methodHandle(THREAD, wrapper_method), THREAD);
393 }
394 }
395 }
396 #endif // INCLUDE_JVMTI
397 return nullptr;
398 }
399
400 address NativeLookup::lookup_base(const methodHandle& method, TRAPS) {
401 address entry = nullptr;
402 ResourceMark rm(THREAD);
403
404 entry = lookup_entry(method, CHECK_NULL);
405 if (entry != nullptr) return entry;
406
407 // standard native method resolution has failed. Check if there are any
408 // JVM TI prefixes which have been applied to the native method name.
409 entry = lookup_entry_prefixed(method, CHECK_NULL);
410 if (entry != nullptr) return entry;
411
412 // Native function not found, throw UnsatisfiedLinkError
413 stringStream ss;
414 ss.print("'");
415 method->print_external_name(&ss);
416 ss.print("'");
417 THROW_MSG_0(vmSymbols::java_lang_UnsatisfiedLinkError(), ss.as_string());
418 }
419
420
421 address NativeLookup::lookup(const methodHandle& method, TRAPS) {
422 if (!method->has_native_function()) {
423 address entry = lookup_base(method, CHECK_NULL);
424 method->set_native_function(entry,
425 Method::native_bind_event_is_interesting);
426 // -verbose:jni printing
427 if (log_is_enabled(Debug, jni, resolve)) {
428 ResourceMark rm(THREAD);
429 log_debug(jni, resolve)("[Dynamic-linking native method %s.%s ... JNI]",
430 method->method_holder()->external_name(),
431 method->name()->as_C_string());
432 }
433 }
434 return method->native_function();
435 }