1 /* 2 * Copyright (c) 2012, 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 #include "java.h" 27 #include "jvm_md.h" 28 #include <dirent.h> 29 #include <dlfcn.h> 30 #include <fcntl.h> 31 #include <inttypes.h> 32 #include <stdio.h> 33 #include <string.h> 34 #include <stdlib.h> 35 #include <sys/stat.h> 36 #include <unistd.h> 37 #include <sys/types.h> 38 #include <sys/time.h> 39 40 #include "manifest_info.h" 41 42 /* Support Cocoa event loop on the main thread */ 43 #include <Cocoa/Cocoa.h> 44 #include <objc/objc-runtime.h> 45 #include <objc/objc-auto.h> 46 47 #include <errno.h> 48 #include <spawn.h> 49 50 struct NSAppArgs { 51 int argc; 52 char **argv; 53 }; 54 55 #define JVM_DLL "libjvm.dylib" 56 #define JAVA_DLL "libjava.dylib" 57 /* FALLBACK avoids naming conflicts with system libraries 58 * (eg, ImageIO's libJPEG.dylib) */ 59 #define LD_LIBRARY_PATH "DYLD_FALLBACK_LIBRARY_PATH" 60 61 /* 62 * If a processor / os combination has the ability to run binaries of 63 * two data models and cohabitation of jre/jdk bits with both data 64 * models is supported, then DUAL_MODE is defined. MacOSX is a hybrid 65 * system in that, the universal library can contain all types of libraries 66 * 32/64 and client/server, thus the spawn is capable of linking with the 67 * appropriate library as requested. 68 * 69 * Notes: 70 * 1. VM. DUAL_MODE is disabled, and not supported, however, it is left here in 71 * for experimentation and perhaps enable it in the future. 72 * 2. At the time of this writing, the universal library contains only 73 * a server 64-bit server JVM. 74 * 3. "-client" command line option is supported merely as a command line flag, 75 * for, compatibility reasons, however, a server VM will be launched. 76 */ 77 78 /* 79 * Flowchart of launcher execs and options processing on unix 80 * 81 * The selection of the proper vm shared library to open depends on 82 * several classes of command line options, including vm "flavor" 83 * options (-client, -server) and the data model options, -d32 and 84 * -d64, as well as a version specification which may have come from 85 * the command line or from the manifest of an executable jar file. 86 * The vm selection options are not passed to the running 87 * virtual machine; they must be screened out by the launcher. 88 * 89 * The version specification (if any) is processed first by the 90 * platform independent routine SelectVersion. This may result in 91 * the exec of the specified launcher version. 92 * 93 * Now, in most cases,the launcher will dlopen the target libjvm.so. All 94 * required libraries are loaded by the runtime linker, using the known paths 95 * baked into the shared libraries at compile time. Therefore, 96 * in most cases, the launcher will only exec, if the data models are 97 * mismatched, and will not set any environment variables, regardless of the 98 * data models. 99 * 100 * 101 * 102 * Main 103 * (incoming argv) 104 * | 105 * \|/ 106 * CreateExecutionEnvironment 107 * (determines desired data model) 108 * | 109 * | 110 * \|/ 111 * Have Desired Model ? --> NO --> Is Dual-Mode ? --> NO --> Exit(with error) 112 * | | 113 * | | 114 * | \|/ 115 * | YES 116 * | | 117 * | | 118 * | \|/ 119 * | CheckJvmType 120 * | (removes -client, -server etc.) 121 * | | 122 * | | 123 * \|/ \|/ 124 * YES Find the desired executable/library 125 * | | 126 * | | 127 * \|/ \|/ 128 * CheckJvmType POINT A 129 * (removes -client, -server, etc.) 130 * | 131 * | 132 * \|/ 133 * TranslateDashJArgs... 134 * (Prepare to pass args to vm) 135 * | 136 * | 137 * \|/ 138 * ParseArguments 139 * (processes version options, 140 * creates argument list for vm, 141 * etc.) 142 * | 143 * | 144 * \|/ 145 * POINT A 146 * | 147 * | 148 * \|/ 149 * Path is desired JRE ? YES --> Continue 150 * NO 151 * | 152 * | 153 * \|/ 154 * Paths have well known 155 * jvm paths ? --> NO --> Continue 156 * YES 157 * | 158 * | 159 * \|/ 160 * Does libjvm.so exist 161 * in any of them ? --> NO --> Continue 162 * YES 163 * | 164 * | 165 * \|/ 166 * Re-exec / Spawn 167 * | 168 * | 169 * \|/ 170 * Main 171 */ 172 173 /* Store the name of the executable once computed */ 174 static char *execname = NULL; 175 176 /* 177 * execname accessor from other parts of platform dependent logic 178 */ 179 const char * 180 GetExecName() { 181 return execname; 182 } 183 184 /* 185 * Exports the JNI interface from libjli 186 * 187 * This allows client code to link against the .jre/.jdk bundles, 188 * and not worry about trying to pick a HotSpot to link against. 189 * 190 * Switching architectures is unsupported, since client code has 191 * made that choice before the JVM was requested. 192 */ 193 194 static InvocationFunctions *sExportedJNIFunctions = NULL; 195 static char *sPreferredJVMType = NULL; 196 197 static InvocationFunctions *GetExportedJNIFunctions() { 198 if (sExportedJNIFunctions != NULL) return sExportedJNIFunctions; 199 200 char jrePath[PATH_MAX]; 201 jboolean gotJREPath = GetJREPath(jrePath, sizeof(jrePath), JNI_FALSE); 202 if (!gotJREPath) { 203 JLI_ReportErrorMessage("Failed to GetJREPath()"); 204 return NULL; 205 } 206 207 char *preferredJVM = sPreferredJVMType; 208 if (preferredJVM == NULL) { 209 #if defined(__i386__) 210 preferredJVM = "client"; 211 #elif defined(__x86_64__) 212 preferredJVM = "server"; 213 #else 214 #error "Unknown architecture - needs definition" 215 #endif 216 } 217 218 char jvmPath[PATH_MAX]; 219 jboolean gotJVMPath = GetJVMPath(jrePath, preferredJVM, jvmPath, sizeof(jvmPath)); 220 if (!gotJVMPath) { 221 JLI_ReportErrorMessage("Failed to GetJVMPath()"); 222 return NULL; 223 } 224 225 InvocationFunctions *fxns = malloc(sizeof(InvocationFunctions)); 226 jboolean vmLoaded = LoadJavaVM(jvmPath, fxns); 227 if (!vmLoaded) { 228 JLI_ReportErrorMessage("Failed to LoadJavaVM()"); 229 return NULL; 230 } 231 232 return sExportedJNIFunctions = fxns; 233 } 234 235 #ifndef STATIC_BUILD 236 237 JNIEXPORT jint JNICALL 238 JNI_GetDefaultJavaVMInitArgs(void *args) { 239 InvocationFunctions *ifn = GetExportedJNIFunctions(); 240 if (ifn == NULL) return JNI_ERR; 241 return ifn->GetDefaultJavaVMInitArgs(args); 242 } 243 244 JNIEXPORT jint JNICALL 245 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args) { 246 InvocationFunctions *ifn = GetExportedJNIFunctions(); 247 if (ifn == NULL) return JNI_ERR; 248 return ifn->CreateJavaVM(pvm, penv, args); 249 } 250 251 JNIEXPORT jint JNICALL 252 JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs) { 253 InvocationFunctions *ifn = GetExportedJNIFunctions(); 254 if (ifn == NULL) return JNI_ERR; 255 return ifn->GetCreatedJavaVMs(vmBuf, bufLen, nVMs); 256 } 257 #endif 258 259 /* 260 * Allow JLI-aware launchers to specify a client/server preference 261 */ 262 JNIEXPORT void JNICALL 263 JLI_SetPreferredJVM(const char *prefJVM) { 264 if (sPreferredJVMType != NULL) { 265 free(sPreferredJVMType); 266 sPreferredJVMType = NULL; 267 } 268 269 if (prefJVM == NULL) return; 270 sPreferredJVMType = strdup(prefJVM); 271 } 272 273 static BOOL awtLoaded = NO; 274 static pthread_mutex_t awtLoaded_mutex = PTHREAD_MUTEX_INITIALIZER; 275 static pthread_cond_t awtLoaded_cv = PTHREAD_COND_INITIALIZER; 276 277 JNIEXPORT void JNICALL 278 JLI_NotifyAWTLoaded() 279 { 280 pthread_mutex_lock(&awtLoaded_mutex); 281 awtLoaded = YES; 282 pthread_cond_signal(&awtLoaded_cv); 283 pthread_mutex_unlock(&awtLoaded_mutex); 284 } 285 286 static int (*main_fptr)(int argc, char **argv) = NULL; 287 288 /* 289 * Unwrap the arguments and re-run main() 290 */ 291 static void *apple_main (void *arg) 292 { 293 if (main_fptr == NULL) { 294 #ifdef STATIC_BUILD 295 extern int main(int argc, char **argv); 296 main_fptr = &main; 297 #else 298 main_fptr = (int (*)())dlsym(RTLD_DEFAULT, "main"); 299 #endif 300 if (main_fptr == NULL) { 301 JLI_ReportErrorMessageSys("error locating main entrypoint\n"); 302 exit(1); 303 } 304 } 305 306 struct NSAppArgs *args = (struct NSAppArgs *) arg; 307 exit(main_fptr(args->argc, args->argv)); 308 } 309 310 static void dummyTimer(CFRunLoopTimerRef timer, void *info) {} 311 312 static void ParkEventLoop() { 313 // RunLoop needs at least one source, and 1e20 is pretty far into the future 314 CFRunLoopTimerRef t = CFRunLoopTimerCreate(kCFAllocatorDefault, 1.0e20, 0.0, 0, 0, dummyTimer, NULL); 315 CFRunLoopAddTimer(CFRunLoopGetCurrent(), t, kCFRunLoopDefaultMode); 316 CFRelease(t); 317 318 // Park this thread in the main run loop. 319 int32_t result; 320 do { 321 result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e20, false); 322 } while (result != kCFRunLoopRunFinished); 323 } 324 325 /* 326 * Mac OS X mandates that the GUI event loop run on very first thread of 327 * an application. This requires that we re-call Java's main() on a new 328 * thread, reserving the 'main' thread for Cocoa. 329 */ 330 static void MacOSXStartup(int argc, char *argv[]) { 331 // Thread already started? 332 static jboolean started = false; 333 if (started) { 334 return; 335 } 336 started = true; 337 338 // Hand off arguments 339 struct NSAppArgs args; 340 args.argc = argc; 341 args.argv = argv; 342 343 // Fire up the main thread 344 pthread_t main_thr; 345 if (pthread_create(&main_thr, NULL, &apple_main, &args) != 0) { 346 JLI_ReportErrorMessageSys("Could not create main thread: %s\n", strerror(errno)); 347 exit(1); 348 } 349 if (pthread_detach(main_thr)) { 350 JLI_ReportErrorMessageSys("pthread_detach() failed: %s\n", strerror(errno)); 351 exit(1); 352 } 353 354 ParkEventLoop(); 355 } 356 357 void 358 CreateExecutionEnvironment(int *pargc, char ***pargv, 359 char jrepath[], jint so_jrepath, 360 char jvmpath[], jint so_jvmpath, 361 char jvmcfg[], jint so_jvmcfg) { 362 jboolean jvmpathExists; 363 364 /* Compute/set the name of the executable */ 365 SetExecname(*pargv); 366 367 char * jvmtype = NULL; 368 int argc = *pargc; 369 char **argv = *pargv; 370 371 /* Find out where the JRE is that we will be using. */ 372 if (!GetJREPath(jrepath, so_jrepath, JNI_FALSE) ) { 373 JLI_ReportErrorMessage(JRE_ERROR1); 374 exit(2); 375 } 376 JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%sjvm.cfg", 377 jrepath, FILESEP, FILESEP); 378 /* Find the specified JVM type */ 379 if (ReadKnownVMs(jvmcfg, JNI_FALSE) < 1) { 380 JLI_ReportErrorMessage(CFG_ERROR7); 381 exit(1); 382 } 383 384 jvmpath[0] = '\0'; 385 jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE); 386 if (JLI_StrCmp(jvmtype, "ERROR") == 0) { 387 JLI_ReportErrorMessage(CFG_ERROR9); 388 exit(4); 389 } 390 391 if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath)) { 392 JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath); 393 exit(4); 394 } 395 396 /* 397 * Mac OS X requires the Cocoa event loop to be run on the "main" 398 * thread. Spawn off a new thread to run main() and pass 399 * this thread off to the Cocoa event loop. 400 */ 401 MacOSXStartup(argc, argv); 402 403 /* 404 * we seem to have everything we need 405 */ 406 return; 407 } 408 409 /* 410 * VM choosing is done by the launcher (java.c). 411 */ 412 static jboolean 413 GetJVMPath(const char *jrepath, const char *jvmtype, 414 char *jvmpath, jint jvmpathsize) 415 { 416 struct stat s; 417 418 if (JLI_StrChr(jvmtype, '/')) { 419 JLI_Snprintf(jvmpath, jvmpathsize, "%s/" JVM_DLL, jvmtype); 420 } else { 421 /* 422 * macosx client library is built thin, i386 only. 423 * 64 bit client requests must load server library 424 */ 425 JLI_Snprintf(jvmpath, jvmpathsize, "%s/lib/%s/" JVM_DLL, jrepath, jvmtype); 426 } 427 428 JLI_TraceLauncher("Does `%s' exist ... ", jvmpath); 429 430 #ifdef STATIC_BUILD 431 return JNI_TRUE; 432 #else 433 if (stat(jvmpath, &s) == 0) { 434 JLI_TraceLauncher("yes.\n"); 435 return JNI_TRUE; 436 } else { 437 JLI_TraceLauncher("no.\n"); 438 return JNI_FALSE; 439 } 440 #endif 441 } 442 443 /* 444 * Find path to JRE based on .exe's location or registry settings. 445 */ 446 static jboolean 447 GetJREPath(char *path, jint pathsize, jboolean speculative) 448 { 449 char libjava[MAXPATHLEN]; 450 451 if (GetApplicationHome(path, pathsize)) { 452 /* Is JRE co-located with the application? */ 453 #ifdef STATIC_BUILD 454 char jvm_cfg[MAXPATHLEN]; 455 JLI_Snprintf(jvm_cfg, sizeof(jvm_cfg), "%s/lib/jvm.cfg", path); 456 if (access(jvm_cfg, F_OK) == 0) { 457 return JNI_TRUE; 458 } 459 #else 460 JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/" JAVA_DLL, path); 461 if (access(libjava, F_OK) == 0) { 462 return JNI_TRUE; 463 } 464 #endif 465 /* ensure storage for path + /jre + NULL */ 466 if ((JLI_StrLen(path) + 4 + 1) > (size_t) pathsize) { 467 JLI_TraceLauncher("Insufficient space to store JRE path\n"); 468 return JNI_FALSE; 469 } 470 /* Does the app ship a private JRE in <apphome>/jre directory? */ 471 JLI_Snprintf(libjava, sizeof(libjava), "%s/jre/lib/" JAVA_DLL, path); 472 if (access(libjava, F_OK) == 0) { 473 JLI_StrCat(path, "/jre"); 474 JLI_TraceLauncher("JRE path is %s\n", path); 475 return JNI_TRUE; 476 } 477 } 478 479 /* try to find ourselves instead */ 480 Dl_info selfInfo; 481 dladdr(&GetJREPath, &selfInfo); 482 483 #ifdef STATIC_BUILD 484 char jvm_cfg[MAXPATHLEN]; 485 char *p = NULL; 486 strncpy(jvm_cfg, selfInfo.dli_fname, MAXPATHLEN); 487 p = strrchr(jvm_cfg, '/'); *p = '\0'; 488 p = strrchr(jvm_cfg, '/'); 489 if (strcmp(p, "/.") == 0) { 490 *p = '\0'; 491 p = strrchr(jvm_cfg, '/'); *p = '\0'; 492 } 493 else *p = '\0'; 494 strncpy(path, jvm_cfg, pathsize); 495 strncat(jvm_cfg, "/lib/jvm.cfg", MAXPATHLEN); 496 if (access(jvm_cfg, F_OK) == 0) { 497 return JNI_TRUE; 498 } 499 #endif 500 501 char *realPathToSelf = realpath(selfInfo.dli_fname, path); 502 if (realPathToSelf != path) { 503 return JNI_FALSE; 504 } 505 506 size_t pathLen = strlen(realPathToSelf); 507 if (pathLen == 0) { 508 return JNI_FALSE; 509 } 510 511 const char lastPathComponent[] = "/lib/libjli.dylib"; 512 size_t sizeOfLastPathComponent = sizeof(lastPathComponent) - 1; 513 if (pathLen < sizeOfLastPathComponent) { 514 return JNI_FALSE; 515 } 516 517 size_t indexOfLastPathComponent = pathLen - sizeOfLastPathComponent; 518 if (0 == strncmp(realPathToSelf + indexOfLastPathComponent, lastPathComponent, sizeOfLastPathComponent)) { 519 realPathToSelf[indexOfLastPathComponent + 1] = '\0'; 520 return JNI_TRUE; 521 } 522 523 // If libjli.dylib is loaded from a macos bundle MacOS dir, find the JRE dir 524 // in ../Home. 525 const char altLastPathComponent[] = "/MacOS/libjli.dylib"; 526 size_t sizeOfAltLastPathComponent = sizeof(altLastPathComponent) - 1; 527 if (pathLen < sizeOfLastPathComponent) { 528 return JNI_FALSE; 529 } 530 531 size_t indexOfAltLastPathComponent = pathLen - sizeOfAltLastPathComponent; 532 if (0 == strncmp(realPathToSelf + indexOfAltLastPathComponent, altLastPathComponent, sizeOfAltLastPathComponent)) { 533 JLI_Snprintf(realPathToSelf + indexOfAltLastPathComponent, sizeOfAltLastPathComponent, "%s", "/Home"); 534 if (access(realPathToSelf, F_OK) == 0) { 535 return JNI_TRUE; 536 } 537 } 538 539 if (!speculative) 540 JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL); 541 return JNI_FALSE; 542 } 543 544 jboolean 545 LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn) 546 { 547 Dl_info dlinfo; 548 void *libjvm; 549 550 JLI_TraceLauncher("JVM path is %s\n", jvmpath); 551 552 #ifndef STATIC_BUILD 553 libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL); 554 #else 555 libjvm = dlopen(NULL, RTLD_FIRST); 556 #endif 557 if (libjvm == NULL) { 558 JLI_ReportErrorMessage(DLL_ERROR1, __LINE__); 559 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 560 return JNI_FALSE; 561 } 562 563 ifn->CreateJavaVM = (CreateJavaVM_t) 564 dlsym(libjvm, "JNI_CreateJavaVM"); 565 if (ifn->CreateJavaVM == NULL) { 566 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 567 return JNI_FALSE; 568 } 569 570 ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t) 571 dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs"); 572 if (ifn->GetDefaultJavaVMInitArgs == NULL) { 573 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 574 return JNI_FALSE; 575 } 576 577 ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t) 578 dlsym(libjvm, "JNI_GetCreatedJavaVMs"); 579 if (ifn->GetCreatedJavaVMs == NULL) { 580 JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); 581 return JNI_FALSE; 582 } 583 584 return JNI_TRUE; 585 } 586 587 /* 588 * Compute the name of the executable 589 * 590 * In order to re-exec securely we need the absolute path of the 591 * executable. On Solaris getexecname(3c) may not return an absolute 592 * path so we use dladdr to get the filename of the executable and 593 * then use realpath to derive an absolute path. From Solaris 9 594 * onwards the filename returned in DL_info structure from dladdr is 595 * an absolute pathname so technically realpath isn't required. 596 * On Linux we read the executable name from /proc/self/exe. 597 * As a fallback, and for platforms other than Solaris and Linux, 598 * we use FindExecName to compute the executable name. 599 */ 600 const char* 601 SetExecname(char **argv) 602 { 603 char* exec_path = NULL; 604 { 605 Dl_info dlinfo; 606 607 #ifdef STATIC_BUILD 608 void *fptr; 609 fptr = (void *)&SetExecname; 610 #else 611 int (*fptr)(); 612 fptr = (int (*)())dlsym(RTLD_DEFAULT, "main"); 613 #endif 614 if (fptr == NULL) { 615 JLI_ReportErrorMessage(DLL_ERROR3, dlerror()); 616 return JNI_FALSE; 617 } 618 619 if (dladdr((void*)fptr, &dlinfo)) { 620 char *resolved = (char*)JLI_MemAlloc(PATH_MAX+1); 621 if (resolved != NULL) { 622 exec_path = realpath(dlinfo.dli_fname, resolved); 623 if (exec_path == NULL) { 624 JLI_MemFree(resolved); 625 } 626 } 627 } 628 } 629 if (exec_path == NULL) { 630 exec_path = FindExecName(argv[0]); 631 } 632 execname = exec_path; 633 return exec_path; 634 } 635 636 /* 637 * BSD's implementation of CounterGet() 638 */ 639 int64_t 640 CounterGet() 641 { 642 struct timeval tv; 643 gettimeofday(&tv, NULL); 644 return (tv.tv_sec * 1000) + tv.tv_usec; 645 } 646 647 648 /* --- Splash Screen shared library support --- */ 649 650 static JavaVM* SetJavaVMValue() 651 { 652 JavaVM * jvm = NULL; 653 654 // The handle is good for both the launcher and the libosxapp.dylib 655 void * handle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL); 656 if (handle) { 657 typedef JavaVM* (*JLI_GetJavaVMInstance_t)(); 658 659 JLI_GetJavaVMInstance_t JLI_GetJavaVMInstance = 660 (JLI_GetJavaVMInstance_t)dlsym(handle, 661 "JLI_GetJavaVMInstance"); 662 if (JLI_GetJavaVMInstance) { 663 jvm = JLI_GetJavaVMInstance(); 664 } 665 666 if (jvm) { 667 typedef void (*OSXAPP_SetJavaVM_t)(JavaVM*); 668 669 OSXAPP_SetJavaVM_t OSXAPP_SetJavaVM = 670 (OSXAPP_SetJavaVM_t)dlsym(handle, "OSXAPP_SetJavaVM"); 671 if (OSXAPP_SetJavaVM) { 672 OSXAPP_SetJavaVM(jvm); 673 } else { 674 jvm = NULL; 675 } 676 } 677 678 dlclose(handle); 679 } 680 681 return jvm; 682 } 683 684 static const char* SPLASHSCREEN_SO = JNI_LIB_NAME("splashscreen"); 685 686 static void* hSplashLib = NULL; 687 688 void* SplashProcAddress(const char* name) { 689 if (!hSplashLib) { 690 char jrePath[PATH_MAX]; 691 if (!GetJREPath(jrePath, sizeof(jrePath), JNI_FALSE)) { 692 JLI_ReportErrorMessage(JRE_ERROR1); 693 return NULL; 694 } 695 696 char splashPath[PATH_MAX]; 697 const int ret = JLI_Snprintf(splashPath, sizeof(splashPath), 698 "%s/lib/%s", jrePath, SPLASHSCREEN_SO); 699 if (ret >= (int)sizeof(splashPath)) { 700 JLI_ReportErrorMessage(JRE_ERROR11); 701 return NULL; 702 } 703 if (ret < 0) { 704 JLI_ReportErrorMessage(JRE_ERROR13); 705 return NULL; 706 } 707 708 hSplashLib = dlopen(splashPath, RTLD_LAZY | RTLD_GLOBAL); 709 // It's OK if dlopen() fails. The splash screen library binary file 710 // might have been stripped out from the JRE image to reduce its size 711 // (e.g. on embedded platforms). 712 713 if (hSplashLib) { 714 if (!SetJavaVMValue()) { 715 dlclose(hSplashLib); 716 hSplashLib = NULL; 717 } 718 } 719 } 720 if (hSplashLib) { 721 void* sym = dlsym(hSplashLib, name); 722 return sym; 723 } else { 724 return NULL; 725 } 726 } 727 728 /* 729 * Signature adapter for pthread_create(). 730 */ 731 static void* ThreadJavaMain(void* args) { 732 return (void*)(intptr_t)JavaMain(args); 733 } 734 735 /* 736 * Block current thread and continue execution in a new thread. 737 */ 738 int 739 CallJavaMainInNewThread(jlong stack_size, void* args) { 740 int rslt; 741 pthread_t tid; 742 pthread_attr_t attr; 743 pthread_attr_init(&attr); 744 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 745 746 if (stack_size > 0) { 747 pthread_attr_setstacksize(&attr, stack_size); 748 } 749 pthread_attr_setguardsize(&attr, 0); // no pthread guard page on java threads 750 751 if (pthread_create(&tid, &attr, ThreadJavaMain, args) == 0) { 752 void* tmp; 753 pthread_join(tid, &tmp); 754 rslt = (int)(intptr_t)tmp; 755 } else { 756 /* 757 * Continue execution in current thread if for some reason (e.g. out of 758 * memory/LWP) a new thread can't be created. This will likely fail 759 * later in JavaMain as JNI_CreateJavaVM needs to create quite a 760 * few new threads, anyway, just give it a try.. 761 */ 762 rslt = JavaMain(args); 763 } 764 765 pthread_attr_destroy(&attr); 766 return rslt; 767 } 768 769 static JavaVM* jvmInstance = NULL; 770 static jboolean sameThread = JNI_FALSE; /* start VM in current thread */ 771 772 /* 773 * Note there is a callback on this function from the splashscreen logic, 774 * this as well SetJavaVMValue() needs to be simplified. 775 */ 776 JNIEXPORT JavaVM* JNICALL 777 JLI_GetJavaVMInstance() 778 { 779 return jvmInstance; 780 } 781 782 void 783 RegisterThread() 784 { 785 // stubbed out for windows and *nixes. 786 } 787 788 static void 789 SetXDockArgForAWT(const char *arg) 790 { 791 char envVar[80]; 792 if (strstr(arg, "-Xdock:name=") == arg) { 793 /* 794 * The APP_NAME_<pid> environment variable is used to pass 795 * an application name as specified with the -Xdock:name command 796 * line option from Java launcher code to the AWT code in order 797 * to assign this name to the app's dock tile on the Mac. 798 * The _<pid> part is added to avoid collisions with child processes. 799 * 800 * WARNING: This environment variable is an implementation detail and 801 * isn't meant for use outside of the core platform. The mechanism for 802 * passing this information from Java launcher to other modules may 803 * change drastically between update release, and it may even be 804 * removed or replaced with another mechanism. 805 * 806 * NOTE: It is used by SWT, and JavaFX. 807 */ 808 snprintf(envVar, sizeof(envVar), "APP_NAME_%d", getpid()); 809 setenv(envVar, (arg + 12), 1); 810 } 811 812 if (strstr(arg, "-Xdock:icon=") == arg) { 813 /* 814 * The APP_ICON_<pid> environment variable is used to pass 815 * an application icon as specified with the -Xdock:icon command 816 * line option from Java launcher code to the AWT code in order 817 * to assign this icon to the app's dock tile on the Mac. 818 * The _<pid> part is added to avoid collisions with child processes. 819 * 820 * WARNING: This environment variable is an implementation detail and 821 * isn't meant for use outside of the core platform. The mechanism for 822 * passing this information from Java launcher to other modules may 823 * change drastically between update release, and it may even be 824 * removed or replaced with another mechanism. 825 * 826 * NOTE: It is used by SWT, and JavaFX. 827 */ 828 snprintf(envVar, sizeof(envVar), "APP_ICON_%d", getpid()); 829 setenv(envVar, (arg + 12), 1); 830 } 831 } 832 833 static void 834 SetMainClassForAWT(JNIEnv *env, jclass mainClass) { 835 jclass classClass = NULL; 836 NULL_CHECK(classClass = FindBootStrapClass(env, "java/lang/Class")); 837 838 jmethodID getCanonicalNameMID = NULL; 839 NULL_CHECK(getCanonicalNameMID = (*env)->GetMethodID(env, classClass, "getCanonicalName", "()Ljava/lang/String;")); 840 841 jstring mainClassString = (*env)->CallObjectMethod(env, mainClass, getCanonicalNameMID); 842 if ((*env)->ExceptionCheck(env)) { 843 /* 844 * Clears all errors caused by getCanonicalName() on the mainclass and 845 * leaves the JAVA_MAIN_CLASS__<pid> empty. 846 */ 847 (*env)->ExceptionClear(env); 848 return; 849 } 850 851 const char *mainClassName = NULL; 852 NULL_CHECK(mainClassName = (*env)->GetStringUTFChars(env, mainClassString, NULL)); 853 854 char envVar[80]; 855 /* 856 * The JAVA_MAIN_CLASS_<pid> environment variable is used to pass 857 * the name of a Java class whose main() method is invoked by 858 * the Java launcher code to start the application, to the AWT code 859 * in order to assign the name to the Apple menu bar when the app 860 * is active on the Mac. 861 * The _<pid> part is added to avoid collisions with child processes. 862 * 863 * WARNING: This environment variable is an implementation detail and 864 * isn't meant for use outside of the core platform. The mechanism for 865 * passing this information from Java launcher to other modules may 866 * change drastically between update release, and it may even be 867 * removed or replaced with another mechanism. 868 * 869 * NOTE: It is used by SWT, and JavaFX. 870 */ 871 snprintf(envVar, sizeof(envVar), "JAVA_MAIN_CLASS_%d", getpid()); 872 setenv(envVar, mainClassName, 1); 873 874 (*env)->ReleaseStringUTFChars(env, mainClassString, mainClassName); 875 } 876 877 void 878 SetXStartOnFirstThreadArg() 879 { 880 // XXX: BEGIN HACK 881 // short circuit hack for <https://bugs.eclipse.org/bugs/show_bug.cgi?id=211625> 882 // need a way to get AWT/Swing apps launched when spawned from Eclipse, 883 // which currently has no UI to not pass the -XstartOnFirstThread option 884 if (getenv("HACK_IGNORE_START_ON_FIRST_THREAD") != NULL) return; 885 // XXX: END HACK 886 887 sameThread = JNI_TRUE; 888 // Set a variable that tells us we started on the main thread. 889 // This is used by the AWT during startup. (See LWCToolkit.m) 890 char envVar[80]; 891 snprintf(envVar, sizeof(envVar), "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid()); 892 setenv(envVar, "1", 1); 893 } 894 895 // MacOSX we may continue in the same thread 896 int 897 JVMInit(InvocationFunctions* ifn, jlong threadStackSize, 898 int argc, char **argv, 899 int mode, char *what, int ret) { 900 if (sameThread) { 901 JLI_TraceLauncher("In same thread\n"); 902 // need to block this thread against the main thread 903 // so signals get caught correctly 904 __block int rslt = 0; 905 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 906 { 907 NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock: ^{ 908 JavaMainArgs args; 909 args.argc = argc; 910 args.argv = argv; 911 args.mode = mode; 912 args.what = what; 913 args.ifn = *ifn; 914 rslt = JavaMain(&args); 915 }]; 916 917 /* 918 * We cannot use dispatch_sync here, because it blocks the main dispatch queue. 919 * Using the main NSRunLoop allows the dispatch queue to run properly once 920 * SWT (or whatever toolkit this is needed for) kicks off it's own NSRunLoop 921 * and starts running. 922 */ 923 [op performSelectorOnMainThread:@selector(start) withObject:nil waitUntilDone:YES]; 924 } 925 [pool drain]; 926 return rslt; 927 } else { 928 return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret); 929 } 930 } 931 932 /* 933 * Note the jvmInstance must be initialized first before entering into 934 * ShowSplashScreen, as there is a callback into the JLI_GetJavaVMInstance. 935 */ 936 void PostJVMInit(JNIEnv *env, jclass mainClass, JavaVM *vm) { 937 jvmInstance = vm; 938 SetMainClassForAWT(env, mainClass); 939 CHECK_EXCEPTION_RETURN(); 940 ShowSplashScreen(); 941 } 942 943 jboolean 944 ProcessPlatformOption(const char* arg) 945 { 946 if (JLI_StrCmp(arg, "-XstartOnFirstThread") == 0) { 947 SetXStartOnFirstThreadArg(); 948 return JNI_TRUE; 949 } else if (JLI_StrCCmp(arg, "-Xdock:") == 0) { 950 SetXDockArgForAWT(arg); 951 return JNI_TRUE; 952 } 953 // arguments we know not 954 return JNI_FALSE; 955 }