jvm.h revision 3602:da91efe96a93
1/* 2 * Copyright (c) 1997, 2012, 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#ifndef SHARE_VM_PRIMS_JVM_H 26#define SHARE_VM_PRIMS_JVM_H 27 28#include "prims/jni.h" 29#ifdef TARGET_OS_FAMILY_linux 30# include "jvm_linux.h" 31#endif 32#ifdef TARGET_OS_FAMILY_solaris 33# include "jvm_solaris.h" 34#endif 35#ifdef TARGET_OS_FAMILY_windows 36# include "jvm_windows.h" 37#endif 38#ifdef TARGET_OS_FAMILY_bsd 39# include "jvm_bsd.h" 40#endif 41 42#ifndef _JAVASOFT_JVM_H_ 43#define _JAVASOFT_JVM_H_ 44 45// HotSpot integration note: 46// 47// This file and jvm.h used with the JDK are identical, 48// except for the three includes removed below 49 50// #include <sys/stat.h> 51// #include "jni.h" 52// #include "jvm_md.h" 53 54 55#ifdef __cplusplus 56extern "C" { 57#endif 58 59/* 60 * This file contains additional functions exported from the VM. 61 * These functions are complementary to the standard JNI support. 62 * There are three parts to this file: 63 * 64 * First, this file contains the VM-related functions needed by native 65 * libraries in the standard Java API. For example, the java.lang.Object 66 * class needs VM-level functions that wait for and notify monitors. 67 * 68 * Second, this file contains the functions and constant definitions 69 * needed by the byte code verifier and class file format checker. 70 * These functions allow the verifier and format checker to be written 71 * in a VM-independent way. 72 * 73 * Third, this file contains various I/O and nerwork operations needed 74 * by the standard Java I/O and network APIs. 75 */ 76 77/* 78 * Bump the version number when either of the following happens: 79 * 80 * 1. There is a change in JVM_* functions. 81 * 82 * 2. There is a change in the contract between VM and Java classes. 83 * For example, if the VM relies on a new private field in Thread 84 * class. 85 */ 86 87#define JVM_INTERFACE_VERSION 4 88 89 90JNIEXPORT jint JNICALL 91JVM_GetInterfaceVersion(void); 92 93/************************************************************************* 94 PART 1: Functions for Native Libraries 95 ************************************************************************/ 96/* 97 * java.lang.Object 98 */ 99JNIEXPORT jint JNICALL 100JVM_IHashCode(JNIEnv *env, jobject obj); 101 102JNIEXPORT void JNICALL 103JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms); 104 105JNIEXPORT void JNICALL 106JVM_MonitorNotify(JNIEnv *env, jobject obj); 107 108JNIEXPORT void JNICALL 109JVM_MonitorNotifyAll(JNIEnv *env, jobject obj); 110 111JNIEXPORT jobject JNICALL 112JVM_Clone(JNIEnv *env, jobject obj); 113 114/* 115 * java.lang.String 116 */ 117JNIEXPORT jstring JNICALL 118JVM_InternString(JNIEnv *env, jstring str); 119 120/* 121 * java.lang.System 122 */ 123JNIEXPORT jlong JNICALL 124JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored); 125 126JNIEXPORT jlong JNICALL 127JVM_NanoTime(JNIEnv *env, jclass ignored); 128 129JNIEXPORT void JNICALL 130JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos, 131 jobject dst, jint dst_pos, jint length); 132 133JNIEXPORT jobject JNICALL 134JVM_InitProperties(JNIEnv *env, jobject p); 135 136/* 137 * java.io.File 138 */ 139JNIEXPORT void JNICALL 140JVM_OnExit(void (*func)(void)); 141 142/* 143 * java.lang.Runtime 144 */ 145JNIEXPORT void JNICALL 146JVM_Exit(jint code); 147 148JNIEXPORT void JNICALL 149JVM_Halt(jint code); 150 151JNIEXPORT void JNICALL 152JVM_GC(void); 153 154/* Returns the number of real-time milliseconds that have elapsed since the 155 * least-recently-inspected heap object was last inspected by the garbage 156 * collector. 157 * 158 * For simple stop-the-world collectors this value is just the time 159 * since the most recent collection. For generational collectors it is the 160 * time since the oldest generation was most recently collected. Other 161 * collectors are free to return a pessimistic estimate of the elapsed time, or 162 * simply the time since the last full collection was performed. 163 * 164 * Note that in the presence of reference objects, a given object that is no 165 * longer strongly reachable may have to be inspected multiple times before it 166 * can be reclaimed. 167 */ 168JNIEXPORT jlong JNICALL 169JVM_MaxObjectInspectionAge(void); 170 171JNIEXPORT void JNICALL 172JVM_TraceInstructions(jboolean on); 173 174JNIEXPORT void JNICALL 175JVM_TraceMethodCalls(jboolean on); 176 177JNIEXPORT jlong JNICALL 178JVM_TotalMemory(void); 179 180JNIEXPORT jlong JNICALL 181JVM_FreeMemory(void); 182 183JNIEXPORT jlong JNICALL 184JVM_MaxMemory(void); 185 186JNIEXPORT jint JNICALL 187JVM_ActiveProcessorCount(void); 188 189JNIEXPORT void * JNICALL 190JVM_LoadLibrary(const char *name); 191 192JNIEXPORT void JNICALL 193JVM_UnloadLibrary(void * handle); 194 195JNIEXPORT void * JNICALL 196JVM_FindLibraryEntry(void *handle, const char *name); 197 198JNIEXPORT jboolean JNICALL 199JVM_IsSupportedJNIVersion(jint version); 200 201/* 202 * java.lang.Float and java.lang.Double 203 */ 204JNIEXPORT jboolean JNICALL 205JVM_IsNaN(jdouble d); 206 207/* 208 * java.lang.Throwable 209 */ 210JNIEXPORT void JNICALL 211JVM_FillInStackTrace(JNIEnv *env, jobject throwable); 212 213JNIEXPORT void JNICALL 214JVM_PrintStackTrace(JNIEnv *env, jobject throwable, jobject printable); 215 216JNIEXPORT jint JNICALL 217JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable); 218 219JNIEXPORT jobject JNICALL 220JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index); 221 222/* 223 * java.lang.Compiler 224 */ 225JNIEXPORT void JNICALL 226JVM_InitializeCompiler (JNIEnv *env, jclass compCls); 227 228JNIEXPORT jboolean JNICALL 229JVM_IsSilentCompiler(JNIEnv *env, jclass compCls); 230 231JNIEXPORT jboolean JNICALL 232JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls); 233 234JNIEXPORT jboolean JNICALL 235JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname); 236 237JNIEXPORT jobject JNICALL 238JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg); 239 240JNIEXPORT void JNICALL 241JVM_EnableCompiler(JNIEnv *env, jclass compCls); 242 243JNIEXPORT void JNICALL 244JVM_DisableCompiler(JNIEnv *env, jclass compCls); 245 246/* 247 * java.lang.Thread 248 */ 249JNIEXPORT void JNICALL 250JVM_StartThread(JNIEnv *env, jobject thread); 251 252JNIEXPORT void JNICALL 253JVM_StopThread(JNIEnv *env, jobject thread, jobject exception); 254 255JNIEXPORT jboolean JNICALL 256JVM_IsThreadAlive(JNIEnv *env, jobject thread); 257 258JNIEXPORT void JNICALL 259JVM_SuspendThread(JNIEnv *env, jobject thread); 260 261JNIEXPORT void JNICALL 262JVM_ResumeThread(JNIEnv *env, jobject thread); 263 264JNIEXPORT void JNICALL 265JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio); 266 267JNIEXPORT void JNICALL 268JVM_Yield(JNIEnv *env, jclass threadClass); 269 270JNIEXPORT void JNICALL 271JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis); 272 273JNIEXPORT jobject JNICALL 274JVM_CurrentThread(JNIEnv *env, jclass threadClass); 275 276JNIEXPORT jint JNICALL 277JVM_CountStackFrames(JNIEnv *env, jobject thread); 278 279JNIEXPORT void JNICALL 280JVM_Interrupt(JNIEnv *env, jobject thread); 281 282JNIEXPORT jboolean JNICALL 283JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted); 284 285JNIEXPORT jboolean JNICALL 286JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj); 287 288JNIEXPORT void JNICALL 289JVM_DumpAllStacks(JNIEnv *env, jclass unused); 290 291JNIEXPORT jobjectArray JNICALL 292JVM_GetAllThreads(JNIEnv *env, jclass dummy); 293 294JNIEXPORT void JNICALL 295JVM_SetNativeThreadName(JNIEnv *env, jobject jthread, jstring name); 296 297/* getStackTrace() and getAllStackTraces() method */ 298JNIEXPORT jobjectArray JNICALL 299JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads); 300 301/* 302 * java.lang.SecurityManager 303 */ 304JNIEXPORT jclass JNICALL 305JVM_CurrentLoadedClass(JNIEnv *env); 306 307JNIEXPORT jobject JNICALL 308JVM_CurrentClassLoader(JNIEnv *env); 309 310JNIEXPORT jobjectArray JNICALL 311JVM_GetClassContext(JNIEnv *env); 312 313JNIEXPORT jint JNICALL 314JVM_ClassDepth(JNIEnv *env, jstring name); 315 316JNIEXPORT jint JNICALL 317JVM_ClassLoaderDepth(JNIEnv *env); 318 319/* 320 * java.lang.Package 321 */ 322JNIEXPORT jstring JNICALL 323JVM_GetSystemPackage(JNIEnv *env, jstring name); 324 325JNIEXPORT jobjectArray JNICALL 326JVM_GetSystemPackages(JNIEnv *env); 327 328/* 329 * java.io.ObjectInputStream 330 */ 331JNIEXPORT jobject JNICALL 332JVM_AllocateNewObject(JNIEnv *env, jobject obj, jclass currClass, 333 jclass initClass); 334 335JNIEXPORT jobject JNICALL 336JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, 337 jint length); 338 339JNIEXPORT jobject JNICALL 340JVM_LatestUserDefinedLoader(JNIEnv *env); 341 342/* 343 * This function has been deprecated and should not be considered 344 * part of the specified JVM interface. 345 */ 346JNIEXPORT jclass JNICALL 347JVM_LoadClass0(JNIEnv *env, jobject obj, jclass currClass, 348 jstring currClassName); 349 350/* 351 * java.lang.reflect.Array 352 */ 353JNIEXPORT jint JNICALL 354JVM_GetArrayLength(JNIEnv *env, jobject arr); 355 356JNIEXPORT jobject JNICALL 357JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index); 358 359JNIEXPORT jvalue JNICALL 360JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode); 361 362JNIEXPORT void JNICALL 363JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val); 364 365JNIEXPORT void JNICALL 366JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, 367 unsigned char vCode); 368 369JNIEXPORT jobject JNICALL 370JVM_NewArray(JNIEnv *env, jclass eltClass, jint length); 371 372JNIEXPORT jobject JNICALL 373JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim); 374 375/* 376 * java.lang.Class and java.lang.ClassLoader 377 */ 378/* 379 * Returns the class in which the code invoking the native method 380 * belongs. 381 * 382 * Note that in JDK 1.1, native methods did not create a frame. 383 * In 1.2, they do. Therefore native methods like Class.forName 384 * can no longer look at the current frame for the caller class. 385 */ 386JNIEXPORT jclass JNICALL 387JVM_GetCallerClass(JNIEnv *env, int n); 388 389/* 390 * Find primitive classes 391 * utf: class name 392 */ 393JNIEXPORT jclass JNICALL 394JVM_FindPrimitiveClass(JNIEnv *env, const char *utf); 395 396/* 397 * Link the class 398 */ 399JNIEXPORT void JNICALL 400JVM_ResolveClass(JNIEnv *env, jclass cls); 401 402/* 403 * Find a class from a given class loader. Throw ClassNotFoundException 404 * or NoClassDefFoundError depending on the value of the last 405 * argument. 406 */ 407JNIEXPORT jclass JNICALL 408JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init, 409 jobject loader, jboolean throwError); 410 411/* 412 * Find a class from a boot class loader. Returns NULL if class not found. 413 */ 414JNIEXPORT jclass JNICALL 415JVM_FindClassFromBootLoader(JNIEnv *env, const char *name); 416 417/* 418 * Find a class from a given class. 419 */ 420JNIEXPORT jclass JNICALL 421JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init, 422 jclass from); 423 424/* Find a loaded class cached by the VM */ 425JNIEXPORT jclass JNICALL 426JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name); 427 428/* Define a class */ 429JNIEXPORT jclass JNICALL 430JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, 431 jsize len, jobject pd); 432 433/* Define a class with a source (added in JDK1.5) */ 434JNIEXPORT jclass JNICALL 435JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, 436 const jbyte *buf, jsize len, jobject pd, 437 const char *source); 438 439/* Define a class with a source with conditional verification (added HSX 14) 440 * -Xverify:all will verify anyway, -Xverify:none will not verify, 441 * -Xverify:remote (default) will obey this conditional 442 * i.e. true = should_verify_class 443 */ 444JNIEXPORT jclass JNICALL 445JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, 446 jobject loader, const jbyte *buf, 447 jsize len, jobject pd, const char *source, 448 jboolean verify); 449 450/* 451 * Reflection support functions 452 */ 453 454JNIEXPORT jstring JNICALL 455JVM_GetClassName(JNIEnv *env, jclass cls); 456 457JNIEXPORT jobjectArray JNICALL 458JVM_GetClassInterfaces(JNIEnv *env, jclass cls); 459 460JNIEXPORT jobject JNICALL 461JVM_GetClassLoader(JNIEnv *env, jclass cls); 462 463JNIEXPORT jboolean JNICALL 464JVM_IsInterface(JNIEnv *env, jclass cls); 465 466JNIEXPORT jobjectArray JNICALL 467JVM_GetClassSigners(JNIEnv *env, jclass cls); 468 469JNIEXPORT void JNICALL 470JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers); 471 472JNIEXPORT jobject JNICALL 473JVM_GetProtectionDomain(JNIEnv *env, jclass cls); 474 475JNIEXPORT void JNICALL 476JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain); 477 478JNIEXPORT jboolean JNICALL 479JVM_IsArrayClass(JNIEnv *env, jclass cls); 480 481JNIEXPORT jboolean JNICALL 482JVM_IsPrimitiveClass(JNIEnv *env, jclass cls); 483 484JNIEXPORT jclass JNICALL 485JVM_GetComponentType(JNIEnv *env, jclass cls); 486 487JNIEXPORT jint JNICALL 488JVM_GetClassModifiers(JNIEnv *env, jclass cls); 489 490JNIEXPORT jobjectArray JNICALL 491JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass); 492 493JNIEXPORT jclass JNICALL 494JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass); 495 496/* Generics support (JDK 1.5) */ 497JNIEXPORT jstring JNICALL 498JVM_GetClassSignature(JNIEnv *env, jclass cls); 499 500/* Annotations support (JDK 1.5) */ 501JNIEXPORT jbyteArray JNICALL 502JVM_GetClassAnnotations(JNIEnv *env, jclass cls); 503 504/* Annotations support (JDK 1.6) */ 505 506// field is a handle to a java.lang.reflect.Field object 507JNIEXPORT jbyteArray JNICALL 508JVM_GetFieldAnnotations(JNIEnv *env, jobject field); 509 510// method is a handle to a java.lang.reflect.Method object 511JNIEXPORT jbyteArray JNICALL 512JVM_GetMethodAnnotations(JNIEnv *env, jobject method); 513 514// method is a handle to a java.lang.reflect.Method object 515JNIEXPORT jbyteArray JNICALL 516JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method); 517 518// method is a handle to a java.lang.reflect.Method object 519JNIEXPORT jbyteArray JNICALL 520JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method); 521 522 523/* 524 * New (JDK 1.4) reflection implementation 525 */ 526 527JNIEXPORT jobjectArray JNICALL 528JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly); 529 530JNIEXPORT jobjectArray JNICALL 531JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly); 532 533JNIEXPORT jobjectArray JNICALL 534JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly); 535 536/* Differs from JVM_GetClassModifiers in treatment of inner classes. 537 This returns the access flags for the class as specified in the 538 class file rather than searching the InnerClasses attribute (if 539 present) to find the source-level access flags. Only the values of 540 the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be 541 valid. */ 542JNIEXPORT jint JNICALL 543JVM_GetClassAccessFlags(JNIEnv *env, jclass cls); 544 545/* 546 * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5) 547 */ 548 549JNIEXPORT jobject JNICALL 550JVM_GetClassConstantPool(JNIEnv *env, jclass cls); 551 552JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize 553(JNIEnv *env, jobject obj, jobject unused); 554 555JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt 556(JNIEnv *env, jobject obj, jobject unused, jint index); 557 558JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded 559(JNIEnv *env, jobject obj, jobject unused, jint index); 560 561JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt 562(JNIEnv *env, jobject obj, jobject unused, jint index); 563 564JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded 565(JNIEnv *env, jobject obj, jobject unused, jint index); 566 567JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt 568(JNIEnv *env, jobject obj, jobject unused, jint index); 569 570JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded 571(JNIEnv *env, jobject obj, jobject unused, jint index); 572 573JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt 574(JNIEnv *env, jobject obj, jobject unused, jint index); 575 576JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt 577(JNIEnv *env, jobject obj, jobject unused, jint index); 578 579JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt 580(JNIEnv *env, jobject obj, jobject unused, jint index); 581 582JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt 583(JNIEnv *env, jobject obj, jobject unused, jint index); 584 585JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt 586(JNIEnv *env, jobject obj, jobject unused, jint index); 587 588JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt 589(JNIEnv *env, jobject obj, jobject unused, jint index); 590 591JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At 592(JNIEnv *env, jobject obj, jobject unused, jint index); 593 594/* 595 * java.security.* 596 */ 597 598JNIEXPORT jobject JNICALL 599JVM_DoPrivileged(JNIEnv *env, jclass cls, 600 jobject action, jobject context, jboolean wrapException); 601 602JNIEXPORT jobject JNICALL 603JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls); 604 605JNIEXPORT jobject JNICALL 606JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls); 607 608/* 609 * Signal support, used to implement the shutdown sequence. Every VM must 610 * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts 611 * (^C) and the latter for external termination (kill, system shutdown, etc.). 612 * Other platform-dependent signal values may also be supported. 613 */ 614 615JNIEXPORT void * JNICALL 616JVM_RegisterSignal(jint sig, void *handler); 617 618JNIEXPORT jboolean JNICALL 619JVM_RaiseSignal(jint sig); 620 621JNIEXPORT jint JNICALL 622JVM_FindSignal(const char *name); 623 624/* 625 * Retrieve the assertion directives for the specified class. 626 */ 627JNIEXPORT jboolean JNICALL 628JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls); 629 630/* 631 * Retrieve the assertion directives from the VM. 632 */ 633JNIEXPORT jobject JNICALL 634JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused); 635 636/* 637 * java.util.concurrent.atomic.AtomicLong 638 */ 639JNIEXPORT jboolean JNICALL 640JVM_SupportsCX8(void); 641 642JNIEXPORT jboolean JNICALL 643JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fldID, jlong oldVal, jlong newVal); 644 645/* 646 * com.sun.dtrace.jsdt support 647 */ 648 649#define JVM_TRACING_DTRACE_VERSION 1 650 651/* 652 * Structure to pass one probe description to JVM. 653 * 654 * The VM will overwrite the definition of the referenced method with 655 * code that will fire the probe. 656 */ 657typedef struct { 658 jmethodID method; 659 jstring function; 660 jstring name; 661 void* reserved[4]; // for future use 662} JVM_DTraceProbe; 663 664/** 665 * Encapsulates the stability ratings for a DTrace provider field 666 */ 667typedef struct { 668 jint nameStability; 669 jint dataStability; 670 jint dependencyClass; 671} JVM_DTraceInterfaceAttributes; 672 673/* 674 * Structure to pass one provider description to JVM 675 */ 676typedef struct { 677 jstring name; 678 JVM_DTraceProbe* probes; 679 jint probe_count; 680 JVM_DTraceInterfaceAttributes providerAttributes; 681 JVM_DTraceInterfaceAttributes moduleAttributes; 682 JVM_DTraceInterfaceAttributes functionAttributes; 683 JVM_DTraceInterfaceAttributes nameAttributes; 684 JVM_DTraceInterfaceAttributes argsAttributes; 685 void* reserved[4]; // for future use 686} JVM_DTraceProvider; 687 688/* 689 * Get the version number the JVM was built with 690 */ 691JNIEXPORT jint JNICALL 692JVM_DTraceGetVersion(JNIEnv* env); 693 694/* 695 * Register new probe with given signature, return global handle 696 * 697 * The version passed in is the version that the library code was 698 * built with. 699 */ 700JNIEXPORT jlong JNICALL 701JVM_DTraceActivate(JNIEnv* env, jint version, jstring module_name, 702 jint providers_count, JVM_DTraceProvider* providers); 703 704/* 705 * Check JSDT probe 706 */ 707JNIEXPORT jboolean JNICALL 708JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method); 709 710/* 711 * Destroy custom DOF 712 */ 713JNIEXPORT void JNICALL 714JVM_DTraceDispose(JNIEnv* env, jlong handle); 715 716/* 717 * Check to see if DTrace is supported by OS 718 */ 719JNIEXPORT jboolean JNICALL 720JVM_DTraceIsSupported(JNIEnv* env); 721 722/************************************************************************* 723 PART 2: Support for the Verifier and Class File Format Checker 724 ************************************************************************/ 725/* 726 * Return the class name in UTF format. The result is valid 727 * until JVM_ReleaseUTf is called. 728 * 729 * The caller must treat the string as a constant and not modify it 730 * in any way. 731 */ 732JNIEXPORT const char * JNICALL 733JVM_GetClassNameUTF(JNIEnv *env, jclass cb); 734 735/* 736 * Returns the constant pool types in the buffer provided by "types." 737 */ 738JNIEXPORT void JNICALL 739JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types); 740 741/* 742 * Returns the number of Constant Pool entries. 743 */ 744JNIEXPORT jint JNICALL 745JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb); 746 747/* 748 * Returns the number of *declared* fields or methods. 749 */ 750JNIEXPORT jint JNICALL 751JVM_GetClassFieldsCount(JNIEnv *env, jclass cb); 752 753JNIEXPORT jint JNICALL 754JVM_GetClassMethodsCount(JNIEnv *env, jclass cb); 755 756/* 757 * Returns the CP indexes of exceptions raised by a given method. 758 * Places the result in the given buffer. 759 * 760 * The method is identified by method_index. 761 */ 762JNIEXPORT void JNICALL 763JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index, 764 unsigned short *exceptions); 765/* 766 * Returns the number of exceptions raised by a given method. 767 * The method is identified by method_index. 768 */ 769JNIEXPORT jint JNICALL 770JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index); 771 772/* 773 * Returns the byte code sequence of a given method. 774 * Places the result in the given buffer. 775 * 776 * The method is identified by method_index. 777 */ 778JNIEXPORT void JNICALL 779JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index, 780 unsigned char *code); 781 782/* 783 * Returns the length of the byte code sequence of a given method. 784 * The method is identified by method_index. 785 */ 786JNIEXPORT jint JNICALL 787JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index); 788 789/* 790 * A structure used to a capture exception table entry in a Java method. 791 */ 792typedef struct { 793 jint start_pc; 794 jint end_pc; 795 jint handler_pc; 796 jint catchType; 797} JVM_ExceptionTableEntryType; 798 799/* 800 * Returns the exception table entry at entry_index of a given method. 801 * Places the result in the given buffer. 802 * 803 * The method is identified by method_index. 804 */ 805JNIEXPORT void JNICALL 806JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index, 807 jint entry_index, 808 JVM_ExceptionTableEntryType *entry); 809 810/* 811 * Returns the length of the exception table of a given method. 812 * The method is identified by method_index. 813 */ 814JNIEXPORT jint JNICALL 815JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index); 816 817/* 818 * Returns the modifiers of a given field. 819 * The field is identified by field_index. 820 */ 821JNIEXPORT jint JNICALL 822JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index); 823 824/* 825 * Returns the modifiers of a given method. 826 * The method is identified by method_index. 827 */ 828JNIEXPORT jint JNICALL 829JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index); 830 831/* 832 * Returns the number of local variables of a given method. 833 * The method is identified by method_index. 834 */ 835JNIEXPORT jint JNICALL 836JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index); 837 838/* 839 * Returns the number of arguments (including this pointer) of a given method. 840 * The method is identified by method_index. 841 */ 842JNIEXPORT jint JNICALL 843JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index); 844 845/* 846 * Returns the maximum amount of stack (in words) used by a given method. 847 * The method is identified by method_index. 848 */ 849JNIEXPORT jint JNICALL 850JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index); 851 852/* 853 * Is a given method a constructor. 854 * The method is identified by method_index. 855 */ 856JNIEXPORT jboolean JNICALL 857JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index); 858 859/* 860 * Returns the name of a given method in UTF format. 861 * The result remains valid until JVM_ReleaseUTF is called. 862 * 863 * The caller must treat the string as a constant and not modify it 864 * in any way. 865 */ 866JNIEXPORT const char * JNICALL 867JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index); 868 869/* 870 * Returns the signature of a given method in UTF format. 871 * The result remains valid until JVM_ReleaseUTF is called. 872 * 873 * The caller must treat the string as a constant and not modify it 874 * in any way. 875 */ 876JNIEXPORT const char * JNICALL 877JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index); 878 879/* 880 * Returns the name of the field refered to at a given constant pool 881 * index. 882 * 883 * The result is in UTF format and remains valid until JVM_ReleaseUTF 884 * is called. 885 * 886 * The caller must treat the string as a constant and not modify it 887 * in any way. 888 */ 889JNIEXPORT const char * JNICALL 890JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index); 891 892/* 893 * Returns the name of the method refered to at a given constant pool 894 * index. 895 * 896 * The result is in UTF format and remains valid until JVM_ReleaseUTF 897 * is called. 898 * 899 * The caller must treat the string as a constant and not modify it 900 * in any way. 901 */ 902JNIEXPORT const char * JNICALL 903JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index); 904 905/* 906 * Returns the signature of the method refered to at a given constant pool 907 * index. 908 * 909 * The result is in UTF format and remains valid until JVM_ReleaseUTF 910 * is called. 911 * 912 * The caller must treat the string as a constant and not modify it 913 * in any way. 914 */ 915JNIEXPORT const char * JNICALL 916JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index); 917 918/* 919 * Returns the signature of the field refered to at a given constant pool 920 * index. 921 * 922 * The result is in UTF format and remains valid until JVM_ReleaseUTF 923 * is called. 924 * 925 * The caller must treat the string as a constant and not modify it 926 * in any way. 927 */ 928JNIEXPORT const char * JNICALL 929JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index); 930 931/* 932 * Returns the class name refered to at a given constant pool index. 933 * 934 * The result is in UTF format and remains valid until JVM_ReleaseUTF 935 * is called. 936 * 937 * The caller must treat the string as a constant and not modify it 938 * in any way. 939 */ 940JNIEXPORT const char * JNICALL 941JVM_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index); 942 943/* 944 * Returns the class name refered to at a given constant pool index. 945 * 946 * The constant pool entry must refer to a CONSTANT_Fieldref. 947 * 948 * The result is in UTF format and remains valid until JVM_ReleaseUTF 949 * is called. 950 * 951 * The caller must treat the string as a constant and not modify it 952 * in any way. 953 */ 954JNIEXPORT const char * JNICALL 955JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index); 956 957/* 958 * Returns the class name refered to at a given constant pool index. 959 * 960 * The constant pool entry must refer to CONSTANT_Methodref or 961 * CONSTANT_InterfaceMethodref. 962 * 963 * The result is in UTF format and remains valid until JVM_ReleaseUTF 964 * is called. 965 * 966 * The caller must treat the string as a constant and not modify it 967 * in any way. 968 */ 969JNIEXPORT const char * JNICALL 970JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index); 971 972/* 973 * Returns the modifiers of a field in calledClass. The field is 974 * referred to in class cb at constant pool entry index. 975 * 976 * The caller must treat the string as a constant and not modify it 977 * in any way. 978 * 979 * Returns -1 if the field does not exist in calledClass. 980 */ 981JNIEXPORT jint JNICALL 982JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass); 983 984/* 985 * Returns the modifiers of a method in calledClass. The method is 986 * referred to in class cb at constant pool entry index. 987 * 988 * Returns -1 if the method does not exist in calledClass. 989 */ 990JNIEXPORT jint JNICALL 991JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass); 992 993/* 994 * Releases the UTF string obtained from the VM. 995 */ 996JNIEXPORT void JNICALL 997JVM_ReleaseUTF(const char *utf); 998 999/* 1000 * Compare if two classes are in the same package. 1001 */ 1002JNIEXPORT jboolean JNICALL 1003JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2); 1004 1005/* Constants in class files */ 1006 1007#define JVM_ACC_PUBLIC 0x0001 /* visible to everyone */ 1008#define JVM_ACC_PRIVATE 0x0002 /* visible only to the defining class */ 1009#define JVM_ACC_PROTECTED 0x0004 /* visible to subclasses */ 1010#define JVM_ACC_STATIC 0x0008 /* instance variable is static */ 1011#define JVM_ACC_FINAL 0x0010 /* no further subclassing, overriding */ 1012#define JVM_ACC_SYNCHRONIZED 0x0020 /* wrap method call in monitor lock */ 1013#define JVM_ACC_SUPER 0x0020 /* funky handling of invokespecial */ 1014#define JVM_ACC_VOLATILE 0x0040 /* can not cache in registers */ 1015#define JVM_ACC_BRIDGE 0x0040 /* bridge method generated by compiler */ 1016#define JVM_ACC_TRANSIENT 0x0080 /* not persistent */ 1017#define JVM_ACC_VARARGS 0x0080 /* method declared with variable number of args */ 1018#define JVM_ACC_NATIVE 0x0100 /* implemented in C */ 1019#define JVM_ACC_INTERFACE 0x0200 /* class is an interface */ 1020#define JVM_ACC_ABSTRACT 0x0400 /* no definition provided */ 1021#define JVM_ACC_STRICT 0x0800 /* strict floating point */ 1022#define JVM_ACC_SYNTHETIC 0x1000 /* compiler-generated class, method or field */ 1023#define JVM_ACC_ANNOTATION 0x2000 /* annotation type */ 1024#define JVM_ACC_ENUM 0x4000 /* field is declared as element of enum */ 1025 1026#define JVM_ACC_PUBLIC_BIT 0 1027#define JVM_ACC_PRIVATE_BIT 1 1028#define JVM_ACC_PROTECTED_BIT 2 1029#define JVM_ACC_STATIC_BIT 3 1030#define JVM_ACC_FINAL_BIT 4 1031#define JVM_ACC_SYNCHRONIZED_BIT 5 1032#define JVM_ACC_SUPER_BIT 5 1033#define JVM_ACC_VOLATILE_BIT 6 1034#define JVM_ACC_BRIDGE_BIT 6 1035#define JVM_ACC_TRANSIENT_BIT 7 1036#define JVM_ACC_VARARGS_BIT 7 1037#define JVM_ACC_NATIVE_BIT 8 1038#define JVM_ACC_INTERFACE_BIT 9 1039#define JVM_ACC_ABSTRACT_BIT 10 1040#define JVM_ACC_STRICT_BIT 11 1041#define JVM_ACC_SYNTHETIC_BIT 12 1042#define JVM_ACC_ANNOTATION_BIT 13 1043#define JVM_ACC_ENUM_BIT 14 1044 1045// NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/utilities/ConstantTag.java 1046enum { 1047 JVM_CONSTANT_Utf8 = 1, 1048 JVM_CONSTANT_Unicode, /* unused */ 1049 JVM_CONSTANT_Integer, 1050 JVM_CONSTANT_Float, 1051 JVM_CONSTANT_Long, 1052 JVM_CONSTANT_Double, 1053 JVM_CONSTANT_Class, 1054 JVM_CONSTANT_String, 1055 JVM_CONSTANT_Fieldref, 1056 JVM_CONSTANT_Methodref, 1057 JVM_CONSTANT_InterfaceMethodref, 1058 JVM_CONSTANT_NameAndType, 1059 JVM_CONSTANT_MethodHandle = 15, // JSR 292 1060 JVM_CONSTANT_MethodType = 16, // JSR 292 1061 //JVM_CONSTANT_(unused) = 17, // JSR 292 early drafts only 1062 JVM_CONSTANT_InvokeDynamic = 18, // JSR 292 1063 JVM_CONSTANT_ExternalMax = 18 // Last tag found in classfiles 1064}; 1065 1066/* JVM_CONSTANT_MethodHandle subtypes */ 1067enum { 1068 JVM_REF_getField = 1, 1069 JVM_REF_getStatic = 2, 1070 JVM_REF_putField = 3, 1071 JVM_REF_putStatic = 4, 1072 JVM_REF_invokeVirtual = 5, 1073 JVM_REF_invokeStatic = 6, 1074 JVM_REF_invokeSpecial = 7, 1075 JVM_REF_newInvokeSpecial = 8, 1076 JVM_REF_invokeInterface = 9 1077}; 1078 1079/* Used in the newarray instruction. */ 1080 1081#define JVM_T_BOOLEAN 4 1082#define JVM_T_CHAR 5 1083#define JVM_T_FLOAT 6 1084#define JVM_T_DOUBLE 7 1085#define JVM_T_BYTE 8 1086#define JVM_T_SHORT 9 1087#define JVM_T_INT 10 1088#define JVM_T_LONG 11 1089 1090/* JVM method signatures */ 1091 1092#define JVM_SIGNATURE_ARRAY '[' 1093#define JVM_SIGNATURE_BYTE 'B' 1094#define JVM_SIGNATURE_CHAR 'C' 1095#define JVM_SIGNATURE_CLASS 'L' 1096#define JVM_SIGNATURE_ENDCLASS ';' 1097#define JVM_SIGNATURE_ENUM 'E' 1098#define JVM_SIGNATURE_FLOAT 'F' 1099#define JVM_SIGNATURE_DOUBLE 'D' 1100#define JVM_SIGNATURE_FUNC '(' 1101#define JVM_SIGNATURE_ENDFUNC ')' 1102#define JVM_SIGNATURE_INT 'I' 1103#define JVM_SIGNATURE_LONG 'J' 1104#define JVM_SIGNATURE_SHORT 'S' 1105#define JVM_SIGNATURE_VOID 'V' 1106#define JVM_SIGNATURE_BOOLEAN 'Z' 1107 1108/* 1109 * A function defined by the byte-code verifier and called by the VM. 1110 * This is not a function implemented in the VM. 1111 * 1112 * Returns JNI_FALSE if verification fails. A detailed error message 1113 * will be places in msg_buf, whose length is specified by buf_len. 1114 */ 1115typedef jboolean (*verifier_fn_t)(JNIEnv *env, 1116 jclass cb, 1117 char * msg_buf, 1118 jint buf_len); 1119 1120 1121/* 1122 * Support for a VM-independent class format checker. 1123 */ 1124typedef struct { 1125 unsigned long code; /* byte code */ 1126 unsigned long excs; /* exceptions */ 1127 unsigned long etab; /* catch table */ 1128 unsigned long lnum; /* line number */ 1129 unsigned long lvar; /* local vars */ 1130} method_size_info; 1131 1132typedef struct { 1133 unsigned int constants; /* constant pool */ 1134 unsigned int fields; 1135 unsigned int methods; 1136 unsigned int interfaces; 1137 unsigned int fields2; /* number of static 2-word fields */ 1138 unsigned int innerclasses; /* # of records in InnerClasses attr */ 1139 1140 method_size_info clinit; /* memory used in clinit */ 1141 method_size_info main; /* used everywhere else */ 1142} class_size_info; 1143 1144/* 1145 * Functions defined in libjava.so to perform string conversions. 1146 * 1147 */ 1148 1149typedef jstring (*to_java_string_fn_t)(JNIEnv *env, char *str); 1150 1151typedef char *(*to_c_string_fn_t)(JNIEnv *env, jstring s, jboolean *b); 1152 1153/* This is the function defined in libjava.so that performs class 1154 * format checks. This functions fills in size information about 1155 * the class file and returns: 1156 * 1157 * 0: good 1158 * -1: out of memory 1159 * -2: bad format 1160 * -3: unsupported version 1161 * -4: bad class name 1162 */ 1163 1164typedef jint (*check_format_fn_t)(char *class_name, 1165 unsigned char *data, 1166 unsigned int data_size, 1167 class_size_info *class_size, 1168 char *message_buffer, 1169 jint buffer_length, 1170 jboolean measure_only, 1171 jboolean check_relaxed); 1172 1173#define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \ 1174 JVM_ACC_FINAL | \ 1175 JVM_ACC_SUPER | \ 1176 JVM_ACC_INTERFACE | \ 1177 JVM_ACC_ABSTRACT | \ 1178 JVM_ACC_ANNOTATION | \ 1179 JVM_ACC_ENUM | \ 1180 JVM_ACC_SYNTHETIC) 1181 1182#define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \ 1183 JVM_ACC_PRIVATE | \ 1184 JVM_ACC_PROTECTED | \ 1185 JVM_ACC_STATIC | \ 1186 JVM_ACC_FINAL | \ 1187 JVM_ACC_VOLATILE | \ 1188 JVM_ACC_TRANSIENT | \ 1189 JVM_ACC_ENUM | \ 1190 JVM_ACC_SYNTHETIC) 1191 1192#define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \ 1193 JVM_ACC_PRIVATE | \ 1194 JVM_ACC_PROTECTED | \ 1195 JVM_ACC_STATIC | \ 1196 JVM_ACC_FINAL | \ 1197 JVM_ACC_SYNCHRONIZED | \ 1198 JVM_ACC_BRIDGE | \ 1199 JVM_ACC_VARARGS | \ 1200 JVM_ACC_NATIVE | \ 1201 JVM_ACC_ABSTRACT | \ 1202 JVM_ACC_STRICT | \ 1203 JVM_ACC_SYNTHETIC) 1204 1205/* 1206 * This is the function defined in libjava.so to perform path 1207 * canonicalization. VM call this function before opening jar files 1208 * to load system classes. 1209 * 1210 */ 1211 1212typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len); 1213 1214/************************************************************************* 1215 PART 3: I/O and Network Support 1216 ************************************************************************/ 1217 1218/* Note that the JVM IO functions are expected to return JVM_IO_ERR 1219 * when there is any kind of error. The caller can then use the 1220 * platform specific support (e.g., errno) to get the detailed 1221 * error info. The JVM_GetLastErrorString procedure may also be used 1222 * to obtain a descriptive error string. 1223 */ 1224#define JVM_IO_ERR (-1) 1225 1226/* For interruptible IO. Returning JVM_IO_INTR indicates that an IO 1227 * operation has been disrupted by Thread.interrupt. There are a 1228 * number of technical difficulties related to interruptible IO that 1229 * need to be solved. For example, most existing programs do not handle 1230 * InterruptedIOExceptions specially, they simply treat those as any 1231 * IOExceptions, which typically indicate fatal errors. 1232 * 1233 * There are also two modes of operation for interruptible IO. In the 1234 * resumption mode, an interrupted IO operation is guaranteed not to 1235 * have any side-effects, and can be restarted. In the termination mode, 1236 * an interrupted IO operation corrupts the underlying IO stream, so 1237 * that the only reasonable operation on an interrupted stream is to 1238 * close that stream. The resumption mode seems to be impossible to 1239 * implement on Win32 and Solaris. Implementing the termination mode is 1240 * easier, but it's not clear that's the right semantics. 1241 * 1242 * Interruptible IO is not supported on Win32.It can be enabled/disabled 1243 * using a compile-time flag on Solaris. Third-party JVM ports do not 1244 * need to implement interruptible IO. 1245 */ 1246#define JVM_IO_INTR (-2) 1247 1248/* Write a string into the given buffer, in the platform's local encoding, 1249 * that describes the most recent system-level error to occur in this thread. 1250 * Return the length of the string or zero if no error occurred. 1251 */ 1252JNIEXPORT jint JNICALL 1253JVM_GetLastErrorString(char *buf, int len); 1254 1255/* 1256 * Convert a pathname into native format. This function does syntactic 1257 * cleanup, such as removing redundant separator characters. It modifies 1258 * the given pathname string in place. 1259 */ 1260JNIEXPORT char * JNICALL 1261JVM_NativePath(char *); 1262 1263/* 1264 * JVM I/O error codes 1265 */ 1266#define JVM_EEXIST -100 1267 1268/* 1269 * Open a file descriptor. This function returns a negative error code 1270 * on error, and a non-negative integer that is the file descriptor on 1271 * success. 1272 */ 1273JNIEXPORT jint JNICALL 1274JVM_Open(const char *fname, jint flags, jint mode); 1275 1276/* 1277 * Close a file descriptor. This function returns -1 on error, and 0 1278 * on success. 1279 * 1280 * fd the file descriptor to close. 1281 */ 1282JNIEXPORT jint JNICALL 1283JVM_Close(jint fd); 1284 1285/* 1286 * Read data from a file decriptor into a char array. 1287 * 1288 * fd the file descriptor to read from. 1289 * buf the buffer where to put the read data. 1290 * nbytes the number of bytes to read. 1291 * 1292 * This function returns -1 on error, and 0 on success. 1293 */ 1294JNIEXPORT jint JNICALL 1295JVM_Read(jint fd, char *buf, jint nbytes); 1296 1297/* 1298 * Write data from a char array to a file decriptor. 1299 * 1300 * fd the file descriptor to read from. 1301 * buf the buffer from which to fetch the data. 1302 * nbytes the number of bytes to write. 1303 * 1304 * This function returns -1 on error, and 0 on success. 1305 */ 1306JNIEXPORT jint JNICALL 1307JVM_Write(jint fd, char *buf, jint nbytes); 1308 1309/* 1310 * Returns the number of bytes available for reading from a given file 1311 * descriptor 1312 */ 1313JNIEXPORT jint JNICALL 1314JVM_Available(jint fd, jlong *pbytes); 1315 1316/* 1317 * Move the file descriptor pointer from whence by offset. 1318 * 1319 * fd the file descriptor to move. 1320 * offset the number of bytes to move it by. 1321 * whence the start from where to move it. 1322 * 1323 * This function returns the resulting pointer location. 1324 */ 1325JNIEXPORT jlong JNICALL 1326JVM_Lseek(jint fd, jlong offset, jint whence); 1327 1328/* 1329 * Set the length of the file associated with the given descriptor to the given 1330 * length. If the new length is longer than the current length then the file 1331 * is extended; the contents of the extended portion are not defined. The 1332 * value of the file pointer is undefined after this procedure returns. 1333 */ 1334JNIEXPORT jint JNICALL 1335JVM_SetLength(jint fd, jlong length); 1336 1337/* 1338 * Synchronize the file descriptor's in memory state with that of the 1339 * physical device. Return of -1 is an error, 0 is OK. 1340 */ 1341JNIEXPORT jint JNICALL 1342JVM_Sync(jint fd); 1343 1344/* 1345 * Networking library support 1346 */ 1347 1348JNIEXPORT jint JNICALL 1349JVM_InitializeSocketLibrary(void); 1350 1351struct sockaddr; 1352 1353JNIEXPORT jint JNICALL 1354JVM_Socket(jint domain, jint type, jint protocol); 1355 1356JNIEXPORT jint JNICALL 1357JVM_SocketClose(jint fd); 1358 1359JNIEXPORT jint JNICALL 1360JVM_SocketShutdown(jint fd, jint howto); 1361 1362JNIEXPORT jint JNICALL 1363JVM_Recv(jint fd, char *buf, jint nBytes, jint flags); 1364 1365JNIEXPORT jint JNICALL 1366JVM_Send(jint fd, char *buf, jint nBytes, jint flags); 1367 1368JNIEXPORT jint JNICALL 1369JVM_Timeout(int fd, long timeout); 1370 1371JNIEXPORT jint JNICALL 1372JVM_Listen(jint fd, jint count); 1373 1374JNIEXPORT jint JNICALL 1375JVM_Connect(jint fd, struct sockaddr *him, jint len); 1376 1377JNIEXPORT jint JNICALL 1378JVM_Bind(jint fd, struct sockaddr *him, jint len); 1379 1380JNIEXPORT jint JNICALL 1381JVM_Accept(jint fd, struct sockaddr *him, jint *len); 1382 1383JNIEXPORT jint JNICALL 1384JVM_RecvFrom(jint fd, char *buf, int nBytes, 1385 int flags, struct sockaddr *from, int *fromlen); 1386 1387JNIEXPORT jint JNICALL 1388JVM_SendTo(jint fd, char *buf, int len, 1389 int flags, struct sockaddr *to, int tolen); 1390 1391JNIEXPORT jint JNICALL 1392JVM_SocketAvailable(jint fd, jint *result); 1393 1394 1395JNIEXPORT jint JNICALL 1396JVM_GetSockName(jint fd, struct sockaddr *him, int *len); 1397 1398JNIEXPORT jint JNICALL 1399JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen); 1400 1401JNIEXPORT jint JNICALL 1402JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen); 1403 1404JNIEXPORT int JNICALL 1405JVM_GetHostName(char* name, int namelen); 1406 1407/* 1408 * The standard printing functions supported by the Java VM. (Should they 1409 * be renamed to JVM_* in the future? 1410 */ 1411 1412/* 1413 * BE CAREFUL! The following functions do not implement the 1414 * full feature set of standard C printf formats. 1415 */ 1416JNIEXPORT int 1417jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args); 1418 1419JNIEXPORT int 1420jio_snprintf(char *str, size_t count, const char *fmt, ...); 1421 1422JNIEXPORT int 1423jio_fprintf(FILE *, const char *fmt, ...); 1424 1425JNIEXPORT int 1426jio_vfprintf(FILE *, const char *fmt, va_list args); 1427 1428 1429JNIEXPORT void * JNICALL 1430JVM_RawMonitorCreate(void); 1431 1432JNIEXPORT void JNICALL 1433JVM_RawMonitorDestroy(void *mon); 1434 1435JNIEXPORT jint JNICALL 1436JVM_RawMonitorEnter(void *mon); 1437 1438JNIEXPORT void JNICALL 1439JVM_RawMonitorExit(void *mon); 1440 1441/* 1442 * java.lang.reflect.Method 1443 */ 1444JNIEXPORT jobject JNICALL 1445JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0); 1446 1447/* 1448 * java.lang.reflect.Constructor 1449 */ 1450JNIEXPORT jobject JNICALL 1451JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0); 1452 1453/* 1454 * java.lang.management support 1455 */ 1456JNIEXPORT void* JNICALL 1457JVM_GetManagement(jint version); 1458 1459/* 1460 * com.sun.tools.attach.VirtualMachine support 1461 * 1462 * Initialize the agent properties with the properties maintained in the VM. 1463 */ 1464JNIEXPORT jobject JNICALL 1465JVM_InitAgentProperties(JNIEnv *env, jobject agent_props); 1466 1467/* Generics reflection support. 1468 * 1469 * Returns information about the given class's EnclosingMethod 1470 * attribute, if present, or null if the class had no enclosing 1471 * method. 1472 * 1473 * If non-null, the returned array contains three elements. Element 0 1474 * is the java.lang.Class of which the enclosing method is a member, 1475 * and elements 1 and 2 are the java.lang.Strings for the enclosing 1476 * method's name and descriptor, respectively. 1477 */ 1478JNIEXPORT jobjectArray JNICALL 1479JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass); 1480 1481/* 1482 * Java thread state support 1483 */ 1484enum { 1485 JAVA_THREAD_STATE_NEW = 0, 1486 JAVA_THREAD_STATE_RUNNABLE = 1, 1487 JAVA_THREAD_STATE_BLOCKED = 2, 1488 JAVA_THREAD_STATE_WAITING = 3, 1489 JAVA_THREAD_STATE_TIMED_WAITING = 4, 1490 JAVA_THREAD_STATE_TERMINATED = 5, 1491 JAVA_THREAD_STATE_COUNT = 6 1492}; 1493 1494/* 1495 * Returns an array of the threadStatus values representing the 1496 * given Java thread state. Returns NULL if the VM version is 1497 * incompatible with the JDK or doesn't support the given 1498 * Java thread state. 1499 */ 1500JNIEXPORT jintArray JNICALL 1501JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState); 1502 1503/* 1504 * Returns an array of the substate names representing the 1505 * given Java thread state. Returns NULL if the VM version is 1506 * incompatible with the JDK or the VM doesn't support 1507 * the given Java thread state. 1508 * values must be the jintArray returned from JVM_GetThreadStateValues 1509 * and javaThreadState. 1510 */ 1511JNIEXPORT jobjectArray JNICALL 1512JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values); 1513 1514/* ========================================================================= 1515 * The following defines a private JVM interface that the JDK can query 1516 * for the JVM version and capabilities. sun.misc.Version defines 1517 * the methods for getting the VM version and its capabilities. 1518 * 1519 * When a new bit is added, the following should be updated to provide 1520 * access to the new capability: 1521 * HS: JVM_GetVersionInfo and Abstract_VM_Version class 1522 * SDK: Version class 1523 * 1524 * Similary, a private JDK interface JDK_GetVersionInfo0 is defined for 1525 * JVM to query for the JDK version and capabilities. 1526 * 1527 * When a new bit is added, the following should be updated to provide 1528 * access to the new capability: 1529 * HS: JDK_Version class 1530 * SDK: JDK_GetVersionInfo0 1531 * 1532 * ========================================================================== 1533 */ 1534typedef struct { 1535 /* HotSpot Express VM version string: 1536 * <major>.<minor>-bxx[-<identifier>][-<debug_flavor>] 1537 */ 1538 unsigned int jvm_version; /* Consists of major.minor.0.build */ 1539 unsigned int update_version : 8; /* 0 in HotSpot Express VM */ 1540 unsigned int special_update_version : 8; /* 0 in HotSpot Express VM */ 1541 unsigned int reserved1 : 16; 1542 unsigned int reserved2; 1543 1544 /* The following bits represents JVM supports that JDK has dependency on. 1545 * JDK can use these bits to determine which JVM version 1546 * and support it has to maintain runtime compatibility. 1547 * 1548 * When a new bit is added in a minor or update release, make sure 1549 * the new bit is also added in the main/baseline. 1550 */ 1551 unsigned int is_attachable : 1; 1552 unsigned int is_kernel_jvm : 1; 1553 unsigned int : 30; 1554 unsigned int : 32; 1555 unsigned int : 32; 1556} jvm_version_info; 1557 1558#define JVM_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24) 1559#define JVM_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16) 1560// Micro version is 0 in HotSpot Express VM (set in jvm.cpp). 1561#define JVM_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8) 1562/* Build number is available in all HotSpot Express VM builds. 1563 * It is defined in make/hotspot_version file. 1564 */ 1565#define JVM_VERSION_BUILD(version) ((version & 0x000000FF)) 1566 1567JNIEXPORT void JNICALL 1568JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size); 1569 1570typedef struct { 1571 // Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx 1572 unsigned int jdk_version; /* Consists of major, minor, micro (n.n.n) */ 1573 /* and build number (xx) */ 1574 unsigned int update_version : 8; /* Update release version (uu) */ 1575 unsigned int special_update_version : 8; /* Special update release version (c)*/ 1576 unsigned int reserved1 : 16; 1577 unsigned int reserved2; 1578 1579 /* The following bits represents new JDK supports that VM has dependency on. 1580 * VM implementation can use these bits to determine which JDK version 1581 * and support it has to maintain runtime compatibility. 1582 * 1583 * When a new bit is added in a minor or update release, make sure 1584 * the new bit is also added in the main/baseline. 1585 */ 1586 unsigned int thread_park_blocker : 1; 1587 unsigned int post_vm_init_hook_enabled : 1; 1588 unsigned int pending_list_uses_discovered_field : 1; 1589 unsigned int : 29; 1590 unsigned int : 32; 1591 unsigned int : 32; 1592} jdk_version_info; 1593 1594#define JDK_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24) 1595#define JDK_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16) 1596#define JDK_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8) 1597 1598/* Build number is available only for RE build (i.e. JDK_BUILD_NUMBER is set to bNN) 1599 * It will be zero for internal builds. 1600 */ 1601#define JDK_VERSION_BUILD(version) ((version & 0x000000FF)) 1602 1603/* 1604 * This is the function JDK_GetVersionInfo0 defined in libjava.so 1605 * that is dynamically looked up by JVM. 1606 */ 1607typedef void (*jdk_version_info_fn_t)(jdk_version_info* info, size_t info_size); 1608 1609/* 1610 * This structure is used by the launcher to get the default thread 1611 * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a 1612 * version of 1.1. As it is not supported otherwise, it has been removed 1613 * from jni.h 1614 */ 1615typedef struct JDK1_1InitArgs { 1616 jint version; 1617 1618 char **properties; 1619 jint checkSource; 1620 jint nativeStackSize; 1621 jint javaStackSize; 1622 jint minHeapSize; 1623 jint maxHeapSize; 1624 jint verifyMode; 1625 char *classpath; 1626 1627 jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args); 1628 void (JNICALL *exit)(jint code); 1629 void (JNICALL *abort)(void); 1630 1631 jint enableClassGC; 1632 jint enableVerboseGC; 1633 jint disableAsyncGC; 1634 jint verbose; 1635 jboolean debugging; 1636 jint debugPort; 1637} JDK1_1InitArgs; 1638 1639#ifdef __cplusplus 1640} /* extern "C" */ 1641#endif /* __cplusplus */ 1642 1643#endif /* !_JAVASOFT_JVM_H_ */ 1644 1645#endif // SHARE_VM_PRIMS_JVM_H 1646