840 lines
27 KiB
C
840 lines
27 KiB
C
/* Copyright (C) 2021 Free Software Foundation, Inc.
|
|
Contributed by Oracle.
|
|
|
|
This file is part of GNU Binutils.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3, or (at your option)
|
|
any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, 51 Franklin Street - Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
/*
|
|
* Routines for managing the target's environment array
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "descendants.h"
|
|
|
|
#define MAX_LD_PRELOADS 2
|
|
|
|
/* TprintfT(<level>,...) definitions. Adjust per module as needed */
|
|
#define DBG_LT0 0 // for high-level configuration, unexpected errors/warnings
|
|
#define DBG_LT1 1 // for configuration details, warnings
|
|
#define DBG_LT2 2
|
|
#define DBG_LT3 3
|
|
#define DBG_LT4 4
|
|
|
|
/* original environment settings to be saved for later restoration */
|
|
static char *sp_preloads[MAX_LD_PRELOADS];
|
|
static char *sp_libpaths[MAX_LD_PRELOADS];
|
|
char **sp_env_backup;
|
|
|
|
static const char *SP_ENV[];
|
|
static const char *LD_ENV[];
|
|
static const char *SP_PRELOAD[];
|
|
static const char *LD_PRELOAD[];
|
|
static const char *SP_LIBRARY_PATH[];
|
|
static const char *LD_LIBRARY_PATH[];
|
|
static int NUM_SP_ENV_VARS;
|
|
static int NUM_LD_ENV_VARS;
|
|
static int NUM_SP_PRELOADS;
|
|
static int NUM_LD_PRELOADS;
|
|
static int NUM_SP_LIBPATHS;
|
|
static int NUM_LD_LIBPATHS;
|
|
|
|
static const char *SP_ENV[] = {
|
|
SP_COLLECTOR_PARAMS, /* data descriptor */
|
|
SP_COLLECTOR_EXPNAME, /* experiment name */
|
|
SP_COLLECTOR_FOLLOW_SPEC, /* linetrace */
|
|
SP_COLLECTOR_FOUNDER, /* determine founder exp */
|
|
SP_PRELOAD_STRINGS, /* LD_PRELOADs for data collection */
|
|
SP_LIBPATH_STRINGS, /* LD_LIBRARY_PATHs for data collection */
|
|
"SP_COLLECTOR_TRACELEVEL", /* tprintf */
|
|
#if DEBUG
|
|
"SP_COLLECTOR_SIGACTION", /* dispatcher, hwprofile */
|
|
#endif
|
|
/* JAVA* */
|
|
/* LD_DEBUG=audit,bindings,detail */
|
|
/* LD_ORIGIN=yes */
|
|
NULL
|
|
};
|
|
|
|
static const char *LD_ENV[] = {
|
|
LD_PRELOAD_STRINGS, /* LD_PRELOADs */
|
|
LD_LIBPATH_STRINGS, /* LD_LIBRARY_PATHs */
|
|
JAVA_TOOL_OPTIONS, /* enable -agentlib:collector for JVMTI */
|
|
NULL
|
|
};
|
|
|
|
static const char *SP_PRELOAD[] = {
|
|
SP_PRELOAD_STRINGS,
|
|
NULL
|
|
};
|
|
|
|
static const char *LD_PRELOAD[] = {
|
|
LD_PRELOAD_STRINGS,
|
|
NULL
|
|
};
|
|
|
|
static const char *SP_LIBRARY_PATH[] = {
|
|
SP_LIBPATH_STRINGS,
|
|
NULL
|
|
};
|
|
static const char *LD_LIBRARY_PATH[] = {
|
|
LD_LIBPATH_STRINGS,
|
|
NULL
|
|
};
|
|
|
|
void
|
|
__collector_env_save_preloads ()
|
|
{
|
|
/* save the list of SP_PRELOADs */
|
|
int v;
|
|
for (v = 0; SP_PRELOAD[v]; v++)
|
|
{
|
|
sp_preloads[v] = __collector_strdup (CALL_UTIL (getenv)(SP_PRELOAD[v]));
|
|
TprintfT (DBG_LT3, "__collector_env_save_preloads: %s=%s\n", SP_PRELOAD[v], sp_preloads[v]);
|
|
}
|
|
NUM_SP_PRELOADS = v;
|
|
for (v = 0; SP_LIBRARY_PATH[v]; v++)
|
|
{
|
|
sp_libpaths[v] = __collector_strdup (CALL_UTIL (getenv)(SP_LIBRARY_PATH[v]));
|
|
TprintfT (DBG_LT4, "__collector_env_save_preloads: %s=%s\n", SP_LIBRARY_PATH[v],
|
|
sp_libpaths[v] ? sp_libpaths[v] : "NULL");
|
|
}
|
|
NUM_SP_LIBPATHS = v;
|
|
for (v = 0; LD_PRELOAD[v]; v++)
|
|
;
|
|
NUM_LD_PRELOADS = v;
|
|
for (v = 0; LD_LIBRARY_PATH[v]; v++)
|
|
;
|
|
NUM_LD_LIBPATHS = v;
|
|
for (v = 0; SP_ENV[v]; v++)
|
|
;
|
|
NUM_SP_ENV_VARS = v;
|
|
for (v = 0; LD_ENV[v]; v++)
|
|
;
|
|
NUM_LD_ENV_VARS = v;
|
|
}
|
|
|
|
/* free the memory involved in backing up the environment */
|
|
void
|
|
__collector_env_backup_free ()
|
|
{
|
|
int v = 0;
|
|
TprintfT (DBG_LT2, "env_backup_free()\n");
|
|
for (v = 0; sp_env_backup[v]; v++)
|
|
{
|
|
TprintfT (DBG_LT2, "env_backup_free():sp_env_backup[%d]=%s \n", v, sp_env_backup[v]);
|
|
__collector_freeCSize (__collector_heap, (char *) sp_env_backup[v], __collector_strlen (sp_env_backup[v]) + 1);
|
|
}
|
|
__collector_freeCSize (__collector_heap, (char**) sp_env_backup,
|
|
(NUM_SP_ENV_VARS + NUM_LD_ENV_VARS + 1) * sizeof (char*));
|
|
}
|
|
|
|
char **
|
|
__collector_env_backup ()
|
|
{
|
|
TprintfT (DBG_LT2, "env_backup_()\n");
|
|
char **backup = __collector_env_allocate (NULL, 1);
|
|
__collector_env_update (backup);
|
|
TprintfT (DBG_LT2, "env_backup_()\n");
|
|
return backup;
|
|
}
|
|
|
|
/*
|
|
function: env_prepend()
|
|
given an <old_str>, check to see if <str>
|
|
is already defined by it. If not, allocate
|
|
a new string and concat <envvar>=<str><separator><old_str>
|
|
params:
|
|
old_str: original string
|
|
str: substring to prepend
|
|
return: pointer to updated string or NULL if string was not updated.
|
|
*/
|
|
static char *
|
|
env_prepend (const char *envvar, const char *str, const char *separator,
|
|
const char *old_str)
|
|
{
|
|
if (!envvar || *envvar == 0 || !str || *str == 0)
|
|
{
|
|
/* nothing to do */
|
|
TprintfT (DBG_LT2, "env_prepend(\"%s\", \"%s\", \"%s\", \"%s\") -- nothing to do\n",
|
|
envvar, str, separator, old_str);
|
|
|
|
return NULL;
|
|
}
|
|
TprintfT (DBG_LT2, "env_prepend(\"%s\", \"%s\", \"%s\", \"%s\")\n",
|
|
envvar, str, separator, old_str);
|
|
char *ev;
|
|
size_t strsz;
|
|
if (!old_str || *old_str == 0)
|
|
{
|
|
strsz = __collector_strlen (envvar) + 1 + __collector_strlen (str) + 1;
|
|
ev = (char*) __collector_allocCSize (__collector_heap, strsz, 1);
|
|
if (ev)
|
|
{
|
|
CALL_UTIL (snprintf)(ev, strsz, "%s=%s", envvar, str);
|
|
assert (__collector_strlen (ev) + 1 == strsz);
|
|
}
|
|
else
|
|
TprintfT (DBG_LT2, "env_prepend(): could not allocate memory\n");
|
|
}
|
|
else
|
|
{
|
|
char *p = CALL_UTIL (strstr)(old_str, str);
|
|
if (p)
|
|
{
|
|
TprintfT (DBG_LT2, "env_prepend(): %s=%s was already set\n",
|
|
envvar, old_str);
|
|
return NULL;
|
|
}
|
|
strsz = __collector_strlen (envvar) + 1 + __collector_strlen (str) +
|
|
__collector_strlen (separator) + __collector_strlen (old_str) + 1;
|
|
ev = (char*) __collector_allocCSize (__collector_heap, strsz, 1);
|
|
if (ev)
|
|
{
|
|
CALL_UTIL (snprintf)(ev, strsz, "%s=%s%s%s", envvar, str, separator, old_str);
|
|
assert (__collector_strlen (ev) + 1 == strsz);
|
|
}
|
|
else
|
|
TprintfT (DBG_LT2, "env_prepend(): could not allocate memory\n");
|
|
}
|
|
TprintfT (DBG_LT2, "env_prepend(\"%s\", \"%s\", \"%s\", \"%s\") returns \"%s\"\n",
|
|
envvar, str, separator, old_str, (ev == NULL ? "NULL" : ev));
|
|
return ev;
|
|
}
|
|
|
|
/*
|
|
function: putenv_prepend()
|
|
get environment variable <envvar>, check to see if <str>
|
|
is already defined by it. If not prepend <str>
|
|
and put it back to environment.
|
|
params:
|
|
envvar: environment variable
|
|
str: substring to find
|
|
return: 0==success, nonzero on failure.
|
|
*/
|
|
int
|
|
putenv_prepend (const char *envvar, const char *str, const char *separator)
|
|
{
|
|
if (!envvar || *envvar == 0)
|
|
return 1;
|
|
const char * old_str = CALL_UTIL (getenv)(envvar);
|
|
char * newstr = env_prepend (envvar, str, separator, old_str);
|
|
if (newstr)
|
|
// now put the new variable into the environment
|
|
if (CALL_UTIL (putenv)(newstr) != 0)
|
|
{
|
|
TprintfT (DBG_LT2, "putenv_prepend(): ERROR %s is not set!\n", newstr);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
function: env_strip()
|
|
Finds substr in origstr; Removes
|
|
all characters from previous ':' or ' '
|
|
up to and including any trailing ':' or ' '.
|
|
params:
|
|
env: environment variable contents
|
|
str: substring to find
|
|
return: count of instances removed from env
|
|
*/
|
|
static int
|
|
env_strip (char *origstr, const char *substr)
|
|
{
|
|
int removed = 0;
|
|
char *p, *q;
|
|
if (origstr == NULL || substr == NULL || *substr == 0)
|
|
return 0;
|
|
while ((p = q = CALL_UTIL (strstr)(origstr, substr)))
|
|
{
|
|
p += __collector_strlen (substr);
|
|
while (*p == ':' || *p == ' ') /* strip trailing separator */
|
|
p++;
|
|
while (*q != ':' && *q != ' ' && *q != '=' && q != origstr) /* strip path */
|
|
q--;
|
|
if (q != origstr) /* restore leading separator (if any) */
|
|
q++;
|
|
__collector_strlcpy (q, p, __collector_strlen (p) + 1);
|
|
removed++;
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
/*
|
|
function: env_ld_preload_strip()
|
|
Removes known libcollector shared objects from envv.
|
|
params:
|
|
var: shared object name (leading characters don't have to match)
|
|
return: 0 = so's removed, non-zero = so's not found.
|
|
*/
|
|
static int
|
|
env_ld_preload_strip (char *envv)
|
|
{
|
|
if (!envv || *envv == 0)
|
|
{
|
|
TprintfT (DBG_LT2, "env_ld_preload_strip(): WARNING - envv is NULL\n");
|
|
return -1;
|
|
}
|
|
for (int v = 0; SP_PRELOAD[v]; v++)
|
|
if (env_strip (envv, sp_preloads[v]))
|
|
return 0;
|
|
if (line_mode != LM_CLOSED)
|
|
TprintfT (DBG_LT2, "env_ld_preload_strip(): WARNING - could not strip SP_PRELOADS from '%s'\n",
|
|
envv);
|
|
return -2;
|
|
}
|
|
|
|
void
|
|
__collector_env_print (char * label)
|
|
{
|
|
#if DEBUG
|
|
TprintfT (DBG_LT2, "__collector_env_print(%s)\n", label);
|
|
for (int v = 0; v < MAX_LD_PRELOADS; v++)
|
|
TprintfT (DBG_LT2, " %s sp_preloads[%d] (0x%p)=%s\n", label,
|
|
v, sp_preloads[v], (sp_preloads[v] == NULL ? "NULL" : sp_preloads[v]));
|
|
for (int v = 0; SP_ENV[v]; v++)
|
|
{
|
|
char *s = CALL_UTIL (getenv)(SP_ENV[v]);
|
|
if (s == NULL)
|
|
s = "<null>";
|
|
TprintfT (DBG_LT2, " %s SP_ENV[%d] (0x%p): %s=\"%s\"\n", label, v, SP_ENV[v], SP_ENV[v], s);
|
|
}
|
|
for (int v = 0; LD_ENV[v]; v++)
|
|
{
|
|
char *s = CALL_UTIL (getenv)(LD_ENV[v]);
|
|
if (s == NULL)
|
|
s = "<null>";
|
|
TprintfT (DBG_LT2, " %s LD_ENV[%d] (0x%p): %s=\"%s\"\n", label, v, LD_ENV[v], LD_ENV[v], s);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
__collector_env_printall (char *label, char *envp[])
|
|
{
|
|
#if DEBUG
|
|
TprintfT (DBG_LT2, "__collector_env_printall(%s): environment @ 0x%p\n", label, envp);
|
|
for (int i = 0; envp[i]; i++)
|
|
Tprintf (DBG_LT2, "\tenv[%d]@0x%p == %s\n", i, envp[i], envp[i]);
|
|
#endif
|
|
}
|
|
|
|
/* match collector environment variable */
|
|
int
|
|
env_match (char *envp[], const char *envvar)
|
|
{
|
|
int match = -1;
|
|
if (envp == NULL)
|
|
TprintfT (DBG_LT1, "env_match(%s): NULL envp!\n", envvar);
|
|
else
|
|
{
|
|
int i = 0;
|
|
while ((envp[i] != NULL) && (__collector_strStartWith (envp[i], envvar)))
|
|
i++;
|
|
if ((envp[i] == NULL) || (envp[i][__collector_strlen (envvar)] != '='))
|
|
TprintfT (DBG_LT4, "env_match(): @%p []%s not defined in envp\n", envp, envvar);
|
|
else
|
|
{
|
|
TprintfT (DBG_LT4, "env_match(): @%p [%d]%s defined in envp\n", envp, i, envp[i]);
|
|
match = i;
|
|
}
|
|
}
|
|
TprintfT (DBG_LT1, "env_match(%s): found in slot %d\n", envvar, match);
|
|
return (match);
|
|
}
|
|
|
|
/* allocate new environment with collector variables */
|
|
/* 1) copy all current envp[] ptrs into a new array, coll_env[] */
|
|
/* 2) if collector-related env ptrs not in envp[], append them to coll_env */
|
|
/* from processes' "environ" (allocate_env==1) */
|
|
/* or from sp_env_backup (allocate_env==0)*/
|
|
/* If they already exist in envp, probably is an error... */
|
|
/* 3) return coll_env */
|
|
|
|
/* __collector__env_update() need be called after this to set LD_ENV*/
|
|
char **
|
|
__collector_env_allocate (char *const old_env[], int allocate_env)
|
|
{
|
|
extern char **environ; /* the process' actual environment */
|
|
char **new_env; /* a new environment for collection */
|
|
TprintfT (DBG_LT3, "__collector_env_allocate(old_env=0x%p %s environ=0x%p)\n",
|
|
old_env, (old_env == environ) ? "==" : "!=", environ);
|
|
/* set up a copy of the provided old_env for collector use */
|
|
int old_env_size = 0;
|
|
|
|
/* determine number of (used) slots in old_env */
|
|
if (old_env)
|
|
while (old_env[old_env_size] != NULL)
|
|
old_env_size++;
|
|
/* allocate a new vector with additional slots */
|
|
int new_env_alloc_sz = old_env_size + NUM_SP_ENV_VARS + NUM_LD_ENV_VARS + 1;
|
|
new_env = (char**) __collector_allocCSize (__collector_heap, new_env_alloc_sz * sizeof (char*), 1);
|
|
if (new_env == NULL)
|
|
return NULL;
|
|
TprintfT (DBG_LT4, "__collector_env_allocate(): old_env has %d entries, new_env @ 0x%p\n", old_env_size, new_env);
|
|
|
|
/* copy provided old_env pointers to new collector environment */
|
|
int new_env_size = 0;
|
|
for (new_env_size = 0; new_env_size < old_env_size; new_env_size++)
|
|
new_env[new_env_size] = old_env[new_env_size];
|
|
|
|
/* check each required environment variable, adding as required */
|
|
const char * env_var;
|
|
int v;
|
|
for (v = 0; (env_var = SP_ENV[v]) != NULL; v++)
|
|
{
|
|
if (env_match ((char**) old_env, env_var) == -1)
|
|
{
|
|
int idx;
|
|
/* not found in old_env */
|
|
if (allocate_env)
|
|
{
|
|
if ((idx = env_match (environ, env_var)) != -1)
|
|
{
|
|
/* found in environ */
|
|
TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
|
|
new_env_size, environ[idx]);
|
|
int varsz = __collector_strlen (environ[idx]) + 1;
|
|
char * var = (char*) __collector_allocCSize (__collector_heap, varsz, 1);
|
|
if (var == NULL)
|
|
return NULL;
|
|
__collector_strlcpy (var, environ[idx], varsz);
|
|
new_env[new_env_size++] = var;
|
|
}
|
|
else
|
|
{
|
|
/* not found in environ */
|
|
if ((__collector_strcmp (env_var, SP_COLLECTOR_PARAMS) == 0) ||
|
|
(__collector_strcmp (env_var, SP_COLLECTOR_EXPNAME) == 0))
|
|
TprintfT (DBG_LT1, "__collector_env_allocate(): note: %s environment variable not found\n",
|
|
env_var);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((idx = env_match (sp_env_backup, env_var)) != -1)
|
|
{
|
|
/* found in backup */
|
|
TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
|
|
new_env_size, sp_env_backup[idx]);
|
|
new_env[new_env_size++] = sp_env_backup[idx];
|
|
}
|
|
else
|
|
{
|
|
/* not found in environ */
|
|
if ((__collector_strcmp (env_var, SP_COLLECTOR_PARAMS) == 0) ||
|
|
(__collector_strcmp (env_var, SP_COLLECTOR_EXPNAME) == 0))
|
|
TprintfT (DBG_LT1, "__collector_env_allocate(): note: %s environment variable not found\n",
|
|
env_var);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (v = 0; (env_var = LD_ENV[v]) != NULL; v++)
|
|
{
|
|
if (env_match ((char**) old_env, env_var) == -1)
|
|
{
|
|
int idx;
|
|
/* not found in old_env */
|
|
if (allocate_env)
|
|
{
|
|
if ((idx = env_match (environ, env_var)) != -1)
|
|
{
|
|
/* found in environ */
|
|
TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
|
|
new_env_size, environ[idx]);
|
|
|
|
int varsz = __collector_strlen (env_var) + 2;
|
|
char * var = (char*) __collector_allocCSize (__collector_heap, varsz, 1);
|
|
if (var == NULL)
|
|
return NULL;
|
|
// assume __collector_env_update() will fill content of env_var
|
|
CALL_UTIL (snprintf)(var, varsz, "%s=", env_var);
|
|
new_env[new_env_size++] = var;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((idx = env_match (sp_env_backup, env_var)) != -1)
|
|
{
|
|
/* found in backup */
|
|
TprintfT (DBG_LT4, "__collector_env_allocate(): [%d]%s env restored!\n",
|
|
new_env_size, sp_env_backup[idx]);
|
|
new_env[new_env_size++] = sp_env_backup[idx];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ensure new_env vector ends with NULL */
|
|
new_env[new_env_size] = NULL;
|
|
assert (new_env_size <= new_env_alloc_sz);
|
|
TprintfT (DBG_LT4, "__collector_env_allocate(): new_env has %d entries (%d added), new_env=0x%p\n",
|
|
new_env_size, new_env_size - old_env_size, new_env);
|
|
if (new_env_size != old_env_size && !allocate_env)
|
|
__collector_log_write ("<event kind=\"%s\" id=\"%d\">%d</event>\n",
|
|
SP_JCMD_CWARN, COL_WARN_EXECENV, new_env_size - old_env_size);
|
|
__collector_env_printall ("__collector_env_allocate", new_env);
|
|
return (new_env);
|
|
}
|
|
|
|
/* unset collection environment variables */
|
|
/* if they exist in env... */
|
|
/* 1) push non-collectorized version to env */
|
|
|
|
/* Not mt safe */
|
|
void
|
|
__collector_env_unset (char *envp[])
|
|
{
|
|
int v;
|
|
const char * env_name;
|
|
TprintfT (DBG_LT3, "env_unset(envp=0x%p)\n", envp);
|
|
if (envp == NULL)
|
|
{
|
|
for (v = 0; (env_name = LD_PRELOAD[v]); v++)
|
|
{
|
|
const char *env_val = CALL_UTIL (getenv)(env_name);
|
|
if (env_val && CALL_UTIL (strstr)(env_val, sp_preloads[v]))
|
|
{
|
|
size_t sz = __collector_strlen (env_name) + 1 + __collector_strlen (env_val) + 1;
|
|
char * ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
|
|
if (ev == NULL)
|
|
return;
|
|
CALL_UTIL (snprintf)(ev, sz, "%s=%s", env_name, env_val);
|
|
assert (__collector_strlen (ev) + 1 == sz);
|
|
TprintfT (DBG_LT4, "env_unset(): old %s\n", ev);
|
|
env_ld_preload_strip (ev);
|
|
CALL_UTIL (putenv)(ev);
|
|
TprintfT (DBG_LT4, "env_unset(): new %s\n", ev);
|
|
}
|
|
}
|
|
// unset JAVA_TOOL_OPTIONS
|
|
env_name = JAVA_TOOL_OPTIONS;
|
|
const char * env_val = CALL_UTIL (getenv)(env_name);
|
|
if (env_val && CALL_UTIL (strstr)(env_val, COLLECTOR_JVMTI_OPTION))
|
|
{
|
|
size_t sz = __collector_strlen (env_name) + 1 + __collector_strlen (env_val) + 1;
|
|
char * ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
|
|
if (ev == NULL)
|
|
return;
|
|
CALL_UTIL (snprintf)(ev, sz, "%s=%s", env_name, env_val);
|
|
assert (__collector_strlen (ev) + 1 == sz);
|
|
TprintfT (DBG_LT4, "env_unset(): old %s\n", ev);
|
|
env_strip (ev, COLLECTOR_JVMTI_OPTION);
|
|
CALL_UTIL (putenv)(ev);
|
|
TprintfT (DBG_LT4, "env_unset(): new %s\n", ev);
|
|
}
|
|
__collector_env_print ("__collector_env_unset");
|
|
}
|
|
else
|
|
{
|
|
__collector_env_printall ("__collector_env_unset, before", envp);
|
|
for (v = 0; (env_name = LD_PRELOAD[v]); v++)
|
|
{
|
|
int idx = env_match (envp, env_name);
|
|
if (idx != -1)
|
|
{
|
|
char *env_val = envp[idx];
|
|
TprintfT (DBG_LT4, "env_unset(): old %s\n", env_val);
|
|
envp[idx] = "junk="; /* xxxx is it ok to use original string? */
|
|
env_ld_preload_strip (env_val);
|
|
envp[idx] = env_val;
|
|
TprintfT (DBG_LT4, "env_unset(): new %s\n", envp[idx]);
|
|
}
|
|
}
|
|
// unset JAVA_TOOL_OPTIONS
|
|
env_name = JAVA_TOOL_OPTIONS;
|
|
int idx = env_match(envp, env_name);
|
|
if (idx != -1) {
|
|
char *env_val = envp[idx];
|
|
TprintfT(DBG_LT4, "env_unset(): old %s\n", env_val);
|
|
envp[idx] = "junk="; /* xxxx is it ok to use original string? */
|
|
env_strip(env_val, COLLECTOR_JVMTI_OPTION);
|
|
envp[idx] = env_val;
|
|
TprintfT(DBG_LT4, "env_unset(): new %s\n", envp[idx]);
|
|
}
|
|
__collector_env_printall ("__collector_env_unset, after", envp );
|
|
}
|
|
}
|
|
|
|
/* update collection environment variables */
|
|
/* update LD_PRELOADs and push them */
|
|
/* not mt safe */
|
|
void
|
|
__collector_env_update (char *envp[])
|
|
{
|
|
const char *env_name;
|
|
TprintfT (DBG_LT1, "__collector_env_update(envp=0x%p)\n", envp);
|
|
extern char **environ;
|
|
if (envp == NULL)
|
|
{
|
|
int v;
|
|
TprintfT (DBG_LT2, "__collector_env_update(envp=NULL)\n");
|
|
__collector_env_printall (" environ array, before", environ);
|
|
__collector_env_print (" env_update at entry ");
|
|
|
|
/* SP_ENV */
|
|
for (v = 0; (env_name = SP_ENV[v]) != NULL; v++)
|
|
{
|
|
if (env_match (environ, env_name) == -1)
|
|
{
|
|
int idx;
|
|
if ((idx = env_match (sp_env_backup, env_name)) != -1)
|
|
{
|
|
unsigned strsz = __collector_strlen (sp_env_backup[idx]) + 1;
|
|
char *ev = (char*) __collector_allocCSize (__collector_heap, strsz, 1);
|
|
CALL_UTIL (snprintf)(ev, strsz, "%s", sp_env_backup[idx]);
|
|
if (CALL_UTIL (putenv)(ev) != 0)
|
|
TprintfT (DBG_LT2, "__collector_env_update(): ERROR %s is not set!\n",
|
|
sp_env_backup[idx]);
|
|
}
|
|
}
|
|
}
|
|
__collector_env_print (" env_update after SP_ENV settings ");
|
|
|
|
/* LD_LIBRARY_PATH */
|
|
for (v = 0; (env_name = LD_LIBRARY_PATH[v]); v++)
|
|
/* assumes same index used between LD and SP vars */
|
|
if (putenv_prepend (env_name, sp_libpaths[v], ":"))
|
|
TprintfT (DBG_LT2, "collector: ERROR %s=%s could not be set\n",
|
|
env_name, sp_libpaths[v]);
|
|
__collector_env_print (" env_update after LD_LIBRARY_PATH settings ");
|
|
|
|
/* LD_PRELOAD */
|
|
for (v = 0; (env_name = LD_PRELOAD[v]); v++)
|
|
/* assumes same index used between LD and SP vars */
|
|
if (putenv_prepend (env_name, sp_preloads[v], " "))
|
|
TprintfT (DBG_LT2, "collector: ERROR %s=%s could not be set\n",
|
|
env_name, sp_preloads[v]);
|
|
__collector_env_print (" env_update after LD_PRELOAD settings ");
|
|
|
|
/* JAVA_TOOL_OPTIONS */
|
|
if (java_mode)
|
|
if (putenv_prepend (JAVA_TOOL_OPTIONS, COLLECTOR_JVMTI_OPTION, " "))
|
|
TprintfT (DBG_LT2, "collector: ERROR %s=%s could not be set\n",
|
|
JAVA_TOOL_OPTIONS, COLLECTOR_JVMTI_OPTION);
|
|
__collector_env_print (" env_update after JAVA_TOOL settings ");
|
|
}
|
|
else
|
|
{
|
|
int v;
|
|
int idx;
|
|
TprintfT (DBG_LT2, "__collector_env_update(envp=0x%p) not NULL\n", envp);
|
|
__collector_env_printall ("__collector_env_update, before", envp);
|
|
/* LD_LIBRARY_PATH */
|
|
for (v = 0; (env_name = LD_LIBRARY_PATH[v]); v++)
|
|
{
|
|
int idx = env_match (envp, env_name);
|
|
if (idx != -1)
|
|
{
|
|
char *env_val = __collector_strchr (envp[idx], '=');
|
|
if (env_val)
|
|
env_val++; /* skip '=' */
|
|
/* assumes same index used between LD and SP vars */
|
|
char *new_str = env_prepend (env_name, sp_libpaths[v],
|
|
":", env_val);
|
|
if (new_str)
|
|
envp[idx] = new_str;
|
|
}
|
|
}
|
|
|
|
/* LD_PRELOAD */
|
|
for (v = 0; (env_name = LD_PRELOAD[v]); v++)
|
|
{
|
|
int idx = env_match (envp, env_name);
|
|
if (idx != -1)
|
|
{
|
|
char *env_val = __collector_strchr (envp[idx], '=');
|
|
if (env_val)
|
|
env_val++; /* skip '=' */
|
|
/* assumes same index used between LD and SP vars */
|
|
char *new_str = env_prepend (env_name, sp_preloads[v],
|
|
" ", env_val);
|
|
if (new_str)
|
|
envp[idx] = new_str;
|
|
}
|
|
}
|
|
|
|
/* JAVA_TOOL_OPTIONS */
|
|
if (java_mode)
|
|
{
|
|
env_name = JAVA_TOOL_OPTIONS;
|
|
idx = env_match (envp, env_name);
|
|
if (idx != -1)
|
|
{
|
|
char *env_val = __collector_strchr (envp[idx], '=');
|
|
if (env_val)
|
|
env_val++; /* skip '=' */
|
|
char *new_str = env_prepend (env_name, COLLECTOR_JVMTI_OPTION,
|
|
" ", env_val);
|
|
if (new_str)
|
|
envp[idx] = new_str;
|
|
}
|
|
}
|
|
}
|
|
__collector_env_printall ("__collector_env_update, after", environ);
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------- putenv */
|
|
int putenv () __attribute__ ((weak, alias ("__collector_putenv")));
|
|
int _putenv () __attribute__ ((weak, alias ("__collector_putenv")));
|
|
|
|
int
|
|
__collector_putenv (char * string)
|
|
{
|
|
if (CALL_UTIL (putenv) == __collector_putenv ||
|
|
CALL_UTIL (putenv) == NULL)
|
|
{ // __collector_libc_funcs_init failed
|
|
CALL_UTIL (putenv) = (int(*)())dlsym (RTLD_NEXT, "putenv");
|
|
if (CALL_UTIL (putenv) == NULL || CALL_UTIL (putenv) == __collector_putenv)
|
|
CALL_UTIL (putenv) = (int(*)())dlsym (RTLD_DEFAULT, "putenv");
|
|
if (CALL_UTIL (putenv) == NULL || CALL_UTIL (putenv) == __collector_putenv)
|
|
{
|
|
TprintfT (DBG_LT2, "__collector_putenv(): ERROR: no pointer found.\n");
|
|
errno = EBUSY;
|
|
return -1;
|
|
}
|
|
}
|
|
if (user_follow_mode == FOLLOW_NONE)
|
|
return CALL_UTIL (putenv)(string);
|
|
char * envp[] = {string, NULL};
|
|
__collector_env_update (envp);
|
|
return CALL_UTIL (putenv)(envp[0]);
|
|
}
|
|
|
|
/*------------------------------------------------------------- setenv */
|
|
int setenv () __attribute__ ((weak, alias ("__collector_setenv")));
|
|
int _setenv () __attribute__ ((weak, alias ("__collector_setenv")));
|
|
|
|
int
|
|
__collector_setenv (const char *name, const char *value, int overwrite)
|
|
{
|
|
if (CALL_UTIL (setenv) == __collector_setenv ||
|
|
CALL_UTIL (setenv) == NULL)
|
|
{ // __collector_libc_funcs_init failed
|
|
CALL_UTIL (setenv) = (int(*)())dlsym (RTLD_NEXT, "setenv");
|
|
if (CALL_UTIL (setenv) == NULL || CALL_UTIL (setenv) == __collector_setenv)
|
|
CALL_UTIL (setenv) = (int(*)())dlsym (RTLD_DEFAULT, "setenv");
|
|
if (CALL_UTIL (setenv) == NULL || CALL_UTIL (setenv) == __collector_setenv)
|
|
{
|
|
TprintfT (DBG_LT2, "__collector_setenv(): ERROR: no pointer found.\n");
|
|
errno = EBUSY;
|
|
return -1;
|
|
}
|
|
}
|
|
if (user_follow_mode == FOLLOW_NONE || !overwrite)
|
|
return CALL_UTIL (setenv)(name, value, overwrite);
|
|
size_t sz = __collector_strlen (name) + 1 + __collector_strlen (value) + 1;
|
|
char *ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
|
|
if (ev == NULL)
|
|
return CALL_UTIL (setenv)(name, value, overwrite);
|
|
CALL_UTIL (snprintf)(ev, sz, "%s=%s", name, value);
|
|
char * envp[] = {ev, NULL};
|
|
__collector_env_update (envp);
|
|
if (envp[0] == ev)
|
|
{
|
|
__collector_freeCSize (__collector_heap, ev, sz);
|
|
return CALL_UTIL (setenv)(name, value, overwrite);
|
|
}
|
|
else
|
|
{
|
|
char *env_val = __collector_strchr (envp[0], '=');
|
|
if (env_val)
|
|
{
|
|
*env_val = '\0';
|
|
env_val++; /* skip '=' */
|
|
}
|
|
return CALL_UTIL (setenv)(envp[0], env_val, overwrite);
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------- unsetenv */
|
|
int unsetenv () __attribute__ ((weak, alias ("__collector_unsetenv")));
|
|
int _unsetenv () __attribute__ ((weak, alias ("__collector_unsetenv")));
|
|
|
|
int
|
|
__collector_unsetenv (const char *name)
|
|
{
|
|
if (CALL_UTIL (unsetenv) == __collector_unsetenv ||
|
|
CALL_UTIL (unsetenv) == NULL)
|
|
{ // __collector_libc_funcs_init failed
|
|
CALL_UTIL (unsetenv) = (int(*)())dlsym (RTLD_NEXT, "unsetenv");
|
|
if (CALL_UTIL (unsetenv) == NULL || CALL_UTIL (unsetenv) == __collector_unsetenv)
|
|
CALL_UTIL (unsetenv) = (int(*)())dlsym (RTLD_DEFAULT, "unsetenv");
|
|
if (CALL_UTIL (unsetenv) == NULL || CALL_UTIL (unsetenv) == __collector_unsetenv)
|
|
{
|
|
TprintfT (DBG_LT2, "__collector_unsetenv(): ERROR: no pointer found.\n");
|
|
errno = EBUSY;
|
|
return -1;
|
|
}
|
|
}
|
|
int ret = CALL_UTIL (unsetenv)(name);
|
|
if (user_follow_mode == FOLLOW_NONE)
|
|
return ret;
|
|
TprintfT (DBG_LT2, "__collector_unsetenv(): %d.\n", user_follow_mode);
|
|
size_t sz = __collector_strlen (name) + 1 + 1;
|
|
char *ev = (char*) __collector_allocCSize (__collector_heap, sz, 1);
|
|
if (ev == NULL)
|
|
return ret;
|
|
CALL_UTIL (snprintf)(ev, sz, "%s=", name);
|
|
char * envp[] = {ev, NULL};
|
|
__collector_env_update (envp);
|
|
if (envp[0] == ev)
|
|
__collector_freeCSize (__collector_heap, ev, sz);
|
|
else
|
|
CALL_UTIL (putenv)(envp[0]);
|
|
return ret;
|
|
}
|
|
|
|
/*------------------------------------------------------------- clearenv */
|
|
int clearenv () __attribute__ ((weak, alias ("__collector_clearenv")));
|
|
|
|
int
|
|
__collector_clearenv (void)
|
|
{
|
|
if (CALL_UTIL (clearenv) == __collector_clearenv || CALL_UTIL (clearenv) == NULL)
|
|
{
|
|
/* __collector_libc_funcs_init failed; look up clearenv now */
|
|
CALL_UTIL (clearenv) = (int(*)())dlsym (RTLD_NEXT, "clearenv");
|
|
if (CALL_UTIL (clearenv) == NULL || CALL_UTIL (clearenv) == __collector_clearenv)
|
|
/* still not found; try again */
|
|
CALL_UTIL (clearenv) = (int(*)())dlsym (RTLD_DEFAULT, "clearenv");
|
|
if (CALL_UTIL (clearenv) == NULL || CALL_UTIL (clearenv) == __collector_clearenv)
|
|
{
|
|
/* still not found -- a fatal error */
|
|
TprintfT (DBG_LT2, "__collector_clearenv(): ERROR: %s\n", dlerror ());
|
|
CALL_UTIL (fprintf)(stderr, "__collector_clearenv(): ERROR: %s\n", dlerror ());
|
|
errno = EBUSY;
|
|
return -1;
|
|
}
|
|
}
|
|
int ret = CALL_UTIL (clearenv)();
|
|
if (user_follow_mode == FOLLOW_NONE)
|
|
return ret;
|
|
if (sp_env_backup == NULL)
|
|
{
|
|
TprintfT (DBG_LT2, "__collector_clearenv: ERROR sp_env_backup is not set!\n");
|
|
return ret;
|
|
}
|
|
for (int v = 0; v < NUM_SP_ENV_VARS + NUM_LD_ENV_VARS; v++)
|
|
if (sp_env_backup[v] && CALL_UTIL (putenv)(sp_env_backup[v]) != 0)
|
|
TprintfT (DBG_LT2, "__collector_clearenv: ERROR %s is not set!\n",
|
|
sp_env_backup[v]);
|
|
return ret;
|
|
}
|