diff -r 378aa3362868 -r 320a714614e9 jdk/src/macosx/bin/java_md_macosx.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/src/macosx/bin/java_md_macosx.c Tue Mar 06 20:34:38 2012 +0000 @@ -0,0 +1,1005 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +#include "java.h" +#include "jvm_md.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "manifest_info.h" +#include "version_comp.h" + +/* Support Cocoa event loop on the main thread */ +#include +#include +#include +#include + +#include +#include + +struct NSAppArgs { + int argc; + char **argv; +}; + +#define JVM_DLL "libjvm.dylib" +#define JAVA_DLL "libjava.dylib" +/* FALLBACK avoids naming conflicts with system libraries + * (eg, ImageIO's libJPEG.dylib) */ +#define LD_LIBRARY_PATH "DYLD_FALLBACK_LIBRARY_PATH" + +/* + * If a processor / os combination has the ability to run binaries of + * two data models and cohabitation of jre/jdk bits with both data + * models is supported, then DUAL_MODE is defined. MacOSX is a hybrid + * system in that, the universal library can contain all types of libraries + * 32/64 and client/server, thus the spawn is capable of linking with the + * appropriate library as requested. + * + * Notes: + * 1. VM. DUAL_MODE is disabled, and not supported, however, it is left here in + * for experimentation and perhaps enable it in the future. + * 2. At the time of this writing, the universal library contains only + * a server 64-bit server JVM. + * 3. "-client" command line option is supported merely as a command line flag, + * for, compatibility reasons, however, a server VM will be launched. + */ + +/* + * Flowchart of launcher execs and options processing on unix + * + * The selection of the proper vm shared library to open depends on + * several classes of command line options, including vm "flavor" + * options (-client, -server) and the data model options, -d32 and + * -d64, as well as a version specification which may have come from + * the command line or from the manifest of an executable jar file. + * The vm selection options are not passed to the running + * virtual machine; they must be screened out by the launcher. + * + * The version specification (if any) is processed first by the + * platform independent routine SelectVersion. This may result in + * the exec of the specified launcher version. + * + * Now, in most cases,the launcher will dlopen the target libjvm.so. All + * required libraries are loaded by the runtime linker, using the known paths + * baked into the shared libraries at compile time. Therefore, + * in most cases, the launcher will only exec, if the data models are + * mismatched, and will not set any environment variables, regardless of the + * data models. + * + * + * + * Main + * (incoming argv) + * | + * \|/ + * SelectVersion + * (selects the JRE version, note: not data model) + * | + * \|/ + * CreateExecutionEnvironment + * (determines desired data model) + * | + * | + * \|/ + * Have Desired Model ? --> NO --> Is Dual-Mode ? --> NO --> Exit(with error) + * | | + * | | + * | \|/ + * | YES + * | | + * | | + * | \|/ + * | CheckJvmType + * | (removes -client, -server etc.) + * | | + * | | + * \|/ \|/ + * YES Find the desired executable/library + * | | + * | | + * \|/ \|/ + * CheckJvmType POINT A + * (removes -client, -server, etc.) + * | + * | + * \|/ + * TranslateDashJArgs... + * (Prepare to pass args to vm) + * | + * | + * \|/ + * ParseArguments + * (removes -d32 and -d64 if any, + * processes version options, + * creates argument list for vm, + * etc.) + * | + * | + * \|/ + * POINT A + * | + * | + * \|/ + * Path is desired JRE ? YES --> Have Desired Model ? NO --> Re-exec --> Main + * NO YES --> Continue + * | + * | + * \|/ + * Paths have well known + * jvm paths ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main + * YES YES --> Continue + * | + * | + * \|/ + * Does libjvm.so exist + * in any of them ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main + * YES YES --> Continue + * | + * | + * \|/ + * Re-exec / Spawn + * | + * | + * \|/ + * Main + */ + +#define GetArch() GetArchPath(CURRENT_DATA_MODEL) + +/* Store the name of the executable once computed */ +static char *execname = NULL; + +/* + * execname accessor from other parts of platform dependent logic + */ +const char * +GetExecName() { + return execname; +} + +const char * +GetArchPath(int nbits) +{ + switch(nbits) { + default: + return LIBARCHNAME; + } +} + + +/* + * Exports the JNI interface from libjli + * + * This allows client code to link against the .jre/.jdk bundles, + * and not worry about trying to pick a HotSpot to link against. + * + * Switching architectures is unsupported, since client code has + * made that choice before the JVM was requested. + */ + +static InvocationFunctions *sExportedJNIFunctions = NULL; +static char *sPreferredJVMType = NULL; + +static InvocationFunctions *GetExportedJNIFunctions() { + if (sExportedJNIFunctions != NULL) return sExportedJNIFunctions; + + char jrePath[PATH_MAX]; + jboolean gotJREPath = GetJREPath(jrePath, sizeof(jrePath), GetArch(), JNI_FALSE); + if (!gotJREPath) { + JLI_ReportErrorMessage("Failed to GetJREPath()"); + return NULL; + } + + char *preferredJVM = sPreferredJVMType; + if (preferredJVM == NULL) { +#if defined(__i386__) + preferredJVM = "client"; +#elif defined(__x86_64__) + preferredJVM = "server"; +#else +#error "Unknown architecture - needs definition" +#endif + } + + char jvmPath[PATH_MAX]; + jboolean gotJVMPath = GetJVMPath(jrePath, preferredJVM, jvmPath, sizeof(jvmPath), GetArch(), CURRENT_DATA_MODEL); + if (!gotJVMPath) { + JLI_ReportErrorMessage("Failed to GetJVMPath()"); + return NULL; + } + + InvocationFunctions *fxns = malloc(sizeof(InvocationFunctions)); + jboolean vmLoaded = LoadJavaVM(jvmPath, fxns); + if (!vmLoaded) { + JLI_ReportErrorMessage("Failed to LoadJavaVM()"); + return NULL; + } + + return sExportedJNIFunctions = fxns; +} + +JNIEXPORT jint JNICALL +JNI_GetDefaultJavaVMInitArgs(void *args) { + InvocationFunctions *ifn = GetExportedJNIFunctions(); + if (ifn == NULL) return JNI_ERR; + return ifn->GetDefaultJavaVMInitArgs(args); +} + +JNIEXPORT jint JNICALL +JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args) { + InvocationFunctions *ifn = GetExportedJNIFunctions(); + if (ifn == NULL) return JNI_ERR; + return ifn->CreateJavaVM(pvm, penv, args); +} + +JNIEXPORT jint JNICALL +JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs) { + InvocationFunctions *ifn = GetExportedJNIFunctions(); + if (ifn == NULL) return JNI_ERR; + return ifn->GetCreatedJavaVMs(vmBuf, bufLen, nVMs); +} + +/* + * Allow JLI-aware launchers to specify a client/server preference + */ +JNIEXPORT void JNICALL +JLI_SetPreferredJVM(const char *prefJVM) { + if (sPreferredJVMType != NULL) { + free(sPreferredJVMType); + sPreferredJVMType = NULL; + } + + if (prefJVM == NULL) return; + sPreferredJVMType = strdup(prefJVM); +} + +static BOOL awtLoaded = NO; +static pthread_mutex_t awtLoaded_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t awtLoaded_cv = PTHREAD_COND_INITIALIZER; + +JNIEXPORT void JNICALL +JLI_NotifyAWTLoaded() +{ + pthread_mutex_lock(&awtLoaded_mutex); + awtLoaded = YES; + pthread_cond_signal(&awtLoaded_cv); + pthread_mutex_unlock(&awtLoaded_mutex); +} + +static int (*main_fptr)(int argc, char **argv) = NULL; + +/* + * Unwrap the arguments and re-run main() + */ +static void *apple_main (void *arg) +{ + objc_registerThreadWithCollector(); + + if (main_fptr == NULL) { + main_fptr = (int (*)())dlsym(RTLD_DEFAULT, "main"); + if (main_fptr == NULL) { + JLI_ReportErrorMessageSys("error locating main entrypoint\n"); + exit(1); + } + } + + struct NSAppArgs *args = (struct NSAppArgs *) arg; + exit(main_fptr(args->argc, args->argv)); +} + +static void dummyTimer(CFRunLoopTimerRef timer, void *info) {} + +static void ParkEventLoop() { + // RunLoop needs at least one source, and 1e20 is pretty far into the future + CFRunLoopTimerRef t = CFRunLoopTimerCreate(kCFAllocatorDefault, 1.0e20, 0.0, 0, 0, dummyTimer, NULL); + CFRunLoopAddTimer(CFRunLoopGetCurrent(), t, kCFRunLoopDefaultMode); + CFRelease(t); + + // Park this thread in the main run loop. + int32_t result; + do { + result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e20, false); + } while (result != kCFRunLoopRunFinished); +} + +/* + * Mac OS X mandates that the GUI event loop run on very first thread of + * an application. This requires that we re-call Java's main() on a new + * thread, reserving the 'main' thread for Cocoa. + */ +static void MacOSXStartup(int argc, char *argv[]) { + // Thread already started? + static jboolean started = false; + if (started) { + return; + } + started = true; + + // Hand off arguments + struct NSAppArgs args; + args.argc = argc; + args.argv = argv; + + // Fire up the main thread + pthread_t main_thr; + if (pthread_create(&main_thr, NULL, &apple_main, &args) != 0) { + JLI_ReportErrorMessageSys("Could not create main thread: %s\n", strerror(errno)); + exit(1); + } + if (pthread_detach(main_thr)) { + JLI_ReportErrorMessageSys("pthread_detach() failed: %s\n", strerror(errno)); + exit(1); + } + + ParkEventLoop(); +} + +void +CreateExecutionEnvironment(int *pargc, char ***pargv, + char jrepath[], jint so_jrepath, + char jvmpath[], jint so_jvmpath, + char jvmcfg[], jint so_jvmcfg) { + /* + * First, determine if we are running the desired data model. If we + * are running the desired data model, all the error messages + * associated with calling GetJREPath, ReadKnownVMs, etc. should be + * output. However, if we are not running the desired data model, + * some of the errors should be suppressed since it is more + * informative to issue an error message based on whether or not the + * os/processor combination has dual mode capabilities. + */ + jboolean jvmpathExists; + + /* Compute/set the name of the executable */ + SetExecname(*pargv); + + /* Check data model flags, and exec process, if needed */ + { + char *arch = (char *)GetArch(); /* like sparc or sparcv9 */ + char * jvmtype = NULL; + int argc = *pargc; + char **argv = *pargv; + int running = CURRENT_DATA_MODEL; + + int wanted = running; /* What data mode is being + asked for? Current model is + fine unless another model + is asked for */ + + char** newargv = NULL; + int newargc = 0; + + /* + * Starting in 1.5, all unix platforms accept the -d32 and -d64 + * options. On platforms where only one data-model is supported + * (e.g. ia-64 Linux), using the flag for the other data model is + * an error and will terminate the program. + */ + + { /* open new scope to declare local variables */ + int i; + + newargv = (char **)JLI_MemAlloc((argc+1) * sizeof(char*)); + newargv[newargc++] = argv[0]; + + /* scan for data model arguments and remove from argument list; + last occurrence determines desired data model */ + for (i=1; i < argc; i++) { + + if (JLI_StrCmp(argv[i], "-J-d64") == 0 || JLI_StrCmp(argv[i], "-d64") == 0) { + wanted = 64; + continue; + } + if (JLI_StrCmp(argv[i], "-J-d32") == 0 || JLI_StrCmp(argv[i], "-d32") == 0) { + wanted = 32; + continue; + } + newargv[newargc++] = argv[i]; + + if (IsJavaArgs()) { + if (argv[i][0] != '-') continue; + } else { + if (JLI_StrCmp(argv[i], "-classpath") == 0 || JLI_StrCmp(argv[i], "-cp") == 0) { + i++; + if (i >= argc) break; + newargv[newargc++] = argv[i]; + continue; + } + if (argv[i][0] != '-') { i++; break; } + } + } + + /* copy rest of args [i .. argc) */ + while (i < argc) { + newargv[newargc++] = argv[i++]; + } + newargv[newargc] = NULL; + + /* + * newargv has all proper arguments here + */ + + argc = newargc; + argv = newargv; + } + + /* If the data model is not changing, it is an error if the + jvmpath does not exist */ + if (wanted == running) { + /* Find out where the JRE is that we will be using. */ + if (!GetJREPath(jrepath, so_jrepath, arch, JNI_FALSE) ) { + JLI_ReportErrorMessage(JRE_ERROR1); + exit(2); + } + JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%s%sjvm.cfg", + jrepath, FILESEP, FILESEP, "", ""); + /* Find the specified JVM type */ + if (ReadKnownVMs(jvmcfg, JNI_FALSE) < 1) { + JLI_ReportErrorMessage(CFG_ERROR7); + exit(1); + } + + jvmpath[0] = '\0'; + jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE); + if (JLI_StrCmp(jvmtype, "ERROR") == 0) { + JLI_ReportErrorMessage(CFG_ERROR9); + exit(4); + } + + if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, arch, wanted)) { + JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath); + exit(4); + } + + /* + * Mac OS X requires the Cocoa event loop to be run on the "main" + * thread. Spawn off a new thread to run main() and pass + * this thread off to the Cocoa event loop. + */ + MacOSXStartup(argc, argv); + + /* + * we seem to have everything we need, so without further ado + * we return back, otherwise proceed to set the environment. + */ + return; + } else { /* do the same speculatively or exit */ +#if defined(DUAL_MODE) + if (running != wanted) { + /* Find out where the JRE is that we will be using. */ + if (!GetJREPath(jrepath, so_jrepath, GetArchPath(wanted), JNI_TRUE)) { + /* give up and let other code report error message */ + JLI_ReportErrorMessage(JRE_ERROR2, wanted); + exit(1); + } + JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%s%sjvm.cfg", + jrepath, FILESEP, FILESEP, "", ""); + /* + * Read in jvm.cfg for target data model and process vm + * selection options. + */ + if (ReadKnownVMs(jvmcfg, JNI_TRUE) < 1) { + /* give up and let other code report error message */ + JLI_ReportErrorMessage(JRE_ERROR2, wanted); + exit(1); + } + jvmpath[0] = '\0'; + jvmtype = CheckJvmType(pargc, pargv, JNI_TRUE); + if (JLI_StrCmp(jvmtype, "ERROR") == 0) { + JLI_ReportErrorMessage(CFG_ERROR9); + exit(4); + } + + /* exec child can do error checking on the existence of the path */ + jvmpathExists = GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, GetArchPath(wanted), wanted); + } +#else /* ! DUAL_MODE */ + JLI_ReportErrorMessage(JRE_ERROR2, wanted); + exit(1); +#endif /* DUAL_MODE */ + } + { + char *newexec = execname; + JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n"); + (void) fflush(stdout); + (void) fflush(stderr); + /* + * Use posix_spawn() instead of execv() on Mac OS X. + * This allows us to choose which architecture the child process + * should run as. + */ + { + posix_spawnattr_t attr; + size_t unused_size; + pid_t unused_pid; + +#if defined(__i386__) || defined(__x86_64__) + cpu_type_t cpu_type[] = { (wanted == 64) ? CPU_TYPE_X86_64 : CPU_TYPE_X86, + (running== 64) ? CPU_TYPE_X86_64 : CPU_TYPE_X86 }; +#else + cpu_type_t cpu_type[] = { CPU_TYPE_ANY }; +#endif /* __i386 .. */ + + posix_spawnattr_init(&attr); + posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETEXEC); + posix_spawnattr_setbinpref_np(&attr, sizeof(cpu_type) / sizeof(cpu_type_t), + cpu_type, &unused_size); + + posix_spawn(&unused_pid, newexec, NULL, &attr, argv, environ); + } + JLI_ReportErrorMessageSys(JRE_ERROR4, newexec); + +#if defined(DUAL_MODE) + if (running != wanted) { + JLI_ReportErrorMessage(JRE_ERROR5, wanted, running); + } +#endif /* DUAL_MODE */ + } + exit(1); + } +} + +/* + * VM choosing is done by the launcher (java.c). + */ +static jboolean +GetJVMPath(const char *jrepath, const char *jvmtype, + char *jvmpath, jint jvmpathsize, const char * arch, int bitsWanted) +{ + struct stat s; + + if (JLI_StrChr(jvmtype, '/')) { + JLI_Snprintf(jvmpath, jvmpathsize, "%s/" JVM_DLL, jvmtype); + } else { + /* + * macosx client library is built thin, i386 only. + * 64 bit client requests must load server library + */ + const char *jvmtypeUsed = ((bitsWanted == 64) && (strcmp(jvmtype, "client") == 0)) ? "server" : jvmtype; + JLI_Snprintf(jvmpath, jvmpathsize, "%s/lib/%s/" JVM_DLL, jrepath, jvmtypeUsed); + } + + JLI_TraceLauncher("Does `%s' exist ... ", jvmpath); + + if (stat(jvmpath, &s) == 0) { + JLI_TraceLauncher("yes.\n"); + return JNI_TRUE; + } else { + JLI_TraceLauncher("no.\n"); + return JNI_FALSE; + } +} + +/* + * Find path to JRE based on .exe's location or registry settings. + */ +static jboolean +GetJREPath(char *path, jint pathsize, const char * arch, jboolean speculative) +{ + char libjava[MAXPATHLEN]; + + if (GetApplicationHome(path, pathsize)) { + /* Is JRE co-located with the application? */ + JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/" JAVA_DLL, path); + if (access(libjava, F_OK) == 0) { + return JNI_TRUE; + } + + /* Does the app ship a private JRE in /jre directory? */ + JLI_Snprintf(libjava, sizeof(libjava), "%s/jre/lib/" JAVA_DLL, path); + if (access(libjava, F_OK) == 0) { + JLI_StrCat(path, "/jre"); + JLI_TraceLauncher("JRE path is %s\n", path); + return JNI_TRUE; + } + } + + /* try to find ourselves instead */ + Dl_info selfInfo; + dladdr(&GetJREPath, &selfInfo); + + char *realPathToSelf = realpath(selfInfo.dli_fname, path); + if (realPathToSelf != path) { + return JNI_FALSE; + } + + size_t pathLen = strlen(realPathToSelf); + if (pathLen == 0) { + return JNI_FALSE; + } + + const char lastPathComponent[] = "/lib/jli/libjli.dylib"; + size_t sizeOfLastPathComponent = sizeof(lastPathComponent) - 1; + if (pathLen < sizeOfLastPathComponent) { + return JNI_FALSE; + } + + size_t indexOfLastPathComponent = pathLen - sizeOfLastPathComponent; + if (0 == strncmp(realPathToSelf + indexOfLastPathComponent, lastPathComponent, sizeOfLastPathComponent - 1)) { + realPathToSelf[indexOfLastPathComponent + 1] = '\0'; + return JNI_TRUE; + } + + if (!speculative) + JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL); + return JNI_FALSE; +} + +jboolean +LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn) +{ + Dl_info dlinfo; + void *libjvm; + + JLI_TraceLauncher("JVM path is %s\n", jvmpath); + + libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL); + if (libjvm == NULL) { + JLI_ReportErrorMessage(DLL_ERROR1, __LINE__); + JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); + return JNI_FALSE; + } + + ifn->CreateJavaVM = (CreateJavaVM_t) + dlsym(libjvm, "JNI_CreateJavaVM"); + if (ifn->CreateJavaVM == NULL) { + JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); + return JNI_FALSE; + } + + ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t) + dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs"); + if (ifn->GetDefaultJavaVMInitArgs == NULL) { + JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); + return JNI_FALSE; + } + + ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t) + dlsym(libjvm, "JNI_GetCreatedJavaVMs"); + if (ifn->GetCreatedJavaVMs == NULL) { + JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); + return JNI_FALSE; + } + + return JNI_TRUE; +} + +/* + * Compute the name of the executable + * + * In order to re-exec securely we need the absolute path of the + * executable. On Solaris getexecname(3c) may not return an absolute + * path so we use dladdr to get the filename of the executable and + * then use realpath to derive an absolute path. From Solaris 9 + * onwards the filename returned in DL_info structure from dladdr is + * an absolute pathname so technically realpath isn't required. + * On Linux we read the executable name from /proc/self/exe. + * As a fallback, and for platforms other than Solaris and Linux, + * we use FindExecName to compute the executable name. + */ +const char* +SetExecname(char **argv) +{ + char* exec_path = NULL; + { + Dl_info dlinfo; + int (*fptr)(); + + fptr = (int (*)())dlsym(RTLD_DEFAULT, "main"); + if (fptr == NULL) { + JLI_ReportErrorMessage(DLL_ERROR3, dlerror()); + return JNI_FALSE; + } + + if (dladdr((void*)fptr, &dlinfo)) { + char *resolved = (char*)JLI_MemAlloc(PATH_MAX+1); + if (resolved != NULL) { + exec_path = realpath(dlinfo.dli_fname, resolved); + if (exec_path == NULL) { + JLI_MemFree(resolved); + } + } + } + } + if (exec_path == NULL) { + exec_path = FindExecName(argv[0]); + } + execname = exec_path; + return exec_path; +} + +/* + * BSD's implementation of CounterGet() + */ +int64_t +CounterGet() +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return (tv.tv_sec * 1000) + tv.tv_usec; +} + + +/* --- Splash Screen shared library support --- */ + +static JavaVM* SetJavaVMValue() +{ + JavaVM * jvm = NULL; + + // The handle is good for both the launcher and the libosxapp.dylib + void * handle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL); + if (handle) { + typedef JavaVM* (*JLI_GetJavaVMInstance_t)(); + + JLI_GetJavaVMInstance_t JLI_GetJavaVMInstance = + (JLI_GetJavaVMInstance_t)dlsym(handle, + "JLI_GetJavaVMInstance"); + if (JLI_GetJavaVMInstance) { + jvm = JLI_GetJavaVMInstance(); + } + + if (jvm) { + typedef void (*OSXAPP_SetJavaVM_t)(JavaVM*); + + OSXAPP_SetJavaVM_t OSXAPP_SetJavaVM = + (OSXAPP_SetJavaVM_t)dlsym(handle, "OSXAPP_SetJavaVM"); + if (OSXAPP_SetJavaVM) { + OSXAPP_SetJavaVM(jvm); + } else { + jvm = NULL; + } + } + + dlclose(handle); + } + + return jvm; +} + +static const char* SPLASHSCREEN_SO = JNI_LIB_NAME("splashscreen"); + +static void* hSplashLib = NULL; + +void* SplashProcAddress(const char* name) { + if (!hSplashLib) { + char jrePath[PATH_MAX]; + if (!GetJREPath(jrePath, sizeof(jrePath), GetArch(), JNI_FALSE)) { + JLI_ReportErrorMessage(JRE_ERROR1); + return NULL; + } + + char splashPath[PATH_MAX]; + const int ret = JLI_Snprintf(splashPath, sizeof(splashPath), + "%s/lib/%s", jrePath, SPLASHSCREEN_SO); + if (ret >= (int)sizeof(splashPath)) { + JLI_ReportErrorMessage(JRE_ERROR11); + return NULL; + } + if (ret < 0) { + JLI_ReportErrorMessage(JRE_ERROR13); + return NULL; + } + + hSplashLib = dlopen(splashPath, RTLD_LAZY | RTLD_GLOBAL); + // It's OK if dlopen() fails. The splash screen library binary file + // might have been stripped out from the JRE image to reduce its size + // (e.g. on embedded platforms). + + if (hSplashLib) { + if (!SetJavaVMValue()) { + dlclose(hSplashLib); + hSplashLib = NULL; + } + } + } + if (hSplashLib) { + void* sym = dlsym(hSplashLib, name); + return sym; + } else { + return NULL; + } +} + +void SplashFreeLibrary() { + if (hSplashLib) { + dlclose(hSplashLib); + hSplashLib = NULL; + } +} + +/* + * Block current thread and continue execution in a new thread + */ +int +ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) { + int rslt; + pthread_t tid; + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); + + if (stack_size > 0) { + pthread_attr_setstacksize(&attr, stack_size); + } + + if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) { + void * tmp; + pthread_join(tid, &tmp); + rslt = (int)tmp; + } else { + /* + * Continue execution in current thread if for some reason (e.g. out of + * memory/LWP) a new thread can't be created. This will likely fail + * later in continuation as JNI_CreateJavaVM needs to create quite a + * few new threads, anyway, just give it a try.. + */ + rslt = continuation(args); + } + + pthread_attr_destroy(&attr); + return rslt; +} + +void SetJavaLauncherPlatformProps() { + /* Linux only */ +} + +jboolean +ServerClassMachine(void) { + return JNI_TRUE; +} + +static JavaVM* jvmInstance = NULL; +static jboolean sameThread = JNI_FALSE; /* start VM in current thread */ + +/* + * Note there is a callback on this function from the splashscreen logic, + * this as well SetJavaVMValue() needs to be simplified. + */ +JavaVM* +JLI_GetJavaVMInstance() +{ + return jvmInstance; +} + +void +RegisterThread() +{ + objc_registerThreadWithCollector(); +} + +static void +SetXDockArgForAWT(const char *arg) +{ + char envVar[80]; + if (strstr(arg, "-Xdock:name=") == arg) { + snprintf(envVar, sizeof(envVar), "APP_NAME_%d", getpid()); + setenv(envVar, (arg + 12), 1); + } + + if (strstr(arg, "-Xdock:icon=") == arg) { + snprintf(envVar, sizeof(envVar), "APP_ICON_%d", getpid()); + setenv(envVar, (arg + 12), 1); + } +} + +static void +SetMainClassForAWT(JNIEnv *env, jclass mainClass) { + jclass classClass = NULL; + NULL_CHECK(classClass = FindBootStrapClass(env, "java/lang/Class")); + + jmethodID getCanonicalNameMID = NULL; + NULL_CHECK(getCanonicalNameMID = (*env)->GetMethodID(env, classClass, "getCanonicalName", "()Ljava/lang/String;")); + + jstring mainClassString = NULL; + NULL_CHECK(mainClassString = (*env)->CallObjectMethod(env, mainClass, getCanonicalNameMID)); + + const char *mainClassName = NULL; + NULL_CHECK(mainClassName = (*env)->GetStringUTFChars(env, mainClassString, NULL)); + + char envVar[80]; + snprintf(envVar, sizeof(envVar), "JAVA_MAIN_CLASS_%d", getpid()); + setenv(envVar, mainClassName, 1); + + (*env)->ReleaseStringUTFChars(env, mainClassString, mainClassName); +} + +void +SetXStartOnFirstThreadArg() +{ + // XXX: BEGIN HACK + // short circuit hack for + // need a way to get AWT/Swing apps launched when spawned from Eclipse, + // which currently has no UI to not pass the -XstartOnFirstThread option + if (getenv("HACK_IGNORE_START_ON_FIRST_THREAD") != NULL) return; + // XXX: END HACK + + sameThread = JNI_TRUE; + // Set a variable that tells us we started on the main thread. + // This is used by the AWT during startup. (See awt.m) + char envVar[80]; + snprintf(envVar, sizeof(envVar), "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid()); + setenv(envVar, "1", 1); +} + +// MacOSX we may continue in the same thread +int +JVMInit(InvocationFunctions* ifn, jlong threadStackSize, + int argc, char **argv, + int mode, char *what, int ret) { + if (sameThread) { + JLI_TraceLauncher("In same thread\n"); + // need to block this thread against the main thread + // so signals get caught correctly + __block int rslt; + dispatch_sync(dispatch_get_main_queue(), ^(void) { + JavaMainArgs args; + args.argc = argc; + args.argv = argv; + args.mode = mode; + args.what = what; + args.ifn = *ifn; + rslt = JavaMain((void*)&args); + }); + return rslt; + } else { + return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret); + } +} + +/* + * Note the jvmInstance must be initialized first before entering into + * ShowSplashScreen, as there is a callback into the JLI_GetJavaVMInstance. + */ +void PostJVMInit(JNIEnv *env, jstring mainClass, JavaVM *vm) { + jvmInstance = vm; + SetMainClassForAWT(env, mainClass); + ShowSplashScreen(); +} + +jboolean +ProcessPlatformOption(const char* arg) +{ + if (JLI_StrCmp(arg, "-XstartOnFirstThread") == 0) { + SetXStartOnFirstThreadArg(); + return JNI_TRUE; + } else if (JLI_StrCCmp(arg, "-Xdock:") == 0) { + SetXDockArgForAWT(arg); + return JNI_TRUE; + } + // arguments we know not + return JNI_FALSE; +}