/****** 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() */