author | jwilhelm |
Thu, 08 Dec 2016 16:40:15 +0100 | |
changeset 42755 | 902841117c87 |
parent 41966 | bac52fa6e617 |
parent 42753 | 40f61533b93d |
child 45062 | 37ed4313c8c1 |
child 46846 | 292be53258b7 |
permissions | -rw-r--r-- |
12047 | 1 |
/* |
41966 | 2 |
* Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved. |
12047 | 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 |
* (removes -d32 and -d64 if any, |
|
140 |
* processes version options, |
|
141 |
* creates argument list for vm, |
|
142 |
* etc.) |
|
143 |
* | |
|
144 |
* | |
|
145 |
* \|/ |
|
146 |
* POINT A |
|
147 |
* | |
|
148 |
* | |
|
149 |
* \|/ |
|
150 |
* Path is desired JRE ? YES --> Have Desired Model ? NO --> Re-exec --> Main |
|
151 |
* NO YES --> Continue |
|
152 |
* | |
|
153 |
* | |
|
154 |
* \|/ |
|
155 |
* Paths have well known |
|
156 |
* jvm paths ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main |
|
157 |
* YES YES --> Continue |
|
158 |
* | |
|
159 |
* | |
|
160 |
* \|/ |
|
161 |
* Does libjvm.so exist |
|
162 |
* in any of them ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main |
|
163 |
* YES YES --> Continue |
|
164 |
* | |
|
165 |
* | |
|
166 |
* \|/ |
|
167 |
* Re-exec / Spawn |
|
168 |
* | |
|
169 |
* | |
|
170 |
* \|/ |
|
171 |
* Main |
|
172 |
*/ |
|
173 |
||
174 |
/* Store the name of the executable once computed */ |
|
175 |
static char *execname = NULL; |
|
176 |
||
177 |
/* |
|
178 |
* execname accessor from other parts of platform dependent logic |
|
179 |
*/ |
|
180 |
const char * |
|
181 |
GetExecName() { |
|
182 |
return execname; |
|
183 |
} |
|
184 |
||
185 |
/* |
|
186 |
* Exports the JNI interface from libjli |
|
187 |
* |
|
188 |
* This allows client code to link against the .jre/.jdk bundles, |
|
189 |
* and not worry about trying to pick a HotSpot to link against. |
|
190 |
* |
|
191 |
* Switching architectures is unsupported, since client code has |
|
192 |
* made that choice before the JVM was requested. |
|
193 |
*/ |
|
194 |
||
195 |
static InvocationFunctions *sExportedJNIFunctions = NULL; |
|
196 |
static char *sPreferredJVMType = NULL; |
|
197 |
||
198 |
static InvocationFunctions *GetExportedJNIFunctions() { |
|
199 |
if (sExportedJNIFunctions != NULL) return sExportedJNIFunctions; |
|
200 |
||
201 |
char jrePath[PATH_MAX]; |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
202 |
jboolean gotJREPath = GetJREPath(jrePath, sizeof(jrePath), JNI_FALSE); |
12047 | 203 |
if (!gotJREPath) { |
204 |
JLI_ReportErrorMessage("Failed to GetJREPath()"); |
|
205 |
return NULL; |
|
206 |
} |
|
207 |
||
208 |
char *preferredJVM = sPreferredJVMType; |
|
209 |
if (preferredJVM == NULL) { |
|
210 |
#if defined(__i386__) |
|
211 |
preferredJVM = "client"; |
|
212 |
#elif defined(__x86_64__) |
|
213 |
preferredJVM = "server"; |
|
214 |
#else |
|
215 |
#error "Unknown architecture - needs definition" |
|
216 |
#endif |
|
217 |
} |
|
218 |
||
219 |
char jvmPath[PATH_MAX]; |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
220 |
jboolean gotJVMPath = GetJVMPath(jrePath, preferredJVM, jvmPath, sizeof(jvmPath), CURRENT_DATA_MODEL); |
12047 | 221 |
if (!gotJVMPath) { |
222 |
JLI_ReportErrorMessage("Failed to GetJVMPath()"); |
|
223 |
return NULL; |
|
224 |
} |
|
225 |
||
226 |
InvocationFunctions *fxns = malloc(sizeof(InvocationFunctions)); |
|
227 |
jboolean vmLoaded = LoadJavaVM(jvmPath, fxns); |
|
228 |
if (!vmLoaded) { |
|
229 |
JLI_ReportErrorMessage("Failed to LoadJavaVM()"); |
|
230 |
return NULL; |
|
231 |
} |
|
232 |
||
233 |
return sExportedJNIFunctions = fxns; |
|
234 |
} |
|
235 |
||
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
236 |
#ifndef STATIC_BUILD |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
237 |
|
12047 | 238 |
JNIEXPORT jint JNICALL |
239 |
JNI_GetDefaultJavaVMInitArgs(void *args) { |
|
240 |
InvocationFunctions *ifn = GetExportedJNIFunctions(); |
|
241 |
if (ifn == NULL) return JNI_ERR; |
|
242 |
return ifn->GetDefaultJavaVMInitArgs(args); |
|
243 |
} |
|
244 |
||
245 |
JNIEXPORT jint JNICALL |
|
246 |
JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args) { |
|
247 |
InvocationFunctions *ifn = GetExportedJNIFunctions(); |
|
248 |
if (ifn == NULL) return JNI_ERR; |
|
249 |
return ifn->CreateJavaVM(pvm, penv, args); |
|
250 |
} |
|
251 |
||
252 |
JNIEXPORT jint JNICALL |
|
253 |
JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs) { |
|
254 |
InvocationFunctions *ifn = GetExportedJNIFunctions(); |
|
255 |
if (ifn == NULL) return JNI_ERR; |
|
256 |
return ifn->GetCreatedJavaVMs(vmBuf, bufLen, nVMs); |
|
257 |
} |
|
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
258 |
#endif |
12047 | 259 |
|
260 |
/* |
|
261 |
* Allow JLI-aware launchers to specify a client/server preference |
|
262 |
*/ |
|
263 |
JNIEXPORT void JNICALL |
|
264 |
JLI_SetPreferredJVM(const char *prefJVM) { |
|
265 |
if (sPreferredJVMType != NULL) { |
|
266 |
free(sPreferredJVMType); |
|
267 |
sPreferredJVMType = NULL; |
|
268 |
} |
|
269 |
||
270 |
if (prefJVM == NULL) return; |
|
271 |
sPreferredJVMType = strdup(prefJVM); |
|
272 |
} |
|
273 |
||
274 |
static BOOL awtLoaded = NO; |
|
275 |
static pthread_mutex_t awtLoaded_mutex = PTHREAD_MUTEX_INITIALIZER; |
|
276 |
static pthread_cond_t awtLoaded_cv = PTHREAD_COND_INITIALIZER; |
|
277 |
||
278 |
JNIEXPORT void JNICALL |
|
279 |
JLI_NotifyAWTLoaded() |
|
280 |
{ |
|
281 |
pthread_mutex_lock(&awtLoaded_mutex); |
|
282 |
awtLoaded = YES; |
|
283 |
pthread_cond_signal(&awtLoaded_cv); |
|
284 |
pthread_mutex_unlock(&awtLoaded_mutex); |
|
285 |
} |
|
286 |
||
287 |
static int (*main_fptr)(int argc, char **argv) = NULL; |
|
288 |
||
289 |
/* |
|
290 |
* Unwrap the arguments and re-run main() |
|
291 |
*/ |
|
292 |
static void *apple_main (void *arg) |
|
293 |
{ |
|
294 |
objc_registerThreadWithCollector(); |
|
295 |
||
296 |
if (main_fptr == NULL) { |
|
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
297 |
#ifdef STATIC_BUILD |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
298 |
extern int main(int argc, char **argv); |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
299 |
main_fptr = &main; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
300 |
#else |
12047 | 301 |
main_fptr = (int (*)())dlsym(RTLD_DEFAULT, "main"); |
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
302 |
#endif |
12047 | 303 |
if (main_fptr == NULL) { |
304 |
JLI_ReportErrorMessageSys("error locating main entrypoint\n"); |
|
305 |
exit(1); |
|
306 |
} |
|
307 |
} |
|
308 |
||
309 |
struct NSAppArgs *args = (struct NSAppArgs *) arg; |
|
310 |
exit(main_fptr(args->argc, args->argv)); |
|
311 |
} |
|
312 |
||
313 |
static void dummyTimer(CFRunLoopTimerRef timer, void *info) {} |
|
314 |
||
315 |
static void ParkEventLoop() { |
|
316 |
// RunLoop needs at least one source, and 1e20 is pretty far into the future |
|
317 |
CFRunLoopTimerRef t = CFRunLoopTimerCreate(kCFAllocatorDefault, 1.0e20, 0.0, 0, 0, dummyTimer, NULL); |
|
318 |
CFRunLoopAddTimer(CFRunLoopGetCurrent(), t, kCFRunLoopDefaultMode); |
|
319 |
CFRelease(t); |
|
320 |
||
321 |
// Park this thread in the main run loop. |
|
322 |
int32_t result; |
|
323 |
do { |
|
324 |
result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e20, false); |
|
325 |
} while (result != kCFRunLoopRunFinished); |
|
326 |
} |
|
327 |
||
328 |
/* |
|
329 |
* Mac OS X mandates that the GUI event loop run on very first thread of |
|
330 |
* an application. This requires that we re-call Java's main() on a new |
|
331 |
* thread, reserving the 'main' thread for Cocoa. |
|
332 |
*/ |
|
333 |
static void MacOSXStartup(int argc, char *argv[]) { |
|
334 |
// Thread already started? |
|
335 |
static jboolean started = false; |
|
336 |
if (started) { |
|
337 |
return; |
|
338 |
} |
|
339 |
started = true; |
|
340 |
||
341 |
// Hand off arguments |
|
342 |
struct NSAppArgs args; |
|
343 |
args.argc = argc; |
|
344 |
args.argv = argv; |
|
345 |
||
346 |
// Fire up the main thread |
|
347 |
pthread_t main_thr; |
|
348 |
if (pthread_create(&main_thr, NULL, &apple_main, &args) != 0) { |
|
349 |
JLI_ReportErrorMessageSys("Could not create main thread: %s\n", strerror(errno)); |
|
350 |
exit(1); |
|
351 |
} |
|
352 |
if (pthread_detach(main_thr)) { |
|
353 |
JLI_ReportErrorMessageSys("pthread_detach() failed: %s\n", strerror(errno)); |
|
354 |
exit(1); |
|
355 |
} |
|
356 |
||
357 |
ParkEventLoop(); |
|
358 |
} |
|
359 |
||
360 |
void |
|
361 |
CreateExecutionEnvironment(int *pargc, char ***pargv, |
|
362 |
char jrepath[], jint so_jrepath, |
|
363 |
char jvmpath[], jint so_jvmpath, |
|
364 |
char jvmcfg[], jint so_jvmcfg) { |
|
365 |
/* |
|
366 |
* First, determine if we are running the desired data model. If we |
|
367 |
* are running the desired data model, all the error messages |
|
368 |
* associated with calling GetJREPath, ReadKnownVMs, etc. should be |
|
369 |
* output. However, if we are not running the desired data model, |
|
370 |
* some of the errors should be suppressed since it is more |
|
371 |
* informative to issue an error message based on whether or not the |
|
372 |
* os/processor combination has dual mode capabilities. |
|
373 |
*/ |
|
374 |
jboolean jvmpathExists; |
|
375 |
||
376 |
/* Compute/set the name of the executable */ |
|
377 |
SetExecname(*pargv); |
|
378 |
||
379 |
/* Check data model flags, and exec process, if needed */ |
|
380 |
{ |
|
381 |
char * jvmtype = NULL; |
|
382 |
int argc = *pargc; |
|
383 |
char **argv = *pargv; |
|
384 |
int running = CURRENT_DATA_MODEL; |
|
385 |
||
386 |
int wanted = running; /* What data mode is being |
|
387 |
asked for? Current model is |
|
388 |
fine unless another model |
|
389 |
is asked for */ |
|
390 |
||
391 |
char** newargv = NULL; |
|
392 |
int newargc = 0; |
|
393 |
||
394 |
/* |
|
395 |
* Starting in 1.5, all unix platforms accept the -d32 and -d64 |
|
396 |
* options. On platforms where only one data-model is supported |
|
397 |
* (e.g. ia-64 Linux), using the flag for the other data model is |
|
398 |
* an error and will terminate the program. |
|
399 |
*/ |
|
400 |
||
401 |
{ /* open new scope to declare local variables */ |
|
402 |
int i; |
|
403 |
||
404 |
newargv = (char **)JLI_MemAlloc((argc+1) * sizeof(char*)); |
|
405 |
newargv[newargc++] = argv[0]; |
|
406 |
||
407 |
/* scan for data model arguments and remove from argument list; |
|
408 |
last occurrence determines desired data model */ |
|
409 |
for (i=1; i < argc; i++) { |
|
410 |
||
411 |
if (JLI_StrCmp(argv[i], "-J-d64") == 0 || JLI_StrCmp(argv[i], "-d64") == 0) { |
|
412 |
wanted = 64; |
|
413 |
continue; |
|
414 |
} |
|
415 |
if (JLI_StrCmp(argv[i], "-J-d32") == 0 || JLI_StrCmp(argv[i], "-d32") == 0) { |
|
416 |
wanted = 32; |
|
417 |
continue; |
|
418 |
} |
|
419 |
newargv[newargc++] = argv[i]; |
|
420 |
||
421 |
if (IsJavaArgs()) { |
|
422 |
if (argv[i][0] != '-') continue; |
|
423 |
} else { |
|
424 |
if (JLI_StrCmp(argv[i], "-classpath") == 0 || JLI_StrCmp(argv[i], "-cp") == 0) { |
|
425 |
i++; |
|
426 |
if (i >= argc) break; |
|
427 |
newargv[newargc++] = argv[i]; |
|
428 |
continue; |
|
429 |
} |
|
430 |
if (argv[i][0] != '-') { i++; break; } |
|
431 |
} |
|
432 |
} |
|
433 |
||
434 |
/* copy rest of args [i .. argc) */ |
|
435 |
while (i < argc) { |
|
436 |
newargv[newargc++] = argv[i++]; |
|
437 |
} |
|
438 |
newargv[newargc] = NULL; |
|
439 |
||
440 |
/* |
|
441 |
* newargv has all proper arguments here |
|
442 |
*/ |
|
443 |
||
444 |
argc = newargc; |
|
445 |
argv = newargv; |
|
446 |
} |
|
447 |
||
448 |
/* If the data model is not changing, it is an error if the |
|
449 |
jvmpath does not exist */ |
|
450 |
if (wanted == running) { |
|
451 |
/* Find out where the JRE is that we will be using. */ |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
452 |
if (!GetJREPath(jrepath, so_jrepath, JNI_FALSE) ) { |
12047 | 453 |
JLI_ReportErrorMessage(JRE_ERROR1); |
454 |
exit(2); |
|
455 |
} |
|
456 |
JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%s%sjvm.cfg", |
|
457 |
jrepath, FILESEP, FILESEP, "", ""); |
|
458 |
/* Find the specified JVM type */ |
|
459 |
if (ReadKnownVMs(jvmcfg, JNI_FALSE) < 1) { |
|
460 |
JLI_ReportErrorMessage(CFG_ERROR7); |
|
461 |
exit(1); |
|
462 |
} |
|
463 |
||
464 |
jvmpath[0] = '\0'; |
|
465 |
jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE); |
|
466 |
if (JLI_StrCmp(jvmtype, "ERROR") == 0) { |
|
467 |
JLI_ReportErrorMessage(CFG_ERROR9); |
|
468 |
exit(4); |
|
469 |
} |
|
470 |
||
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
471 |
if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, wanted)) { |
12047 | 472 |
JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath); |
473 |
exit(4); |
|
474 |
} |
|
475 |
||
476 |
/* |
|
477 |
* Mac OS X requires the Cocoa event loop to be run on the "main" |
|
478 |
* thread. Spawn off a new thread to run main() and pass |
|
479 |
* this thread off to the Cocoa event loop. |
|
480 |
*/ |
|
481 |
MacOSXStartup(argc, argv); |
|
482 |
||
483 |
/* |
|
484 |
* we seem to have everything we need, so without further ado |
|
485 |
* we return back, otherwise proceed to set the environment. |
|
486 |
*/ |
|
487 |
return; |
|
488 |
} else { /* do the same speculatively or exit */ |
|
489 |
#if defined(DUAL_MODE) |
|
490 |
if (running != wanted) { |
|
491 |
/* Find out where the JRE is that we will be using. */ |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
492 |
if (!GetJREPath(jrepath, so_jrepath, JNI_TRUE)) { |
12047 | 493 |
/* give up and let other code report error message */ |
494 |
JLI_ReportErrorMessage(JRE_ERROR2, wanted); |
|
495 |
exit(1); |
|
496 |
} |
|
497 |
JLI_Snprintf(jvmcfg, so_jvmcfg, "%s%slib%s%s%sjvm.cfg", |
|
498 |
jrepath, FILESEP, FILESEP, "", ""); |
|
499 |
/* |
|
500 |
* Read in jvm.cfg for target data model and process vm |
|
501 |
* selection options. |
|
502 |
*/ |
|
503 |
if (ReadKnownVMs(jvmcfg, JNI_TRUE) < 1) { |
|
504 |
/* give up and let other code report error message */ |
|
505 |
JLI_ReportErrorMessage(JRE_ERROR2, wanted); |
|
506 |
exit(1); |
|
507 |
} |
|
508 |
jvmpath[0] = '\0'; |
|
509 |
jvmtype = CheckJvmType(pargc, pargv, JNI_TRUE); |
|
510 |
if (JLI_StrCmp(jvmtype, "ERROR") == 0) { |
|
511 |
JLI_ReportErrorMessage(CFG_ERROR9); |
|
512 |
exit(4); |
|
513 |
} |
|
514 |
||
515 |
/* exec child can do error checking on the existence of the path */ |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
516 |
jvmpathExists = GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, wanted); |
12047 | 517 |
} |
518 |
#else /* ! DUAL_MODE */ |
|
519 |
JLI_ReportErrorMessage(JRE_ERROR2, wanted); |
|
520 |
exit(1); |
|
521 |
#endif /* DUAL_MODE */ |
|
522 |
} |
|
523 |
{ |
|
524 |
char *newexec = execname; |
|
525 |
JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n"); |
|
526 |
(void) fflush(stdout); |
|
527 |
(void) fflush(stderr); |
|
528 |
/* |
|
529 |
* Use posix_spawn() instead of execv() on Mac OS X. |
|
530 |
* This allows us to choose which architecture the child process |
|
531 |
* should run as. |
|
532 |
*/ |
|
533 |
{ |
|
534 |
posix_spawnattr_t attr; |
|
535 |
size_t unused_size; |
|
536 |
pid_t unused_pid; |
|
537 |
||
538 |
#if defined(__i386__) || defined(__x86_64__) |
|
539 |
cpu_type_t cpu_type[] = { (wanted == 64) ? CPU_TYPE_X86_64 : CPU_TYPE_X86, |
|
540 |
(running== 64) ? CPU_TYPE_X86_64 : CPU_TYPE_X86 }; |
|
541 |
#else |
|
542 |
cpu_type_t cpu_type[] = { CPU_TYPE_ANY }; |
|
543 |
#endif /* __i386 .. */ |
|
544 |
||
545 |
posix_spawnattr_init(&attr); |
|
546 |
posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETEXEC); |
|
547 |
posix_spawnattr_setbinpref_np(&attr, sizeof(cpu_type) / sizeof(cpu_type_t), |
|
548 |
cpu_type, &unused_size); |
|
549 |
||
550 |
posix_spawn(&unused_pid, newexec, NULL, &attr, argv, environ); |
|
551 |
} |
|
552 |
JLI_ReportErrorMessageSys(JRE_ERROR4, newexec); |
|
553 |
||
554 |
#if defined(DUAL_MODE) |
|
555 |
if (running != wanted) { |
|
556 |
JLI_ReportErrorMessage(JRE_ERROR5, wanted, running); |
|
557 |
} |
|
558 |
#endif /* DUAL_MODE */ |
|
559 |
} |
|
560 |
exit(1); |
|
561 |
} |
|
562 |
} |
|
563 |
||
564 |
/* |
|
565 |
* VM choosing is done by the launcher (java.c). |
|
566 |
*/ |
|
567 |
static jboolean |
|
568 |
GetJVMPath(const char *jrepath, const char *jvmtype, |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
569 |
char *jvmpath, jint jvmpathsize, int bitsWanted) |
12047 | 570 |
{ |
571 |
struct stat s; |
|
572 |
||
573 |
if (JLI_StrChr(jvmtype, '/')) { |
|
574 |
JLI_Snprintf(jvmpath, jvmpathsize, "%s/" JVM_DLL, jvmtype); |
|
575 |
} else { |
|
576 |
/* |
|
577 |
* macosx client library is built thin, i386 only. |
|
578 |
* 64 bit client requests must load server library |
|
579 |
*/ |
|
580 |
const char *jvmtypeUsed = ((bitsWanted == 64) && (strcmp(jvmtype, "client") == 0)) ? "server" : jvmtype; |
|
581 |
JLI_Snprintf(jvmpath, jvmpathsize, "%s/lib/%s/" JVM_DLL, jrepath, jvmtypeUsed); |
|
582 |
} |
|
583 |
||
584 |
JLI_TraceLauncher("Does `%s' exist ... ", jvmpath); |
|
585 |
||
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
586 |
#ifdef STATIC_BUILD |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
587 |
return JNI_TRUE; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
588 |
#else |
12047 | 589 |
if (stat(jvmpath, &s) == 0) { |
590 |
JLI_TraceLauncher("yes.\n"); |
|
591 |
return JNI_TRUE; |
|
592 |
} else { |
|
593 |
JLI_TraceLauncher("no.\n"); |
|
594 |
return JNI_FALSE; |
|
595 |
} |
|
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
596 |
#endif |
12047 | 597 |
} |
598 |
||
599 |
/* |
|
600 |
* Find path to JRE based on .exe's location or registry settings. |
|
601 |
*/ |
|
602 |
static jboolean |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
603 |
GetJREPath(char *path, jint pathsize, jboolean speculative) |
12047 | 604 |
{ |
605 |
char libjava[MAXPATHLEN]; |
|
606 |
||
607 |
if (GetApplicationHome(path, pathsize)) { |
|
608 |
/* Is JRE co-located with the application? */ |
|
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
609 |
#ifdef STATIC_BUILD |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
610 |
char jvm_cfg[MAXPATHLEN]; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
611 |
JLI_Snprintf(jvm_cfg, sizeof(jvm_cfg), "%s/lib/jvm.cfg", path); |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
612 |
if (access(jvm_cfg, F_OK) == 0) { |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
613 |
return JNI_TRUE; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
614 |
} |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
615 |
#else |
12047 | 616 |
JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/" JAVA_DLL, path); |
617 |
if (access(libjava, F_OK) == 0) { |
|
618 |
return JNI_TRUE; |
|
619 |
} |
|
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
620 |
#endif |
31690 | 621 |
/* ensure storage for path + /jre + NULL */ |
622 |
if ((JLI_StrLen(path) + 4 + 1) > (size_t) pathsize) { |
|
623 |
JLI_TraceLauncher("Insufficient space to store JRE path\n"); |
|
624 |
return JNI_FALSE; |
|
625 |
} |
|
12047 | 626 |
/* Does the app ship a private JRE in <apphome>/jre directory? */ |
627 |
JLI_Snprintf(libjava, sizeof(libjava), "%s/jre/lib/" JAVA_DLL, path); |
|
628 |
if (access(libjava, F_OK) == 0) { |
|
629 |
JLI_StrCat(path, "/jre"); |
|
630 |
JLI_TraceLauncher("JRE path is %s\n", path); |
|
631 |
return JNI_TRUE; |
|
632 |
} |
|
633 |
} |
|
634 |
||
635 |
/* try to find ourselves instead */ |
|
636 |
Dl_info selfInfo; |
|
637 |
dladdr(&GetJREPath, &selfInfo); |
|
638 |
||
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
639 |
#ifdef STATIC_BUILD |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
640 |
char jvm_cfg[MAXPATHLEN]; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
641 |
char *p = NULL; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
642 |
strncpy(jvm_cfg, selfInfo.dli_fname, MAXPATHLEN); |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
643 |
p = strrchr(jvm_cfg, '/'); *p = '\0'; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
644 |
p = strrchr(jvm_cfg, '/'); |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
645 |
if (strcmp(p, "/.") == 0) { |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
646 |
*p = '\0'; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
647 |
p = strrchr(jvm_cfg, '/'); *p = '\0'; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
648 |
} |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
649 |
else *p = '\0'; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
650 |
strncpy(path, jvm_cfg, pathsize); |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
651 |
strncat(jvm_cfg, "/lib/jvm.cfg", MAXPATHLEN); |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
652 |
if (access(jvm_cfg, F_OK) == 0) { |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
653 |
return JNI_TRUE; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
654 |
} |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
655 |
#endif |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
656 |
|
12047 | 657 |
char *realPathToSelf = realpath(selfInfo.dli_fname, path); |
658 |
if (realPathToSelf != path) { |
|
659 |
return JNI_FALSE; |
|
660 |
} |
|
661 |
||
662 |
size_t pathLen = strlen(realPathToSelf); |
|
663 |
if (pathLen == 0) { |
|
664 |
return JNI_FALSE; |
|
665 |
} |
|
666 |
||
667 |
const char lastPathComponent[] = "/lib/jli/libjli.dylib"; |
|
668 |
size_t sizeOfLastPathComponent = sizeof(lastPathComponent) - 1; |
|
669 |
if (pathLen < sizeOfLastPathComponent) { |
|
670 |
return JNI_FALSE; |
|
671 |
} |
|
672 |
||
673 |
size_t indexOfLastPathComponent = pathLen - sizeOfLastPathComponent; |
|
674 |
if (0 == strncmp(realPathToSelf + indexOfLastPathComponent, lastPathComponent, sizeOfLastPathComponent - 1)) { |
|
675 |
realPathToSelf[indexOfLastPathComponent + 1] = '\0'; |
|
676 |
return JNI_TRUE; |
|
677 |
} |
|
678 |
||
679 |
if (!speculative) |
|
680 |
JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL); |
|
681 |
return JNI_FALSE; |
|
682 |
} |
|
683 |
||
684 |
jboolean |
|
685 |
LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn) |
|
686 |
{ |
|
687 |
Dl_info dlinfo; |
|
688 |
void *libjvm; |
|
689 |
||
690 |
JLI_TraceLauncher("JVM path is %s\n", jvmpath); |
|
691 |
||
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
692 |
#ifndef STATIC_BUILD |
12047 | 693 |
libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL); |
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
694 |
#else |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
695 |
libjvm = dlopen(NULL, RTLD_FIRST); |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
696 |
#endif |
12047 | 697 |
if (libjvm == NULL) { |
698 |
JLI_ReportErrorMessage(DLL_ERROR1, __LINE__); |
|
699 |
JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); |
|
700 |
return JNI_FALSE; |
|
701 |
} |
|
702 |
||
703 |
ifn->CreateJavaVM = (CreateJavaVM_t) |
|
704 |
dlsym(libjvm, "JNI_CreateJavaVM"); |
|
705 |
if (ifn->CreateJavaVM == NULL) { |
|
706 |
JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); |
|
707 |
return JNI_FALSE; |
|
708 |
} |
|
709 |
||
710 |
ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t) |
|
711 |
dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs"); |
|
712 |
if (ifn->GetDefaultJavaVMInitArgs == NULL) { |
|
713 |
JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); |
|
714 |
return JNI_FALSE; |
|
715 |
} |
|
716 |
||
717 |
ifn->GetCreatedJavaVMs = (GetCreatedJavaVMs_t) |
|
718 |
dlsym(libjvm, "JNI_GetCreatedJavaVMs"); |
|
719 |
if (ifn->GetCreatedJavaVMs == NULL) { |
|
720 |
JLI_ReportErrorMessage(DLL_ERROR2, jvmpath, dlerror()); |
|
721 |
return JNI_FALSE; |
|
722 |
} |
|
723 |
||
724 |
return JNI_TRUE; |
|
725 |
} |
|
726 |
||
727 |
/* |
|
728 |
* Compute the name of the executable |
|
729 |
* |
|
730 |
* In order to re-exec securely we need the absolute path of the |
|
731 |
* executable. On Solaris getexecname(3c) may not return an absolute |
|
732 |
* path so we use dladdr to get the filename of the executable and |
|
733 |
* then use realpath to derive an absolute path. From Solaris 9 |
|
734 |
* onwards the filename returned in DL_info structure from dladdr is |
|
735 |
* an absolute pathname so technically realpath isn't required. |
|
736 |
* On Linux we read the executable name from /proc/self/exe. |
|
737 |
* As a fallback, and for platforms other than Solaris and Linux, |
|
738 |
* we use FindExecName to compute the executable name. |
|
739 |
*/ |
|
740 |
const char* |
|
741 |
SetExecname(char **argv) |
|
742 |
{ |
|
743 |
char* exec_path = NULL; |
|
744 |
{ |
|
745 |
Dl_info dlinfo; |
|
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
746 |
|
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
747 |
#ifdef STATIC_BUILD |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
748 |
void *fptr; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
749 |
fptr = (void *)&SetExecname; |
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
750 |
#else |
12047 | 751 |
int (*fptr)(); |
752 |
fptr = (int (*)())dlsym(RTLD_DEFAULT, "main"); |
|
33653
c1ee09fe3274
8136556: Add the ability to perform static builds of MacOSX x64 binaries
bobv
parents:
31690
diff
changeset
|
753 |
#endif |
12047 | 754 |
if (fptr == NULL) { |
755 |
JLI_ReportErrorMessage(DLL_ERROR3, dlerror()); |
|
756 |
return JNI_FALSE; |
|
757 |
} |
|
758 |
||
759 |
if (dladdr((void*)fptr, &dlinfo)) { |
|
760 |
char *resolved = (char*)JLI_MemAlloc(PATH_MAX+1); |
|
761 |
if (resolved != NULL) { |
|
762 |
exec_path = realpath(dlinfo.dli_fname, resolved); |
|
763 |
if (exec_path == NULL) { |
|
764 |
JLI_MemFree(resolved); |
|
765 |
} |
|
766 |
} |
|
767 |
} |
|
768 |
} |
|
769 |
if (exec_path == NULL) { |
|
770 |
exec_path = FindExecName(argv[0]); |
|
771 |
} |
|
772 |
execname = exec_path; |
|
773 |
return exec_path; |
|
774 |
} |
|
775 |
||
776 |
/* |
|
777 |
* BSD's implementation of CounterGet() |
|
778 |
*/ |
|
779 |
int64_t |
|
780 |
CounterGet() |
|
781 |
{ |
|
782 |
struct timeval tv; |
|
783 |
gettimeofday(&tv, NULL); |
|
784 |
return (tv.tv_sec * 1000) + tv.tv_usec; |
|
785 |
} |
|
786 |
||
787 |
||
788 |
/* --- Splash Screen shared library support --- */ |
|
789 |
||
790 |
static JavaVM* SetJavaVMValue() |
|
791 |
{ |
|
792 |
JavaVM * jvm = NULL; |
|
793 |
||
794 |
// The handle is good for both the launcher and the libosxapp.dylib |
|
795 |
void * handle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL); |
|
796 |
if (handle) { |
|
797 |
typedef JavaVM* (*JLI_GetJavaVMInstance_t)(); |
|
798 |
||
799 |
JLI_GetJavaVMInstance_t JLI_GetJavaVMInstance = |
|
800 |
(JLI_GetJavaVMInstance_t)dlsym(handle, |
|
801 |
"JLI_GetJavaVMInstance"); |
|
802 |
if (JLI_GetJavaVMInstance) { |
|
803 |
jvm = JLI_GetJavaVMInstance(); |
|
804 |
} |
|
805 |
||
806 |
if (jvm) { |
|
807 |
typedef void (*OSXAPP_SetJavaVM_t)(JavaVM*); |
|
808 |
||
809 |
OSXAPP_SetJavaVM_t OSXAPP_SetJavaVM = |
|
810 |
(OSXAPP_SetJavaVM_t)dlsym(handle, "OSXAPP_SetJavaVM"); |
|
811 |
if (OSXAPP_SetJavaVM) { |
|
812 |
OSXAPP_SetJavaVM(jvm); |
|
813 |
} else { |
|
814 |
jvm = NULL; |
|
815 |
} |
|
816 |
} |
|
817 |
||
818 |
dlclose(handle); |
|
819 |
} |
|
820 |
||
821 |
return jvm; |
|
822 |
} |
|
823 |
||
824 |
static const char* SPLASHSCREEN_SO = JNI_LIB_NAME("splashscreen"); |
|
825 |
||
826 |
static void* hSplashLib = NULL; |
|
827 |
||
828 |
void* SplashProcAddress(const char* name) { |
|
829 |
if (!hSplashLib) { |
|
830 |
char jrePath[PATH_MAX]; |
|
42753
40f61533b93d
8066474: Remove the lib/ directory from Linux and Solaris images
erikj
parents:
39534
diff
changeset
|
831 |
if (!GetJREPath(jrePath, sizeof(jrePath), JNI_FALSE)) { |
12047 | 832 |
JLI_ReportErrorMessage(JRE_ERROR1); |
833 |
return NULL; |
|
834 |
} |
|
835 |
||
836 |
char splashPath[PATH_MAX]; |
|
837 |
const int ret = JLI_Snprintf(splashPath, sizeof(splashPath), |
|
838 |
"%s/lib/%s", jrePath, SPLASHSCREEN_SO); |
|
839 |
if (ret >= (int)sizeof(splashPath)) { |
|
840 |
JLI_ReportErrorMessage(JRE_ERROR11); |
|
841 |
return NULL; |
|
842 |
} |
|
843 |
if (ret < 0) { |
|
844 |
JLI_ReportErrorMessage(JRE_ERROR13); |
|
845 |
return NULL; |
|
846 |
} |
|
847 |
||
848 |
hSplashLib = dlopen(splashPath, RTLD_LAZY | RTLD_GLOBAL); |
|
849 |
// It's OK if dlopen() fails. The splash screen library binary file |
|
850 |
// might have been stripped out from the JRE image to reduce its size |
|
851 |
// (e.g. on embedded platforms). |
|
852 |
||
853 |
if (hSplashLib) { |
|
854 |
if (!SetJavaVMValue()) { |
|
855 |
dlclose(hSplashLib); |
|
856 |
hSplashLib = NULL; |
|
857 |
} |
|
858 |
} |
|
859 |
} |
|
860 |
if (hSplashLib) { |
|
861 |
void* sym = dlsym(hSplashLib, name); |
|
862 |
return sym; |
|
863 |
} else { |
|
864 |
return NULL; |
|
865 |
} |
|
866 |
} |
|
867 |
||
868 |
void SplashFreeLibrary() { |
|
869 |
if (hSplashLib) { |
|
870 |
dlclose(hSplashLib); |
|
871 |
hSplashLib = NULL; |
|
872 |
} |
|
873 |
} |
|
874 |
||
875 |
/* |
|
876 |
* Block current thread and continue execution in a new thread |
|
877 |
*/ |
|
878 |
int |
|
879 |
ContinueInNewThread0(int (JNICALL *continuation)(void *), jlong stack_size, void * args) { |
|
880 |
int rslt; |
|
881 |
pthread_t tid; |
|
882 |
pthread_attr_t attr; |
|
883 |
pthread_attr_init(&attr); |
|
884 |
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); |
|
885 |
||
886 |
if (stack_size > 0) { |
|
887 |
pthread_attr_setstacksize(&attr, stack_size); |
|
888 |
} |
|
889 |
||
890 |
if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) { |
|
891 |
void * tmp; |
|
892 |
pthread_join(tid, &tmp); |
|
29742
b73f38796859
8074840: Resolve disabled warnings for libjli and libjli_static
mikael
parents:
28771
diff
changeset
|
893 |
rslt = (int)(intptr_t)tmp; |
12047 | 894 |
} else { |
895 |
/* |
|
896 |
* Continue execution in current thread if for some reason (e.g. out of |
|
897 |
* memory/LWP) a new thread can't be created. This will likely fail |
|
898 |
* later in continuation as JNI_CreateJavaVM needs to create quite a |
|
899 |
* few new threads, anyway, just give it a try.. |
|
900 |
*/ |
|
901 |
rslt = continuation(args); |
|
902 |
} |
|
903 |
||
904 |
pthread_attr_destroy(&attr); |
|
905 |
return rslt; |
|
906 |
} |
|
907 |
||
908 |
void SetJavaLauncherPlatformProps() { |
|
909 |
/* Linux only */ |
|
910 |
} |
|
911 |
||
912 |
static JavaVM* jvmInstance = NULL; |
|
913 |
static jboolean sameThread = JNI_FALSE; /* start VM in current thread */ |
|
914 |
||
915 |
/* |
|
916 |
* Note there is a callback on this function from the splashscreen logic, |
|
917 |
* this as well SetJavaVMValue() needs to be simplified. |
|
918 |
*/ |
|
919 |
JavaVM* |
|
920 |
JLI_GetJavaVMInstance() |
|
921 |
{ |
|
922 |
return jvmInstance; |
|
923 |
} |
|
924 |
||
925 |
void |
|
926 |
RegisterThread() |
|
927 |
{ |
|
928 |
objc_registerThreadWithCollector(); |
|
929 |
} |
|
930 |
||
931 |
static void |
|
932 |
SetXDockArgForAWT(const char *arg) |
|
933 |
{ |
|
934 |
char envVar[80]; |
|
935 |
if (strstr(arg, "-Xdock:name=") == arg) { |
|
12527
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
936 |
/* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
937 |
* The APP_NAME_<pid> environment variable is used to pass |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
938 |
* an application name as specified with the -Xdock:name command |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
939 |
* line option from Java launcher code to the AWT code in order |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
940 |
* to assign this name to the app's dock tile on the Mac. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
941 |
* The _<pid> part is added to avoid collisions with child processes. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
942 |
* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
943 |
* WARNING: This environment variable is an implementation detail and |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
944 |
* isn't meant for use outside of the core platform. The mechanism for |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
945 |
* passing this information from Java launcher to other modules may |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
946 |
* change drastically between update release, and it may even be |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
947 |
* removed or replaced with another mechanism. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
948 |
* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
949 |
* NOTE: It is used by SWT, and JavaFX. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
950 |
*/ |
12047 | 951 |
snprintf(envVar, sizeof(envVar), "APP_NAME_%d", getpid()); |
952 |
setenv(envVar, (arg + 12), 1); |
|
953 |
} |
|
954 |
||
955 |
if (strstr(arg, "-Xdock:icon=") == arg) { |
|
12527
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
956 |
/* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
957 |
* The APP_ICON_<pid> environment variable is used to pass |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
958 |
* an application icon as specified with the -Xdock:icon command |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
959 |
* line option from Java launcher code to the AWT code in order |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
960 |
* to assign this icon to the app's dock tile on the Mac. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
961 |
* The _<pid> part is added to avoid collisions with child processes. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
962 |
* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
963 |
* WARNING: This environment variable is an implementation detail and |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
964 |
* isn't meant for use outside of the core platform. The mechanism for |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
965 |
* passing this information from Java launcher to other modules may |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
966 |
* change drastically between update release, and it may even be |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
967 |
* removed or replaced with another mechanism. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
968 |
* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
969 |
* NOTE: It is used by SWT, and JavaFX. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
970 |
*/ |
12047 | 971 |
snprintf(envVar, sizeof(envVar), "APP_ICON_%d", getpid()); |
972 |
setenv(envVar, (arg + 12), 1); |
|
973 |
} |
|
974 |
} |
|
975 |
||
976 |
static void |
|
977 |
SetMainClassForAWT(JNIEnv *env, jclass mainClass) { |
|
978 |
jclass classClass = NULL; |
|
979 |
NULL_CHECK(classClass = FindBootStrapClass(env, "java/lang/Class")); |
|
980 |
||
981 |
jmethodID getCanonicalNameMID = NULL; |
|
982 |
NULL_CHECK(getCanonicalNameMID = (*env)->GetMethodID(env, classClass, "getCanonicalName", "()Ljava/lang/String;")); |
|
983 |
||
30467
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
984 |
jstring mainClassString = (*env)->CallObjectMethod(env, mainClass, getCanonicalNameMID); |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
985 |
if ((*env)->ExceptionCheck(env)) { |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
986 |
/* |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
987 |
* Clears all errors caused by getCanonicalName() on the mainclass and |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
988 |
* leaves the JAVA_MAIN_CLASS__<pid> empty. |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
989 |
*/ |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
990 |
(*env)->ExceptionClear(env); |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
991 |
return; |
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
992 |
} |
12047 | 993 |
|
994 |
const char *mainClassName = NULL; |
|
995 |
NULL_CHECK(mainClassName = (*env)->GetStringUTFChars(env, mainClassString, NULL)); |
|
996 |
||
997 |
char envVar[80]; |
|
12527
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
998 |
/* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
999 |
* The JAVA_MAIN_CLASS_<pid> environment variable is used to pass |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1000 |
* the name of a Java class whose main() method is invoked by |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1001 |
* the Java launcher code to start the application, to the AWT code |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1002 |
* in order to assign the name to the Apple menu bar when the app |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1003 |
* is active on the Mac. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1004 |
* The _<pid> part is added to avoid collisions with child processes. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1005 |
* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1006 |
* WARNING: This environment variable is an implementation detail and |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1007 |
* isn't meant for use outside of the core platform. The mechanism for |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1008 |
* passing this information from Java launcher to other modules may |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1009 |
* change drastically between update release, and it may even be |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1010 |
* removed or replaced with another mechanism. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1011 |
* |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1012 |
* NOTE: It is used by SWT, and JavaFX. |
22abaf748b5b
7131021: [macosx] Consider using system properties to pass arguments from the launcher to AWT/SplashScreen
anthony
parents:
12047
diff
changeset
|
1013 |
*/ |
12047 | 1014 |
snprintf(envVar, sizeof(envVar), "JAVA_MAIN_CLASS_%d", getpid()); |
1015 |
setenv(envVar, mainClassName, 1); |
|
1016 |
||
1017 |
(*env)->ReleaseStringUTFChars(env, mainClassString, mainClassName); |
|
1018 |
} |
|
1019 |
||
1020 |
void |
|
1021 |
SetXStartOnFirstThreadArg() |
|
1022 |
{ |
|
1023 |
// XXX: BEGIN HACK |
|
1024 |
// short circuit hack for <https://bugs.eclipse.org/bugs/show_bug.cgi?id=211625> |
|
1025 |
// need a way to get AWT/Swing apps launched when spawned from Eclipse, |
|
1026 |
// which currently has no UI to not pass the -XstartOnFirstThread option |
|
1027 |
if (getenv("HACK_IGNORE_START_ON_FIRST_THREAD") != NULL) return; |
|
1028 |
// XXX: END HACK |
|
1029 |
||
1030 |
sameThread = JNI_TRUE; |
|
1031 |
// Set a variable that tells us we started on the main thread. |
|
25563
248400a88627
8033367: [macosx] Appletviewer was broken in jdk8 b124
pchelko
parents:
23010
diff
changeset
|
1032 |
// This is used by the AWT during startup. (See LWCToolkit.m) |
12047 | 1033 |
char envVar[80]; |
1034 |
snprintf(envVar, sizeof(envVar), "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid()); |
|
1035 |
setenv(envVar, "1", 1); |
|
1036 |
} |
|
1037 |
||
1038 |
// MacOSX we may continue in the same thread |
|
1039 |
int |
|
1040 |
JVMInit(InvocationFunctions* ifn, jlong threadStackSize, |
|
1041 |
int argc, char **argv, |
|
1042 |
int mode, char *what, int ret) { |
|
1043 |
if (sameThread) { |
|
1044 |
JLI_TraceLauncher("In same thread\n"); |
|
1045 |
// need to block this thread against the main thread |
|
1046 |
// so signals get caught correctly |
|
39534
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1047 |
__block int rslt = 0; |
17688
4b8f0d9b9cbc
8009911: [macosx] SWT app freeze when going full screen using Java 7 on Mac
pchelko
parents:
12527
diff
changeset
|
1048 |
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
4b8f0d9b9cbc
8009911: [macosx] SWT app freeze when going full screen using Java 7 on Mac
pchelko
parents:
12527
diff
changeset
|
1049 |
{ |
39534
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1050 |
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock: ^{ |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1051 |
JavaMainArgs args; |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1052 |
args.argc = argc; |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1053 |
args.argv = argv; |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1054 |
args.mode = mode; |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1055 |
args.what = what; |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1056 |
args.ifn = *ifn; |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1057 |
rslt = JavaMain(&args); |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1058 |
}]; |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1059 |
|
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1060 |
/* |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1061 |
* We cannot use dispatch_sync here, because it blocks the main dispatch queue. |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1062 |
* Using the main NSRunLoop allows the dispatch queue to run properly once |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1063 |
* SWT (or whatever toolkit this is needed for) kicks off it's own NSRunLoop |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1064 |
* and starts running. |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1065 |
*/ |
b12e60ec4e0f
8022291: Mac OS: Unexpected JavaLaunchHelper message displaying
ddehaven
parents:
33653
diff
changeset
|
1066 |
[op performSelectorOnMainThread:@selector(start) withObject:nil waitUntilDone:YES]; |
17688
4b8f0d9b9cbc
8009911: [macosx] SWT app freeze when going full screen using Java 7 on Mac
pchelko
parents:
12527
diff
changeset
|
1067 |
} |
4b8f0d9b9cbc
8009911: [macosx] SWT app freeze when going full screen using Java 7 on Mac
pchelko
parents:
12527
diff
changeset
|
1068 |
[pool drain]; |
12047 | 1069 |
return rslt; |
1070 |
} else { |
|
1071 |
return ContinueInNewThread(ifn, threadStackSize, argc, argv, mode, what, ret); |
|
1072 |
} |
|
1073 |
} |
|
1074 |
||
1075 |
/* |
|
1076 |
* Note the jvmInstance must be initialized first before entering into |
|
1077 |
* ShowSplashScreen, as there is a callback into the JLI_GetJavaVMInstance. |
|
1078 |
*/ |
|
30467
075f4f160f19
8076264: [macosx] Launching app on MacOSX requires enclosing class
serb
parents:
29742
diff
changeset
|
1079 |
void PostJVMInit(JNIEnv *env, jclass mainClass, JavaVM *vm) { |
12047 | 1080 |
jvmInstance = vm; |
1081 |
SetMainClassForAWT(env, mainClass); |
|
28771
2885fb2e1002
8068033: JNI exception pending in jdk/src/share/bin/java.c
ksrini
parents:
27938
diff
changeset
|
1082 |
CHECK_EXCEPTION_RETURN(); |
12047 | 1083 |
ShowSplashScreen(); |
1084 |
} |
|
1085 |
||
1086 |
jboolean |
|
1087 |
ProcessPlatformOption(const char* arg) |
|
1088 |
{ |
|
1089 |
if (JLI_StrCmp(arg, "-XstartOnFirstThread") == 0) { |
|
1090 |
SetXStartOnFirstThreadArg(); |
|
1091 |
return JNI_TRUE; |
|
1092 |
} else if (JLI_StrCCmp(arg, "-Xdock:") == 0) { |
|
1093 |
SetXDockArgForAWT(arg); |
|
1094 |
return JNI_TRUE; |
|
1095 |
} |
|
1096 |
// arguments we know not |
|
1097 |
return JNI_FALSE; |
|
1098 |
} |