/****** uti/stdlib/sge_realloc() **********************************************
* NAME
* sge_realloc() -- replacement for realloc
*
* SYNOPSIS
* char* sge_realloc(char *ptr, int size, int abort)
*
* FUNCTION
* Reallocates a memory block. Aborts in case of an error.
*
* INPUTS
* char *ptr - pointer to a memory block
* int size - new size
* int abort - do abort when realloc fails?
*
* RESULT
* char* - pointer to the (new) memory block
*
* NOTES
* MT-NOTE: sge_realloc() is MT safe
******************************************************************************/
void *sge_realloc(void *ptr, int size, int do_abort)
{
void *cp = NULL;
DENTER_(BASIS_LAYER, "sge_realloc");
/* if new size is 0, just free the currently allocated memory */
if (size == 0) {
sge_free(&ptr);
DRETURN_(NULL);
}
cp = realloc(ptr, size);
if (cp == NULL) {
CRITICAL((SGE_EVENT, SFNMAX, MSG_MEMORY_REALLOCFAILED));
if (do_abort) {
DEXIT_;
abort();
} else {
sge_free(&ptr);
}
}
DRETURN_(cp);
}
/****** uti/prog/sge_get_alias_path() *****************************************
* NAME
* sge_get_alias_path() -- Return the path of the 'alias_file'
*
* SYNOPSIS
* const char* sge_get_alias_path(void)
*
* FUNCTION
* Return the path of the 'alias_file'
*
* NOTES
* MT-NOTE: sge_get_alias_path() is MT safe
*
******************************************************************************/
const char *sge_get_alias_path(void)
{
const char *sge_root, *sge_cell;
char *cp;
int len;
SGE_STRUCT_STAT sbuf;
DENTER_(TOP_LAYER, "sge_get_alias_path");
sge_root = sge_get_root_dir(1, NULL, 0, 1);
sge_cell = sge_get_default_cell();
if (SGE_STAT(sge_root, &sbuf)) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_SGEROOTNOTFOUND_S , sge_root));
SGE_EXIT(NULL, 1);
}
len = strlen(sge_root) + strlen(sge_cell) + strlen(COMMON_DIR) + strlen(ALIAS_FILE) + 5;
if (!(cp = malloc(len))) {
CRITICAL((SGE_EVENT, MSG_MEMORY_MALLOCFAILEDFORPATHTOHOSTALIASFILE ));
SGE_EXIT(NULL, 1);
}
sprintf(cp, "%s/%s/%s/%s", sge_root, sge_cell, COMMON_DIR, ALIAS_FILE);
DRETURN_(cp);
}
/****** uti/prog/sge_get_default_cell() ***************************************
* NAME
* sge_get_default_cell() -- get cell name and remove trailing slash
*
* SYNOPSIS
* const char* sge_get_default_cell(void)
*
* FUNCTION
* This function returns the defined cell name of SGE/SGEEE.
* This directory is defined by the SGE_CELL environment variable
* of the calling process.
* If the environment variable does not exist or is not set then
* this function will return the 'DEFAULT_CELL'.
*
* RESULT
* const char* - Cell name of this SGE/SGEEE installation
*
* NOTES
* MT-NOTE: sge_get_default_cell() is MT safe
******************************************************************************/
const char *sge_get_default_cell(void)
{
char *sge_cell;
char *s;
DENTER_(TOP_LAYER, "sge_get_default_cell");
/*
* Read some env variables
*/
sge_cell = getenv("SGE_CELL");
/*
* Check the env variables
*/
if (sge_cell) {
s = sge_cell;
} else {
s = NULL;
}
/*
* Use default?
*/
if (!s || strlen(s) == 0) {
s = DEFAULT_CELL;
} else {
/*
* Get rid of trailing slash
*/
if (s[strlen(s)-1] == '/') {
s[strlen(s)-1] = '\0';
}
}
DRETURN_(s);
}
/****** uti/stdlib/sge_getenv() ***********************************************
* NAME
* sge_getenv() -- get an environment variable
*
* SYNOPSIS
* const char* sge_getenv(const char *env_str)
*
* FUNCTION
* The function searches the environment list for a
* string that matches the string pointed to by 'env_str'.
*
* INPUTS
* const char *env_str - name of env. varibale
*
* RESULT
* const char* - value
*
* SEE ALSO
* uti/stdlib/sge_putenv()
* uti/stdlib/sge_setenv()
*
* NOTES
* MT-NOTE: sge_getenv() is MT safe
******************************************************************************/
const char *sge_getenv(const char *env_str)
{
const char *cp=NULL;
DENTER_(BASIS_LAYER, "sge_getenv");
cp = (char *) getenv(env_str);
DRETURN_(cp);
}
/****** uti/prog/sge_get_root_dir() *******************************************
* NAME
* sge_get_root_dir() -- SGE/SGEEE installation directory
*
* SYNOPSIS
* const char* sge_get_root_dir(int do_exit,
* char *buffer,
* size_t size,
* int do_error_log )
*
* FUNCTION
* This function returns the installation directory of SGE/SGEEE.
* This directory is defined by the SGE_ROOT environment variable
* of the calling process.
* If the environment variable does not exist or is not set then
* this function will handle this as error and return NULL
* (do_exit = 0). If 'do_exit' is 1 and an error occures, the
* function will terminate the calling application.
*
* INPUTS
* int do_exit - Terminate the application in case of an error
* char *buffer - buffer to be used for error message
* size_t size - size of buffer
* int do_error_log - enable/disable error logging
*
* RESULT
* const char* - Root directory of the SGE/SGEEE installation
*
* NOTES
* MT-NOTE: sge_get_arch() is MT safe
*******************************************************************************/
const char *sge_get_root_dir(int do_exit, char *buffer, size_t size, int do_error_log)
{
char *sge_root;
char *s;
DENTER_(TOP_LAYER, "sge_get_root_dir");
/*
* Read some env variables
*/
sge_root = getenv("SGE_ROOT");
/*
* Check the env variables
*/
if (sge_root) {
s = sge_root;
} else {
goto error;
}
if (!s || strlen(s)==0) {
goto error;
} else {
/*
* Get rid of trailing slash
*/
if (s[strlen(s)-1] == '/') {
s[strlen(s)-1] = '\0';
}
}
DRETURN_(s);
error:
if (do_error_log) {
if (buffer != NULL) {
sge_strlcpy(buffer, MSG_SGEROOTNOTSET, size);
} else {
CRITICAL((SGE_EVENT, MSG_SGEROOTNOTSET));
}
}
DEXIT_;
if (do_exit) {
SGE_EXIT(NULL, 1);
}
return NULL;
}
/****** uti/stdlib/sge_malloc() ***********************************************
* NAME
* sge_malloc() -- replacement for malloc()
*
* SYNOPSIS
* void* sge_malloc(size_t size)
*
* FUNCTION
* Allocates a memory block. Aborts in case of error.
*
* INPUTS
* size_t size - size in bytes
*
* RESULT
* void* - pointer to memory block
*
* NOTES
* MT-NOTE: sge_malloc() is MT safe
******************************************************************************/
void *sge_malloc(size_t size)
{
void *cp = NULL;
DENTER_(BASIS_LAYER, "sge_malloc");
if (!size) {
DRETURN_(NULL);
}
cp = malloc(size);
if (!cp) {
CRITICAL((SGE_EVENT, SFNMAX, MSG_MEMORY_MALLOCFAILED));
DEXIT_;
abort();
}
DRETURN_(cp);
}
/****** uti/log/sge_log() *****************************************************
* NAME
* sge_log() -- Low level logging function
*
* SYNOPSIS
* int sge_log(int log_level, char *mesg, char *file__,
* char *func__, int line__)
*
* FUNCTION
* Low level logging function. Used by various macros.
* Do not use this function directly.
*
* INPUTS
* int log_level - Logging Level
* char *mesg - Message
* char *file__ - Filename
* char *func__ - Function Name
* int line__ - Line within 'file__'
*
* RESULT
* int - 0
*
* SEE ALSO
* uti/log/CRITICAL
* uti/log/ERROR
* uti/log/WARNING
* uti/log/NOTICE
* uti/log/INFO
* uti/log/DEBUG
*
* NOTES
* MT-NOTE: sge_log() is not MT safe due to sge_switch2admin_user()
* MT-NOTE: sge_log() can be used in clients where no admin user switching
* MT-NOTE: takes place
* MT-NOTE: sge_log() is not MT safe due rmon_condition()
* MT-NOTE: sge_log() can be used if DENTER_MAIN() is called only by one
* MT-NOTE: thread
******************************************************************************/
int sge_log(int log_level, const char *mesg, const char *file__, const char *func__, int line__)
{
char buf[128*4];
int levelchar;
char levelstring[32*4];
sge_gdi_ctx_class_t *ctx = NULL;
/* TODO: this must be kept for qmaster and should be done in a different
way (qmaster context) !!! */
u_long32 me = 0;
const char *threadname = NULL;
const char *unqualified_hostname = NULL;
int is_daemonized = 0;
DENTER_(BASIS_LAYER, "sge_log");
ctx = log_state_get_log_context();
if (ctx != NULL) {
me = ctx->get_who(ctx);
threadname = ctx->get_thread_name(ctx);
unqualified_hostname = ctx->get_unqualified_hostname(ctx);
is_daemonized = ctx->is_daemonized(ctx);
} else {
DPRINTF(("sge_log: ctx is NULL\n"));
}
/* Make sure to have at least a one byte logging string */
if (!mesg || mesg[0] == '\0') {
sprintf(buf, MSG_LOG_CALLEDLOGGINGSTRING_S,
mesg ? MSG_LOG_ZEROLENGTH : MSG_POINTER_NULL);
mesg = buf;
}
DPRINTF(("%s %d %s\n", file__, line__, mesg));
/* quick exit if nothing to log */
if (log_level > MAX(log_state_get_log_level(), LOG_WARNING)) {
DRETURN_(0);
}
if (!log_state_get_log_gui()) {
DRETURN_(0);
}
switch(log_level) {
case LOG_PROF:
strcpy(levelstring, MSG_LOG_PROFILING);
levelchar = 'P';
break;
case LOG_CRIT:
strcpy(levelstring, MSG_LOG_CRITICALERROR);
levelchar = 'C';
break;
case LOG_ERR:
strcpy(levelstring, MSG_LOG_ERROR);
levelchar = 'E';
break;
case LOG_WARNING:
strcpy(levelstring, "");
levelchar = 'W';
break;
case LOG_NOTICE:
strcpy(levelstring, "");
levelchar = 'N';
break;
case LOG_INFO:
strcpy(levelstring, "");
levelchar = 'I';
break;
case LOG_DEBUG:
strcpy(levelstring, "");
levelchar = 'D';
break;
default:
strcpy(levelstring, "");
levelchar = 'L';
break;
}
/* avoid double output in debug mode */
if (!is_daemonized && !rmon_condition(TOP_LAYER, INFOPRINT) &&
(log_state_get_log_verbose() || log_level <= LOG_WARNING)) {
fprintf(stderr, "%s%s\n", levelstring, mesg);
}
sge_do_log(me, threadname, unqualified_hostname, levelchar, mesg);
DRETURN_(0);
} /* sge_log() */
