jdk-sandbox: comparison jdk/src/solaris/bin/java

equal deleted inserted replaced

-:d7a77bce0742
+:84d85c90d5db
 /*
-* Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1998, 2011, 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
 #endif
 #define JVM_DLL "libjvm.so"
 #define JAVA_DLL "libjava.so"
+/* help jettison the LD_LIBRARY_PATH settings in the future */
+#ifndef SETENV_REQUIRED
+#define SETENV_REQUIRED
+#endif
 /*
 * 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.  When DUAL_MODE is
 * defined, the architecture names for the narrow and wide version of
 * the exec of the specified launcher version.
 *
 * Previously the launcher modified the LD_LIBRARY_PATH appropriately for the
 * desired data model path, regardless if data models matched or not. The
 * launcher subsequently exec'ed the desired executable, in order to make the
-* LD_LIBRARY_PATH path available for the runtime linker. This is no longer the
+* LD_LIBRARY_PATH path available, for the runtime linker.
-* case, the launcher dlopens the target libjvm.so. All other required
+*
-* libraries are loaded by the runtime linker, by virtue of the $ORIGIN paths
+* Now, in most cases,the launcher will dlopen the target libjvm.so. All
-* baked into the shared libraries, by the build infrastructure at compile time.
+* required libraries are loaded by the runtime linker, using the
+* $RPATH/$ORIGIN 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.
+*
+* However, if the environment contains a LD_LIBRARY_PATH, this will cause the
+* launcher to inspect the LD_LIBRARY_PATH. The launcher will check
+*  a. if the LD_LIBRARY_PATH's first component is the the path to the desired
+*     libjvm.so
+*  b. if any other libjvm.so is found in any of the paths.
+* If case b is true, then the launcher will set the LD_LIBRARY_PATH to the
+* desired JRE and reexec, in order to propagate the environment.
 *
 *  Main
 *  (incoming argv)
 *  |
 * \|/
 *  |                                CheckJvmType
 *  |                               (removes -client, -server etc.)
 *  |                                          |
 *  |                                          |
 * \|/                                        \|/
-* YES                              (find the desired executable and exec child)
+* YES                             Find the desired executable/library
 *  |                                          |
 *  |                                          |
 * \|/                                        \|/
-* CheckJvmType                                Main
+* CheckJvmType                          RequiresSetenv
 * (removes -client, -server, etc.)
 *  |
 *  |
 * \|/
 * TranslateDashJArgs...
 * ParseArguments
 * (removes -d32 and -d64 if any,
 *  processes version options,
 *  creates argument list for vm,
 *  etc.)
-*
+*   |
+*   |
+*  \|/
+* RequiresSetenv
+* Is LD_LIBRARY_PATH
+* and friends set ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main
+*  YES                              YES --> Continue
+*   |
+*   |
+*  \|/
+* 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 exit
+*  in any of them ? --> NO --> Have Desired Model ? NO --> Re-exec --> Main
+*   YES                             YES --> Continue
+*   |
+*   |
+*  \|/
+*  Set the LD_LIBRARY_PATH
+*   |
+*   |
+*  \|/
+* Re-exec
+*   |
+*   |
+*  \|/
+* Main
 */
 static const char * SetExecname(char **argv);
 static jboolean GetJVMPath(const char *jrepath, const char *jvmtype,
 char *jvmpath, jint jvmpathsize, const char * arch);
 #endif /* DUAL_MODE */
 default:
 return LIBARCHNAME;
 }
 }
+#ifdef SETENV_REQUIRED
+static jboolean
+JvmExists(const char *path) {
+char tmp[PATH_MAX + 1];
+struct stat statbuf;
+JLI_Snprintf(tmp, PATH_MAX, "%s/%s", path, JVM_DLL);
+if (stat(tmp, &statbuf) == 0) {
+return JNI_TRUE;
+}
+return JNI_FALSE;
+}
+/*
+* contains a lib/$LIBARCH/{server,client}/libjvm.so ?
+*/
+static jboolean
+ContainsLibJVM(int wanted, const char *env) {
+char clientPattern[PATH_MAX + 1];
+char serverPattern[PATH_MAX + 1];
+char *envpath;
+char *path;
+jboolean clientPatternFound;
+jboolean serverPatternFound;
+/* fastest path */
+if (env == NULL) {
+return JNI_FALSE;
+}
+/* the usual suspects */
+JLI_Snprintf(clientPattern, PATH_MAX, "lib/%s/client", GetArchPath(wanted));
+JLI_Snprintf(serverPattern, PATH_MAX, "lib/%s/server", GetArchPath(wanted));
+/* to optimize for time, test if any of our usual suspects are present. */
+clientPatternFound = JLI_StrStr(env, clientPattern) != NULL;
+serverPatternFound = JLI_StrStr(env, serverPattern) != NULL;
+if (clientPatternFound == JNI_FALSE && serverPatternFound == JNI_FALSE) {
+return JNI_FALSE;
+}
+/*
+* we have a suspicious path component, check if it contains a libjvm.so
+*/
+envpath = JLI_StringDup(env);
+for (path = JLI_StrTok(envpath, ":"); path != NULL; path = JLI_StrTok(NULL, ":")) {
+if (clientPatternFound && JLI_StrStr(path, clientPattern) != NULL) {
+if (JvmExists(path)) {
+JLI_MemFree(envpath);
+return JNI_TRUE;
+}
+}
+if (serverPatternFound && JLI_StrStr(path, serverPattern)  != NULL) {
+if (JvmExists(path)) {
+JLI_MemFree(envpath);
+return JNI_TRUE;
+}
+}
+}
+JLI_MemFree(envpath);
+return JNI_FALSE;
+}
+/*
+* Test whether the environment variable needs to be set, see flowchart.
+*/
+static jboolean
+RequiresSetenv(int wanted, const char *jvmpath) {
+char jpath[PATH_MAX + 1];
+char *llp;
+char *dmllp = NULL;
+char *p; /* a utility pointer */
+llp = getenv("LD_LIBRARY_PATH");
+#ifdef __solaris__
+dmllp = (CURRENT_DATA_MODEL == 32)
+? getenv("LD_LIBRARY_PATH_32")
+: getenv("LD_LIBRARY_PATH_64");
+#endif /* __solaris__ */
+/* no environment variable is a good environment variable */
+if (llp == NULL && dmllp == NULL) {
+return JNI_FALSE;
+}
+#ifdef __linux
+/*
+* On linux, if a binary is running as sgid or suid, glibc sets
+* LD_LIBRARY_PATH to the empty string for security purposes. (In contrast,
+* on Solaris the LD_LIBRARY_PATH variable for a privileged binary does not
+* lose its settings; but the dynamic linker does apply more scrutiny to the
+* path.) The launcher uses the value of LD_LIBRARY_PATH to prevent an exec
+* loop, here and further downstream. Therefore, if we are running sgid or
+* suid, this function's setting of LD_LIBRARY_PATH will be ineffective and
+* we should case a return from the calling function.  Getting the right
+* libraries will be handled by the RPATH. In reality, this check is
+* redundant, as the previous check for a non-null LD_LIBRARY_PATH will
+* return back to the calling function forthwith, it is left here to safe
+* guard against any changes, in the glibc's existing security policy.
+*/
+if ((getgid() != getegid()) || (getuid() != geteuid())) {
+return JNI_FALSE;
+}
+#endif /* __linux */
+/*
+* Prevent recursions. Since LD_LIBRARY_PATH is the one which will be set by
+* previous versions of the JRE, thus it is the only path that matters here.
+* So we check to see if the desired JRE is set.
+*/
+JLI_StrNCpy(jpath, jvmpath, PATH_MAX);
+p = JLI_StrRChr(jpath, '/');
+*p = '\0';
+if (llp != NULL && JLI_StrNCmp(llp, jpath, JLI_StrLen(jpath)) == 0) {
+return JNI_FALSE;
+}
+/* scrutinize all the paths further */
+if (llp != NULL &&  ContainsLibJVM(wanted, llp)) {
+return JNI_TRUE;
+}
+if (dmllp != NULL && ContainsLibJVM(wanted, dmllp)) {
+return JNI_TRUE;
+}
+return JNI_FALSE;
+}
+#endif /* SETENV_REQUIRED */
 void
 CreateExecutionEnvironment(int *pargc, char ***pargv,
 char jrepath[], jint so_jrepath,
 char jvmpath[], jint so_jvmpath) {
 * 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);
 {
 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 */
+#ifdef SETENV_REQUIRED
+jboolean mustsetenv = JNI_FALSE;
+char *runpath     = NULL; /* existing effective LD_LIBRARY_PATH setting */
+char* new_runpath = NULL; /* desired new LD_LIBRARY_PATH string */
+char* newpath     = NULL; /* path on new LD_LIBRARY_PATH */
+char* lastslash   = NULL;
+char** newenvp    = NULL; /* current environment */
+#ifdef __solaris__
+char*  dmpath     = NULL;  /* data model specific LD_LIBRARY_PATH,
+Solaris only */
+#endif /* __solaris__ */
+#endif  /* SETENV_REQUIRED */
 char** newargv    = NULL;
 int    newargc    = 0;
 /*
 JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath);
 exit(4);
 }
 /*
 * we seem to have everything we need, so without further ado
-* we return back.
+* we return back, otherwise proceed to set the environment.
 */
+#ifdef SETENV_REQUIRED
+mustsetenv = RequiresSetenv(wanted, jvmpath);
+JLI_TraceLauncher("mustsetenv: %s\n", mustsetenv ? "TRUE" : "FALSE");
+if (mustsetenv == JNI_FALSE) {
+return;
+}
+#else
 return;
+#endif /* SETENV_REQUIRED */
 } else {  /* do the same speculatively or exit */
 #ifdef 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)) {
 exit(4);
 }
 /* exec child can do error checking on the existence of the path */
 jvmpathExists = GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, GetArchPath(wanted));
+#ifdef SETENV_REQUIRED
+mustsetenv = RequiresSetenv(wanted, jvmpath);
+#endif /* SETENV_REQUIRED */
 }
 #else
 JLI_ReportErrorMessage(JRE_ERROR2, wanted);
 exit(1);
 #endif
 }
+#ifdef SETENV_REQUIRED
-{
+if (mustsetenv) {
-char *newexec = execname;
+/*
+* We will set the LD_LIBRARY_PATH as follows:
+*
+*     o          $JVMPATH (directory portion only)
+*     o          $JRE/lib/$LIBARCHNAME
+*     o          $JRE/../lib/$LIBARCHNAME
+*
+* followed by the user's previous effective LD_LIBRARY_PATH, if
+* any.
+*/
+#ifdef __solaris__
+/*
+* Starting in Solaris 7, ld.so.1 supports three LD_LIBRARY_PATH
+* variables:
+*
+* 1. LD_LIBRARY_PATH -- used for 32 and 64 bit searches if
+* data-model specific variables are not set.
+*
+* 2. LD_LIBRARY_PATH_64 -- overrides and replaces LD_LIBRARY_PATH
+* for 64-bit binaries.
+*
+* 3. LD_LIBRARY_PATH_32 -- overrides and replaces LD_LIBRARY_PATH
+* for 32-bit binaries.
+*
+* The vm uses LD_LIBRARY_PATH to set the java.library.path system
+* property.  To shield the vm from the complication of multiple
+* LD_LIBRARY_PATH variables, if the appropriate data model
+* specific variable is set, we will act as if LD_LIBRARY_PATH had
+* the value of the data model specific variant and the data model
+* specific variant will be unset.  Note that the variable for the
+* *wanted* data model must be used (if it is set), not simply the
+* current running data model.
+*/
+switch (wanted) {
+case 0:
+if (running == 32) {
+dmpath = getenv("LD_LIBRARY_PATH_32");
+wanted = 32;
+} else {
+dmpath = getenv("LD_LIBRARY_PATH_64");
+wanted = 64;
+}
+break;
+case 32:
+dmpath = getenv("LD_LIBRARY_PATH_32");
+break;
+case 64:
+dmpath = getenv("LD_LIBRARY_PATH_64");
+break;
+default:
+JLI_ReportErrorMessage(JRE_ERROR3, __LINE__);
+exit(1); /* unknown value in wanted */
+break;
+}
+/*
+* If dmpath is NULL, the relevant data model specific variable is
+* not set and normal LD_LIBRARY_PATH should be used.
+*/
+if (dmpath == NULL) {
+runpath = getenv("LD_LIBRARY_PATH");
+} else {
+runpath = dmpath;
+}
+#else
+/*
+* If not on Solaris, assume only a single LD_LIBRARY_PATH
+* variable.
+*/
+runpath = getenv("LD_LIBRARY_PATH");
+#endif /* __solaris__ */
+/* runpath contains current effective LD_LIBRARY_PATH setting */
+jvmpath = JLI_StringDup(jvmpath);
+new_runpath = JLI_MemAlloc(((runpath != NULL) ? JLI_StrLen(runpath) : 0) +
+2 * JLI_StrLen(jrepath) + 2 * JLI_StrLen(arch) +
+JLI_StrLen(jvmpath) + 52);
+newpath = new_runpath + JLI_StrLen("LD_LIBRARY_PATH=");
+/*
+* Create desired LD_LIBRARY_PATH value for target data model.
+*/
+{
+/* remove the name of the .so from the JVM path */
+lastslash = JLI_StrRChr(jvmpath, '/');
+if (lastslash)
+*lastslash = '\0';
+sprintf(new_runpath, "LD_LIBRARY_PATH="
+"%s:"
+"%s/lib/%s:"
+"%s/../lib/%s",
+jvmpath,
 #ifdef DUAL_MODE
-/*
+jrepath, GetArchPath(wanted),
-* If the data model is being changed, the path to the
+jrepath, GetArchPath(wanted)
-* executable must be updated accordingly; the executable name
+#else
-* and directory the executable resides in are separate.  In the
+jrepath, arch,
-* case of 32 => 64, the new bits are assumed to reside in, e.g.
+jrepath, arch
-* "olddir/LIBARCH64NAME/execname"; in the case of 64 => 32,
-* the bits are assumed to be in "olddir/../execname".  For example,
-*
-* olddir/sparcv9/execname
-* olddir/amd64/execname
-*
-* for Solaris SPARC and Linux amd64, respectively.
-*/
-if (running != wanted) {
-char *oldexec = JLI_StrCpy(JLI_MemAlloc(JLI_StrLen(execname) + 1), execname);
-char *olddir = oldexec;
-char *oldbase = JLI_StrRChr(oldexec, '/');
-newexec = JLI_MemAlloc(JLI_StrLen(execname) + 20);
-*oldbase++ = 0;
-sprintf(newexec, "%s/%s/%s", olddir,
-((wanted==64) ? LIBARCH64NAME : ".."), oldbase);
-argv[0] = newexec;
-}
 #endif
-JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n");
+);
-(void)fflush(stdout);
-(void)fflush(stderr);
-execv(newexec, argv);
+/*
-JLI_ReportErrorMessageSys(JRE_ERROR4, newexec);
+* Check to make sure that the prefix of the current path is the
+* desired environment variable setting, though the RequiresSetenv
+* checks if the desired runpath exists, this logic does a more
+* comprehensive check.
+*/
+if (runpath != NULL &&
+JLI_StrNCmp(newpath, runpath, JLI_StrLen(newpath)) == 0 &&
+(runpath[JLI_StrLen(newpath)] == 0 || runpath[JLI_StrLen(newpath)] == ':') &&
+(running == wanted) /* data model does not have to be changed */
+#ifdef __solaris__
+&& (dmpath == NULL) /* data model specific variables not set  */
+#endif
+) {
+return;
+}
+}
+/*
+* Place the desired environment setting onto the prefix of
+* LD_LIBRARY_PATH.  Note that this prevents any possible infinite
+* loop of execv() because we test for the prefix, above.
+*/
+if (runpath != 0) {
+JLI_StrCat(new_runpath, ":");
+JLI_StrCat(new_runpath, runpath);
+}
+if (putenv(new_runpath) != 0) {
+exit(1); /* problem allocating memory; LD_LIBRARY_PATH not set
+properly */
+}
+/*
+* Unix systems document that they look at LD_LIBRARY_PATH only
+* once at startup, so we have to re-exec the current executable
+* to get the changed environment variable to have an effect.
+*/
+#ifdef __solaris__
+/*
+* If dmpath is not NULL, remove the data model specific string
+* in the environment for the exec'ed child.
+*/
+if (dmpath != NULL)
+(void)UnsetEnv((wanted == 32) ? "LD_LIBRARY_PATH_32" : "LD_LIBRARY_PATH_64");
+#endif
+newenvp = environ;
+}
+#endif /* SETENV_REQUIRED */
+{
+char *newexec = execname;
 #ifdef DUAL_MODE
-if (running != wanted) {
+/*
-JLI_ReportErrorMessage(JRE_ERROR5, wanted, running);
+* If the data model is being changed, the path to the
-#  ifdef __solaris__
+* executable must be updated accordingly; the executable name
-#    ifdef __sparc
+* and directory the executable resides in are separate.  In the
-JLI_ReportErrorMessage(JRE_ERROR6);
+* case of 32 => 64, the new bits are assumed to reside in, e.g.
-#    else
+* "olddir/LIBARCH64NAME/execname"; in the case of 64 => 32,
-JLI_ReportErrorMessage(JRE_ERROR7);
+* the bits are assumed to be in "olddir/../execname".  For example,
-#    endif
+*
-}
+* olddir/sparcv9/execname
-#  endif
+* olddir/amd64/execname
-#endif
+*
+* for Solaris SPARC and Linux amd64, respectively.
-}
+*/
-exit(1);
-}
+if (running != wanted) {
+char *oldexec = JLI_StrCpy(JLI_MemAlloc(JLI_StrLen(execname) + 1), execname);
+char *olddir = oldexec;
+char *oldbase = JLI_StrRChr(oldexec, '/');
+newexec = JLI_MemAlloc(JLI_StrLen(execname) + 20);
+*oldbase++ = 0;
+sprintf(newexec, "%s/%s/%s", olddir,
+((wanted == 64) ? LIBARCH64NAME : ".."), oldbase);
+argv[0] = newexec;
+}
+#endif /* DUAL_MODE */
+JLI_TraceLauncher("TRACER_MARKER:About to EXEC\n");
+(void) fflush(stdout);
+(void) fflush(stderr);
+#ifdef SETENV_REQUIRED
+if (mustsetenv) {
+execve(newexec, argv, newenvp);
+} else {
+execv(newexec, argv);
+}
+#else
+execv(newexec, argv);
+#endif /* SETENV_REQUIRED */
+JLI_ReportErrorMessageSys(JRE_ERROR4, newexec);
+#ifdef DUAL_MODE
+if (running != wanted) {
+JLI_ReportErrorMessage(JRE_ERROR5, wanted, running);
+#ifdef __solaris__
+#ifdef __sparc
+JLI_ReportErrorMessage(JRE_ERROR6);
+#else
+JLI_ReportErrorMessage(JRE_ERROR7);
+#endif  /* __sparc */
+}
+#endif /* __solaris__ */
+#endif /* DUAL_MODE */
+}
+exit(1);
+}
 }
 /*
 * On Solaris VM choosing is done by the launcher (java.c).
 */

changeset 9244	84d85c90d5db
parent 7028	adadd244f506
child 10706	9bd5de10aaf9