/***************************** init_fmri() *************************************
* NAME
* init_fmri() -- initialize shared SCF library
*
* SYNOPSIS
* static void init_fmri(void)
*
* FUNCTION
* Detects service FMRI if process was started over SMF and stores the name
* to static variable called FMRI.
*
* INPUTS
* void
*
* RESULT
* void
*
* NOTES
* LOCAL helper function, to be called only in as pthread_once init function
*
* SEE ALSO
* get_fmri()
*******************************************************************************/
static void init_fmri(void)
{
DENTER(TOP_LAYER, "init_fmri");
/* Will be set is started over SMF */
char *temp = getenv("SMF_FMRI");
/* We explicitly check the fmri for valid service names */
if (temp && is_valid_sge_fmri(temp)) {
FMRI = sge_strdup(NULL, temp);
DPRINTF(("init_fmri() - FMRI set to %s\n", (FMRI==NULL) ? "NULL" : FMRI));
}
DEXIT;
}
/****** loadcheck/fill_socket_core_topology() **********************************
* NAME
* fill_socket_core_topology() -- Get load values regarding processor topology.
*
* SYNOPSIS
* void fill_socket_core_topology(dstring* msocket, dstring* mcore, dstring*
* mtopology)
*
* FUNCTION
* Gets the values regarding processor topology.
*
* OUTPUTS
* dstring* msocket - The amount of sockets the host have.
* dstring* mcore - The amount of cores the host have.
* dstring* mtopology - The topology the host have.
*
* RESULT
* void - nothing
*
*******************************************************************************/
void fill_socket_core_topology(dstring* msocket, dstring* mcore, dstring* mtopology)
{
int ms, mc;
char* topo = NULL;
int length = 0;
ms = get_execd_amount_of_sockets();
mc = get_execd_amount_of_cores();
if (!get_execd_topology(&topo, &length) || topo == NULL) {
topo = sge_strdup(NULL, "-");
}
sge_dstring_sprintf(msocket, "%d", ms);
sge_dstring_sprintf(mcore, "%d", mc);
sge_dstring_append(mtopology, topo);
sge_free(&topo);
}
/****** sge_binding/getExecdTopologyInUse() ************************************
* NAME
* getExecdTopologyInUse() -- Creates a string which represents the used topology.
*
* SYNOPSIS
* bool getExecdTopologyInUse(char** topology)
*
* FUNCTION
*
* Checks all jobs (with going through active jobs directories) and their
* usage of the topology (binding). Afterwards global "logical_used_topology"
* string is up to date (which is also updated when a job ends and starts) and
* a copy is made available for the caller.
*
* Note: The memory is allocated within this function and
* has to be freed from the caller afterwards.
* INPUTS
* char** topology - out: the current topology in use by jobs
*
* RESULT
* bool - true if the "topology in use" string could be created
*
* NOTES
* MT-NOTE: getExecdTopologyInUse() is not MT safe
*******************************************************************************/
bool get_execd_topology_in_use(char** topology)
{
bool retval = false;
/* topology must be a NULL pointer */
if ((*topology) != NULL) {
return false;
}
if (logical_used_topology_length == 0 || logical_used_topology == NULL) {
/* initialize without any usage */
get_topology(&logical_used_topology, &logical_used_topology_length);
}
if (logical_used_topology_length > 0) {
/* copy the string */
(*topology) = sge_strdup(NULL, logical_used_topology);
retval = true;
}
return retval;
}
static void set_security_mode(sge_bootstrap_state_class_t *thiz, const char *security_mode)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->security_mode = sge_strdup(es->security_mode, security_mode);
}
/****** sge_binding_hlp/get_topology_linux() ***********************************
* NAME
* get_topology_linux() -- Creates the topology string for the current host.
*
* SYNOPSIS
* bool get_topology_linux(char** topology, int* length)
*
* FUNCTION
* Creates the topology string for the current host. When it was created
* it has top be freed from outside.
*
* INPUTS
* char** topology - The topology string for the current host.
* int* length - The length of the topology string.
*
* RESULT
* bool - when true the topology string could be generated (and memory
* is allocated otherwise false
*
* NOTES
* MT-NOTE: get_topology_linux() is MT safe
*
*******************************************************************************/
bool get_topology_linux(char** topology, int* length)
{
bool success = false;
/* initialize length of topology string */
(*length) = 0;
int has_topology = 0;
/* check if topology is supported via PLPA */
if (plpa_have_topology_information(&has_topology) == 0 && has_topology == 1) {
int num_sockets, max_socket_id;
/* topology string */
dstring d_topology = DSTRING_INIT;
/* build the topology string */
if (plpa_get_socket_info(&num_sockets, &max_socket_id) == 0) {
int num_cores, max_core_id, ctr_cores, ctr_sockets, ctr_threads;
char* s = "S"; /* socket */
char* c = "C"; /* core */
char* t = "T"; /* thread */
for (ctr_sockets = 0; ctr_sockets < num_sockets; ctr_sockets++) {
int socket_id; /* internal socket id */
/* append new socket */
sge_dstring_append_char(&d_topology, *s);
(*length)++;
/* for each socket get the number of cores */
if (plpa_get_socket_id(ctr_sockets, &socket_id) != 0) {
/* error while getting the internal socket id out of the logical */
continue;
}
/* get information about this socket */
if (plpa_get_core_info(socket_id, &num_cores, &max_core_id) == 0) {
/* for thread counting */
int* proc_ids = NULL;
int amount_of_threads = 0;
/* check each core */
for (ctr_cores = 0; ctr_cores < num_cores; ctr_cores++) {
sge_dstring_append_char(&d_topology, *c);
(*length)++;
/* check if the core has threads */
if (get_processor_ids_linux(ctr_sockets, ctr_cores, &proc_ids, &amount_of_threads)
&& amount_of_threads > 1) {
/* print the threads */
for (ctr_threads = 0; ctr_threads < amount_of_threads; ctr_threads++) {
sge_dstring_append_char(&d_topology, *t);
(*length)++;
}
}
sge_free(&proc_ids);
}
}
} /* for each socket */
if ((*length) != 0) {
/* convert d_topolgy into topology */
(*length)++; /* we need `\0` at the end */
/* copy element */
(*topology) = sge_strdup(NULL, sge_dstring_get_string(&d_topology));
success = true;
}
sge_dstring_free(&d_topology);
}
}
return success;
}
/****** sge_var/var_list_parse_from_string() *******************************
* NAME
* var_list_parse_from_string() -- parse vars from string list
*
* SYNOPSIS
* int var_list_parse_from_string(lList **lpp,
* const char *variable_str,
* int check_environment)
*
* FUNCTION
* Parse a list of variables ("lpp") from a comma separated
* string list ("variable_str"). The boolean "check_environment"
* defined wether the current value of a variable is taken from
* the environment of the calling process.
*
* INPUTS
* lList **lpp - VA_Type list
* const char *variable_str - source string
* int check_environment - boolean
*
* RESULT
* int - error state
* 0 - OK
* >0 - Error
*
* NOTES
* MT-NOTE: var_list_parse_from_string() is MT safe
*******************************************************************************/
int var_list_parse_from_string(lList **lpp, const char *variable_str,
int check_environment)
{
char *variable;
char *val_str;
int var_len;
char **str_str;
char **pstr;
lListElem *ep;
char *va_string;
DENTER(TOP_LAYER, "var_list_parse_from_string");
if (!lpp) {
DEXIT;
return 1;
}
va_string = sge_strdup(NULL, variable_str);
if (!va_string) {
*lpp = NULL;
DEXIT;
return 2;
}
str_str = string_list(va_string, ",", NULL);
if (!str_str || !*str_str) {
*lpp = NULL;
sge_free(&va_string);
DEXIT;
return 3;
}
if (!*lpp) {
*lpp = lCreateList("variable list", VA_Type);
if (!*lpp) {
sge_free(&va_string);
sge_free(&str_str);
DEXIT;
return 4;
}
}
for (pstr = str_str; *pstr; pstr++) {
struct saved_vars_s *context;
ep = lCreateElem(VA_Type);
/* SGE_ASSERT(ep); */
lAppendElem(*lpp, ep);
context = NULL;
variable = sge_strtok_r(*pstr, "=", &context);
SGE_ASSERT((variable));
var_len=strlen(variable);
lSetString(ep, VA_variable, variable);
val_str=*pstr;
/*
* The character at the end of the first token must be either '=' or '\0'.
* If it's a '=' then we treat the following string as the value
* If it's a '\0' and check_environment is set, then we get the value from
* the environment variable value.
* If it's a '\0' and check_environment is not set, then we set the value
* to NULL.
*/
if (val_str[var_len] == '=') {
lSetString(ep, VA_value, &val_str[var_len+1]);
} else if (check_environment) {
lSetString(ep, VA_value, sge_getenv(variable));
} else {
lSetString(ep, VA_value, NULL);
}
sge_free_saved_vars(context);
}
sge_free(&va_string);
sge_free(&str_str);
DRETURN(0);
}
/*-------------------------------------------------------------------------*/
static Boolean qmonSchedSet(lListElem *sep) {
static char schedd_job_info[BUFSIZ];
DENTER(GUI_LAYER, "qmonSchedSet");
if (!sep) {
DRETURN(False);
}
/* printf("------> qmonSchedSet\n"); */
/* lWriteElemTo(sep, stdout); */
data.algorithm = sge_strdup(data.algorithm,
(StringConst)lGetString(sep, SC_algorithm));
data.schedule_interval = sge_strdup(data.schedule_interval,
(StringConst)lGetString(sep, SC_schedule_interval));
data.sc_params = sge_strdup(data.sc_params,
(StringConst)lGetString(sep, SC_params));
data.maxujobs = lGetUlong(sep, SC_maxujobs);
data.flush_submit_secs = lGetUlong(sep, SC_flush_submit_sec);
data.flush_finish_secs = lGetUlong(sep, SC_flush_finish_sec);
data.max_reservation = lGetUlong(sep, SC_max_reservation);
/* this depends on the kind queue_sort_method is represented */
data.queue_sort_method = lGetUlong(sep, SC_queue_sort_method);
/*
** load adjustments need special treatment
*/
data.job_load_adjustments = lCopyList("copy", lGetList(sep, SC_job_load_adjustments));
data.load_adjustment_decay_time = sge_strdup(data.load_adjustment_decay_time,
(StringConst)lGetString(sep, SC_load_adjustment_decay_time));
data.load_formula = sge_strdup(data.load_formula,
(StringConst)lGetString(sep, SC_load_formula));
data.reprioritize_interval = sge_strdup(data.reprioritize_interval,
(StringConst)lGetString(sep, SC_reprioritize_interval));
data.default_duration = sge_strdup(data.default_duration,
(StringConst)lGetString(sep, SC_default_duration));
/**
printf("->data.algorithm: '%s'\n", data.algorithm ? data.algorithm : "-NA-");
printf("->data.schedule_interval: '%s'\n", data.schedule_interval ? data.schedule_interval : "-NA-");
printf("->data.sc_params: '%s'\n", data.sc_params ? data.sc_params : "-NA-");
printf("->data.maxujobs: '%d'\n", data.maxujobs );
printf("->data.flush_submit_secs: '%d'\n", data.flush_submit_secs );
printf("->data.flush_finish_secs: '%d'\n", data.flush_finish_secs );
printf("->data.max_reservation: '%d'\n", data.max_reservation );
printf("->data.queue_sort_method: '%d'\n", data.queue_sort_method );
printf("->data.load_adjustment_decay_time: '%s'\n", data.load_adjustment_decay_time ? data.load_adjustment_decay_time : "-NA-");
printf("->data.load_formula: '%s'\n", data.load_formula ? data.load_formula : "-NA-");
**/
/*
** set the dialog values
*/
XmtDialogSetDialogValues(qmon_sconf, (XtPointer) &data);
/*
** schedd_job_info needs some extras
** attention: order must match order of labels in qmon_sconf.ad
**
** Qmon*sconf_general*sconf_job_info.chooserType: ChooserOption
** Qmon*sconf_general*sconf_job_info.strings: \
** "False", \
** "True", \
** "Job Range"
*/
if (lGetString(sep, SC_schedd_job_info))
sge_strlcpy(schedd_job_info, lGetString(sep, SC_schedd_job_info), BUFSIZ);
else
strcpy(schedd_job_info, "false");
if (!strcasecmp(schedd_job_info, "false")) {
XmtChooserSetState(sconf_job_info, 0, True);
XmtInputFieldSetString(sconf_job_range, "");
}
else if (!strcasecmp(schedd_job_info, "true")) {
XmtChooserSetState(sconf_job_info, 1, True);
XmtInputFieldSetString(sconf_job_range, "");
}
else {
char *sji;
strtok(schedd_job_info, " \t");
sji = strtok(NULL, "\n");
XmtChooserSetState(sconf_job_info, 2, True);
XmtInputFieldSetString(sconf_job_range, sji);
}
qmonSchedFreeData();
DRETURN(True);
}
static void set_spooling_lib(sge_bootstrap_state_class_t *thiz, const char *spooling_lib)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->spooling_lib = sge_strdup(es->spooling_lib, spooling_lib);
}
static void set_spooling_method(sge_bootstrap_state_class_t *thiz, const char *spooling_method)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->spooling_method = sge_strdup(es->spooling_method, spooling_method);
}
static void set_default_domain(sge_bootstrap_state_class_t *thiz, const char *default_domain)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->default_domain = sge_strdup(es->default_domain, default_domain);
}
static void set_admin_user(sge_bootstrap_state_class_t *thiz, const char *admin_user)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->admin_user = sge_strdup(es->admin_user, admin_user);
}
/****** binding_support/get_topology() ***********************************
* NAME
* get_topology() -- Creates the topology string for the current host.
*
* SYNOPSIS
* bool get_topology(char** topology, int* length)
*
* FUNCTION
* Creates the topology string for the current host. When created,
* it has to be freed from outside.
*
* INPUTS
* char** topology - The topology string for the current host.
* int* length - The length of the topology string.
*
* RESULT
* bool - when true the topology string could be generated (and memory
* is allocated otherwise false
*
* NOTES
* MT-NOTE: get_topology() is MT safe
*
*******************************************************************************/
bool get_topology(char** topology, int* length)
{
bool success = false;
if (HAVE_HWLOC) {
/* initialize length of topology string */
(*length) = 0;
/* check if topology is supported via hwloc */
if (has_topology_information()) {
int num_sockets;
/* topology string */
dstring d_topology = DSTRING_INIT;
/* build the topology string */
if ((num_sockets = get_number_of_sockets())) {
int num_cores, ctr_cores, ctr_sockets, ctr_threads;
char* s = "S"; /* socket */
char* c = "C"; /* core */
char* t = "T"; /* thread */
for (ctr_sockets = 0; ctr_sockets < num_sockets; ctr_sockets++) {
/* append new socket */
sge_dstring_append_char(&d_topology, *s);
(*length)++;
/* for each socket get the number of cores */
if ((num_cores = get_number_of_cores(ctr_sockets))) {
/* for thread counting */
int* proc_ids = NULL;
int number_of_threads = 0;
/* check each core */
for (ctr_cores = 0; ctr_cores < num_cores; ctr_cores++) {
sge_dstring_append_char(&d_topology, *c);
(*length)++;
/* check if the core has threads */
if (get_processor_ids(ctr_sockets, ctr_cores, &proc_ids,
&number_of_threads)
&& number_of_threads > 1) {
/* print the threads */
for (ctr_threads = 0; ctr_threads < number_of_threads;
ctr_threads++) {
sge_dstring_append_char(&d_topology, *t);
(*length)++;
}
}
sge_free(&proc_ids);
}
}
} /* for each socket */
if ((*length) != 0) {
/* convert d_topolgy into topology */
(*length)++; /* we need `\0` at the end */
/* copy element */
(*topology) = sge_strdup(NULL, sge_dstring_get_string(&d_topology));
success = true;
}
sge_dstring_free(&d_topology);
}
}
}
return success;
}
static void set_qmaster_spool_dir(sge_bootstrap_state_class_t *thiz, const char *qmaster_spool_dir)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->qmaster_spool_dir = sge_strdup(es->qmaster_spool_dir, qmaster_spool_dir);
}
static void set_binary_path(sge_bootstrap_state_class_t *thiz, const char *binary_path)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->binary_path = sge_strdup(es->binary_path, binary_path);
}
static void set_spooling_params(sge_bootstrap_state_class_t *thiz, const char *spooling_params)
{
sge_bootstrap_state_t *es = (sge_bootstrap_state_t *) thiz->sge_bootstrap_state_handle;
es->spooling_params = sge_strdup(es->spooling_params, spooling_params);
}
static void set_sge_cell(sge_env_state_class_t *thiz, const char *sge_cell)
{
sge_env_state_t *es = (sge_env_state_t *) thiz->sge_env_state_handle;
es->sge_cell = sge_strdup(es->sge_cell, sge_cell);
}
static void set_sge_root(sge_env_state_class_t *thiz, const char *sge_root)
{
sge_env_state_t *es = (sge_env_state_t *) thiz->sge_env_state_handle;
es->sge_root = sge_strdup(es->sge_root, sge_root);
}