/*
* slurm_sprint_partition_info - output information about a specific Slurm
* partition based upon message as loaded using slurm_load_partitions
* IN part_ptr - an individual partition information record pointer
* IN one_liner - print as a single line if true
* RET out - char * containing formatted output (must be freed after call)
* NULL is returned on failure.
*/
char *slurm_sprint_partition_info ( partition_info_t * part_ptr,
int one_liner )
{
char tmp[16];
char *out = NULL;
char *allow_deny, *value;
uint16_t force, preempt_mode, val;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
char *line_end = (one_liner) ? " " : "\n ";
/****** Line 1 ******/
xstrfmtcat(out, "PartitionName=%s", part_ptr->name);
xstrcat(out, line_end);
/****** Line 2 ******/
if ((part_ptr->allow_groups == NULL) ||
(part_ptr->allow_groups[0] == '\0'))
xstrcat(out, "AllowGroups=ALL");
else {
xstrfmtcat(out, "AllowGroups=%s", part_ptr->allow_groups);
}
if (part_ptr->allow_accounts || !part_ptr->deny_accounts) {
allow_deny = "Allow";
if ((part_ptr->allow_accounts == NULL) ||
(part_ptr->allow_accounts[0] == '\0'))
value = "ALL";
else
value = part_ptr->allow_accounts;
} else {
allow_deny = "Deny";
value = part_ptr->deny_accounts;
}
xstrfmtcat(out, " %sAccounts=%s", allow_deny, value);
if (part_ptr->allow_qos || !part_ptr->deny_qos) {
allow_deny = "Allow";
if ((part_ptr->allow_qos == NULL) ||
(part_ptr->allow_qos[0] == '\0'))
value = "ALL";
else
value = part_ptr->allow_qos;
} else {
allow_deny = "Deny";
value = part_ptr->deny_qos;
}
xstrfmtcat(out, " %sQos=%s", allow_deny, value);
xstrcat(out, line_end);
/****** Line 3 ******/
if (part_ptr->allow_alloc_nodes == NULL)
xstrcat(out, "AllocNodes=ALL");
else
xstrfmtcat(out, "AllocNodes=%s", part_ptr->allow_alloc_nodes);
if (part_ptr->alternate != NULL) {
xstrfmtcat(out, " Alternate=%s", part_ptr->alternate);
}
if (part_ptr->flags & PART_FLAG_DEFAULT)
xstrcat(out, " Default=YES");
else
xstrcat(out, " Default=NO");
if (part_ptr->qos_char)
xstrfmtcat(out, " QoS=%s", part_ptr->qos_char);
else
xstrcat(out, " QoS=N/A");
xstrcat(out, line_end);
/****** Line 4 added here for BG partitions only
****** to maintain alphabetized output ******/
if (cluster_flags & CLUSTER_FLAG_BG) {
xstrfmtcat(out, "Midplanes=%s", part_ptr->nodes);
xstrcat(out, line_end);
}
/****** Line 5 ******/
if (part_ptr->default_time == INFINITE)
xstrcat(out, "DefaultTime=UNLIMITED");
else if (part_ptr->default_time == NO_VAL)
xstrcat(out, "DefaultTime=NONE");
else {
char time_line[32];
secs2time_str(part_ptr->default_time * 60, time_line,
sizeof(time_line));
xstrfmtcat(out, "DefaultTime=%s", time_line);
}
if (part_ptr->flags & PART_FLAG_NO_ROOT)
xstrcat(out, " DisableRootJobs=YES");
else
xstrcat(out, " DisableRootJobs=NO");
if (part_ptr->flags & PART_FLAG_EXCLUSIVE_USER)
xstrcat(out, " ExclusiveUser=YES");
else
xstrcat(out, " ExclusiveUser=NO");
xstrfmtcat(out, " GraceTime=%u", part_ptr->grace_time);
if (part_ptr->flags & PART_FLAG_HIDDEN)
xstrcat(out, " Hidden=YES");
else
xstrcat(out, " Hidden=NO");
xstrcat(out, line_end);
/****** Line 6 ******/
if (part_ptr->max_nodes == INFINITE)
xstrcat(out, "MaxNodes=UNLIMITED");
else {
if (cluster_flags & CLUSTER_FLAG_BG) {
convert_num_unit((float)part_ptr->max_nodes, tmp,
sizeof(tmp), UNIT_NONE, NO_VAL,
CONVERT_NUM_UNIT_EXACT);
xstrfmtcat(out, "MaxNodes=%s", tmp);
} else
xstrfmtcat(out, "MaxNodes=%u", part_ptr->max_nodes);
}
if (part_ptr->max_time == INFINITE)
xstrcat(out, " MaxTime=UNLIMITED");
else {
char time_line[32];
secs2time_str(part_ptr->max_time * 60, time_line,
sizeof(time_line));
xstrfmtcat(out, " MaxTime=%s", time_line);
}
if (cluster_flags & CLUSTER_FLAG_BG) {
convert_num_unit((float)part_ptr->min_nodes, tmp, sizeof(tmp),
UNIT_NONE, NO_VAL, CONVERT_NUM_UNIT_EXACT);
xstrfmtcat(out, " MinNodes=%s", tmp);
} else
xstrfmtcat(out, " MinNodes=%u", part_ptr->min_nodes);
if (part_ptr->flags & PART_FLAG_LLN)
xstrcat(out, " LLN=YES");
else
xstrcat(out, " LLN=NO");
if (part_ptr->max_cpus_per_node == INFINITE)
xstrcat(out, " MaxCPUsPerNode=UNLIMITED");
else {
xstrfmtcat(out, " MaxCPUsPerNode=%u",
part_ptr->max_cpus_per_node);
}
xstrcat(out, line_end);
/****** Line added here for non BG nodes
to keep with alphabetized output******/
if (!(cluster_flags & CLUSTER_FLAG_BG)) {
xstrfmtcat(out, "Nodes=%s", part_ptr->nodes);
xstrcat(out, line_end);
}
/****** Line 7 ******/
xstrfmtcat(out, "PriorityJobFactor=%u", part_ptr->priority_job_factor);
xstrfmtcat(out, " PriorityTier=%u", part_ptr->priority_tier);
if (part_ptr->flags & PART_FLAG_ROOT_ONLY)
xstrcat(out, " RootOnly=YES");
else
xstrcat(out, " RootOnly=NO");
if (part_ptr->flags & PART_FLAG_REQ_RESV)
xstrcat(out, " ReqResv=YES");
else
xstrcat(out, " ReqResv=NO");
force = part_ptr->max_share & SHARED_FORCE;
val = part_ptr->max_share & (~SHARED_FORCE);
if (val == 0)
xstrcat(out, " OverSubscribe=EXCLUSIVE");
else if (force)
xstrfmtcat(out, " OverSubscribe=FORCE:%u", val);
else if (val == 1)
xstrcat(out, " OverSubscribe=NO");
else
xstrfmtcat(out, " OverSubscribe=YES:%u", val);
xstrcat(out, line_end);
/****** Line ******/
if (part_ptr->over_time_limit == NO_VAL16)
xstrfmtcat(out, "OverTimeLimit=NONE");
else if (part_ptr->over_time_limit == (uint16_t) INFINITE)
xstrfmtcat(out, "OverTimeLimit=UNLIMITED");
else
xstrfmtcat(out, "OverTimeLimit=%u", part_ptr->over_time_limit);
preempt_mode = part_ptr->preempt_mode;
if (preempt_mode == NO_VAL16)
preempt_mode = slurm_get_preempt_mode(); /* use cluster param */
xstrfmtcat(out, " PreemptMode=%s", preempt_mode_string(preempt_mode));
xstrcat(out, line_end);
/****** Line ******/
if (part_ptr->state_up == PARTITION_UP)
xstrcat(out, "State=UP");
else if (part_ptr->state_up == PARTITION_DOWN)
xstrcat(out, "State=DOWN");
else if (part_ptr->state_up == PARTITION_INACTIVE)
xstrcat(out, "State=INACTIVE");
else if (part_ptr->state_up == PARTITION_DRAIN)
xstrcat(out, "State=DRAIN");
else
xstrcat(out, "State=UNKNOWN");
if (cluster_flags & CLUSTER_FLAG_BG) {
convert_num_unit((float)part_ptr->total_cpus, tmp, sizeof(tmp),
UNIT_NONE, NO_VAL, CONVERT_NUM_UNIT_EXACT);
xstrfmtcat(out, " TotalCPUs=%s", tmp);
} else
xstrfmtcat(out, " TotalCPUs=%u", part_ptr->total_cpus);
if (cluster_flags & CLUSTER_FLAG_BG) {
convert_num_unit((float)part_ptr->total_nodes, tmp, sizeof(tmp),
UNIT_NONE, NO_VAL, CONVERT_NUM_UNIT_EXACT);
xstrfmtcat(out, " TotalNodes=%s", tmp);
} else
xstrfmtcat(out, " TotalNodes=%u", part_ptr->total_nodes);
xstrfmtcat(out, " SelectTypeParameters=%s",
select_type_param_string(part_ptr->cr_type));
xstrcat(out, line_end);
/****** Line 9 ******/
if (part_ptr->def_mem_per_cpu & MEM_PER_CPU) {
if (part_ptr->def_mem_per_cpu == MEM_PER_CPU) {
xstrcat(out, "DefMemPerCPU=UNLIMITED");
} else {
xstrfmtcat(out, "DefMemPerCPU=%"PRIu64"",
part_ptr->def_mem_per_cpu & (~MEM_PER_CPU));
}
} else if (part_ptr->def_mem_per_cpu == 0) {
xstrcat(out, "DefMemPerNode=UNLIMITED");
} else {
xstrfmtcat(out, "DefMemPerNode=%"PRIu64"", part_ptr->def_mem_per_cpu);
}
if (part_ptr->max_mem_per_cpu & MEM_PER_CPU) {
if (part_ptr->max_mem_per_cpu == MEM_PER_CPU) {
xstrcat(out, " MaxMemPerCPU=UNLIMITED");
} else {
xstrfmtcat(out, " MaxMemPerCPU=%"PRIu64"",
part_ptr->max_mem_per_cpu & (~MEM_PER_CPU));
}
} else if (part_ptr->max_mem_per_cpu == 0) {
xstrcat(out, " MaxMemPerNode=UNLIMITED");
} else {
xstrfmtcat(out, " MaxMemPerNode=%"PRIu64"", part_ptr->max_mem_per_cpu);
}
/****** Line 10 ******/
if (part_ptr->billing_weights_str) {
xstrcat(out, line_end);
xstrfmtcat(out, "TRESBillingWeights=%s",
part_ptr->billing_weights_str);
}
if (one_liner)
xstrcat(out, "\n");
else
xstrcat(out, "\n\n");
return out;
}
/*
* Initialize context for node selection plugin
*/
extern int slurm_select_init(bool only_default)
{
int retval = SLURM_SUCCESS;
char *select_type = NULL;
int i, j, plugin_cnt;
char *plugin_type = "select";
List plugin_names = NULL;
_plugin_args_t plugin_args = {0};
if ( init_run && select_context )
return retval;
slurm_mutex_lock( &select_context_lock );
if ( select_context )
goto done;
select_type = slurm_get_select_type();
if (working_cluster_rec) {
/* just ignore warnings here */
} else {
#ifdef HAVE_NATIVE_CRAY
if (xstrcasecmp(select_type, "select/cray")) {
error("%s is incompatible with a native Cray system.",
select_type);
fatal("Use SelectType=select/cray");
}
#else
/* if (!xstrcasecmp(select_type, "select/cray")) { */
/* fatal("Requested SelectType=select/cray " */
/* "in slurm.conf, but not running on a native Cray " */
/* "system. If looking to run on a Cray " */
/* "system natively use --enable-native-cray."); */
/* } */
#endif
}
select_context_cnt = 0;
plugin_args.plugin_type = plugin_type;
plugin_args.default_plugin = select_type;
if (only_default) {
plugin_names = list_create(slurm_destroy_char);
list_append(plugin_names, xstrdup(select_type));
} else {
plugin_names = plugin_get_plugins_of_type(plugin_type);
}
if (plugin_names && (plugin_cnt = list_count(plugin_names))) {
ops = xcalloc(plugin_cnt, sizeof(slurm_select_ops_t));
select_context = xcalloc(plugin_cnt,
sizeof(plugin_context_t *));
list_for_each(plugin_names, _load_plugins, &plugin_args);
}
if (select_context_default == -1)
fatal("Can't find plugin for %s", select_type);
/* Ensure that plugin_id is valid and unique */
for (i=0; i<select_context_cnt; i++) {
for (j=i+1; j<select_context_cnt; j++) {
if (*(ops[i].plugin_id) !=
*(ops[j].plugin_id))
continue;
fatal("SelectPlugins: Duplicate plugin_id %u for "
"%s and %s",
*(ops[i].plugin_id),
select_context[i]->type,
select_context[j]->type);
}
if (*(ops[i].plugin_id) < 100) {
fatal("SelectPlugins: Invalid plugin_id %u (<100) %s",
*(ops[i].plugin_id),
select_context[i]->type);
}
}
init_run = true;
done:
slurm_mutex_unlock( &select_context_lock );
if (!working_cluster_rec) {
if (select_running_linear_based()) {
uint16_t cr_type = slurm_get_select_type_param();
if (cr_type & (CR_CPU | CR_CORE | CR_SOCKET)) {
fatal("Invalid SelectTypeParameters for "
"%s: %s (%u), it can't contain "
"CR_(CPU|CORE|SOCKET).",
select_type,
select_type_param_string(cr_type),
cr_type);
}
}
}
xfree(select_type);
FREE_NULL_LIST(plugin_names);
return retval;
}
extern void *slurm_ctl_conf_2_key_pairs (slurm_ctl_conf_t* slurm_ctl_conf_ptr)
{
List ret_list = NULL;
config_key_pair_t *key_pair;
char tmp_str[128];
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
if ( slurm_ctl_conf_ptr == NULL )
return NULL;
ret_list = list_create(destroy_config_key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageBackupHost");
key_pair->value =
xstrdup(slurm_ctl_conf_ptr->accounting_storage_backup_host);
list_append(ret_list, key_pair);
accounting_enforce_string(slurm_ctl_conf_ptr->
accounting_storage_enforce,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageEnforce");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageHost");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_host);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageLoc");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_loc);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->accounting_storage_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStoragePort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStorageUser");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->accounting_storage_user);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AccountingStoreJobComment");
if (slurm_ctl_conf_ptr->acctng_store_job_comment)
key_pair->value = xstrdup("YES");
else
key_pair->value = xstrdup("NO");
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherEnergyType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->acct_gather_energy_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherFilesystemType");
key_pair->value =
xstrdup(slurm_ctl_conf_ptr->acct_gather_filesystem_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherInfinibandType");
key_pair->value =
xstrdup(slurm_ctl_conf_ptr->acct_gather_infiniband_type);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->acct_gather_node_freq);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherNodeFreq");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AcctGatherProfileType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->acct_gather_profile_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AuthInfo");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->authinfo);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("AuthType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->authtype);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BackupAddr");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->backup_addr);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BackupController");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->backup_controller);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->batch_start_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BatchStartTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
slurm_make_time_str((time_t *)&slurm_ctl_conf_ptr->boot_time,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("BOOT_TIME");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CacheGroups");
if (slurm_ctl_conf_ptr->group_info & GROUP_CACHE)
key_pair->value = xstrdup("1");
else
key_pair->value = xstrdup("0");
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CheckpointType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->checkpoint_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ClusterName");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->cluster_name);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->complete_wait);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CompleteWait");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ControlAddr");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->control_addr);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ControlMachine");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->control_machine);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("CryptoType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->crypto_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DebugFlags");
key_pair->value = debug_flags2str(slurm_ctl_conf_ptr->debug_flags);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->def_mem_per_cpu & MEM_PER_CPU) {
key_pair->name = xstrdup("DefMemPerCPU");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->def_mem_per_cpu &
(~MEM_PER_CPU));
key_pair->value = xstrdup(tmp_str);
} else if (slurm_ctl_conf_ptr->def_mem_per_cpu) {
key_pair->name = xstrdup("DefMemPerNode");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->def_mem_per_cpu);
key_pair->value = xstrdup(tmp_str);
} else {
key_pair->name = xstrdup("DefMemPerNode");
key_pair->value = xstrdup("UNLIMITED");
}
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
key_pair->name = xstrdup("DisableRootJobs");
if (slurm_ctl_conf_ptr->disable_root_jobs)
key_pair->value = xstrdup("YES");
else
key_pair->value = xstrdup("NO");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->dynalloc_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("DynAllocPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
key_pair->name = xstrdup("EnforcePartLimits");
if (slurm_ctl_conf_ptr->enforce_part_limits)
key_pair->value = xstrdup("YES");
else
key_pair->value = xstrdup("NO");
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("Epilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->epilog);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u usec",
slurm_ctl_conf_ptr->epilog_msg_time);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("EpilogMsgTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("EpilogSlurmctld");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->epilog_slurmctld);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ExtSensorsType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->ext_sensors_type);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->ext_sensors_freq);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ExtSensorsFreq");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (strcmp(slurm_ctl_conf_ptr->priority_type, "priority/basic")) {
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->fs_dampening_factor);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("FairShareDampeningFactor");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->fast_schedule);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("FastSchedule");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->first_job_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("FirstJobId");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->get_env_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GetEnvTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GresTypes");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->gres_plugins);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GroupUpdateForce");
if (slurm_ctl_conf_ptr->group_info & GROUP_FORCE)
key_pair->value = xstrdup("1");
else
key_pair->value = xstrdup("0");
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->group_info & GROUP_TIME_MASK);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("GroupUpdateTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->hash_val != NO_VAL) {
if (slurm_ctl_conf_ptr->hash_val == slurm_get_hash_val())
snprintf(tmp_str, sizeof(tmp_str), "Match");
else {
snprintf(tmp_str, sizeof(tmp_str),
"Different Ours=0x%x Slurmctld=0x%x",
slurm_get_hash_val(),
slurm_ctl_conf_ptr->hash_val);
}
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HASH_VAL");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->health_check_interval);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HealthCheckInterval");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HealthCheckNodeState");
key_pair->value = health_check_node_state_str(slurm_ctl_conf_ptr->
health_check_node_state);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HealthCheckProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->health_check_program);
list_append(ret_list, key_pair);
if (cluster_flags & CLUSTER_FLAG_XCPU) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("HAVE_XCPU");
key_pair->value = xstrdup("1");
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->inactive_limit);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("InactiveLimit");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobAcctGatherFrequency");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_acct_gather_freq);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobAcctGatherType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_acct_gather_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobAcctGatherParams");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_acct_gather_params);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCheckpointDir");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_ckpt_dir);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompHost");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_host);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompLoc");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_loc);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->job_comp_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCompUser");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_comp_user);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobContainerPlugin");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_container_plugin);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCredentialPrivateKey");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->
job_credential_private_key);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobCredentialPublicCertificate");
key_pair->value = xstrdup(
slurm_ctl_conf_ptr->job_credential_public_certificate);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->job_file_append);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobFileAppend");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->job_requeue);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobRequeue");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("JobSubmitPlugins");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->job_submit_plugins);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->keep_alive_time == (uint16_t) NO_VAL)
snprintf(tmp_str, sizeof(tmp_str), "SYSTEM_DEFAULT");
else {
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->keep_alive_time);
}
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("KeepAliveTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->kill_on_bad_exit);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("KillOnBadExit");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->kill_wait);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("KillWait");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("LaunchType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->launch_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("Licenses");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->licenses);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("LicensesUsed");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->licenses_used);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MailProg");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->mail_prog);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_array_sz);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxArraySize");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_job_cnt);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxJobCount");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_job_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxJobId");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->max_mem_per_cpu & MEM_PER_CPU) {
key_pair->name = xstrdup("MaxMemPerCPU");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_mem_per_cpu & (~MEM_PER_CPU));
key_pair->value = xstrdup(tmp_str);
} else if (slurm_ctl_conf_ptr->max_mem_per_cpu) {
key_pair->name = xstrdup("MaxMemPerNode");
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_mem_per_cpu);
key_pair->value = xstrdup(tmp_str);
} else {
key_pair->name = xstrdup("MaxMemPerNode");
key_pair->value = xstrdup("UNLIMITED");
}
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_step_cnt);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxStepCount");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->max_tasks_per_node);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MaxTasksPerNode");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->msg_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MessageTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->min_job_age);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MinJobAge");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MpiDefault");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->mpi_default);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MpiParams");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->mpi_params);
list_append(ret_list, key_pair);
if (cluster_flags & CLUSTER_FLAG_MULTSD) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("MULTIPLE_SLURMD");
key_pair->value = xstrdup("1");
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->next_job_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("NEXT_JOB_ID");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->over_time_limit == (uint16_t) INFINITE)
snprintf(tmp_str, sizeof(tmp_str), "UNLIMITED");
else
snprintf(tmp_str, sizeof(tmp_str), "%u min",
slurm_ctl_conf_ptr->over_time_limit);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("OverTimeLimit");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PluginDir");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->plugindir);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PlugStackConfig");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->plugstack);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PreemptMode");
key_pair->value = xstrdup(preempt_mode_string(slurm_ctl_conf_ptr->
preempt_mode));
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PreemptType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->preempt_type);
list_append(ret_list, key_pair);
if (strcmp(slurm_ctl_conf_ptr->priority_type, "priority/basic") == 0) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->priority_type);
list_append(ret_list, key_pair);
} else {
secs2time_str((time_t) slurm_ctl_conf_ptr->priority_decay_hl,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityDecayHalfLife");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
secs2time_str((time_t)slurm_ctl_conf_ptr->priority_calc_period,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityCalcPeriod");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_favor_small);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityFavorSmall");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_flags);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityFlags");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
secs2time_str((time_t) slurm_ctl_conf_ptr->priority_max_age,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityMaxAge");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityUsageResetPeriod");
key_pair->value = xstrdup(_reset_period_str(
slurm_ctl_conf_ptr->
priority_reset_period));
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->priority_type);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_age);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightAge");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_fs);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightFairShare");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_js);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightJobSize");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_part);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightPartition");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->priority_weight_qos);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PriorityWeightQOS");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
}
private_data_string(slurm_ctl_conf_ptr->private_data,
tmp_str, sizeof(tmp_str));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PrivateData");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ProctrackType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->proctrack_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("Prolog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->prolog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PrologSlurmctld");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->prolog_slurmctld);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->propagate_prio_process);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PropagatePrioProcess");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PropagateResourceLimits");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->propagate_rlimits);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("PropagateResourceLimitsExcept");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->
propagate_rlimits_except);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("RebootProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->reboot_program);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ReconfigFlags");
key_pair->value =
reconfig_flags2str(slurm_ctl_conf_ptr->reconfig_flags);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResumeProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->resume_program);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u nodes/min",
slurm_ctl_conf_ptr->resume_rate);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResumeRate");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->resume_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResumeTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResvEpilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->resv_epilog);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->resv_over_run == (uint16_t) INFINITE)
snprintf(tmp_str, sizeof(tmp_str), "UNLIMITED");
else
snprintf(tmp_str, sizeof(tmp_str), "%u min",
slurm_ctl_conf_ptr->resv_over_run);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResvOverRun");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ResvProlog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->resv_prolog);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->ret2service);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("ReturnToService");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SallocDefaultCommand");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->salloc_default_command);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerParameters");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->sched_params);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->schedport);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->schedrootfltr);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerRootFilter");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->sched_time_slice);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerTimeSlice");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SchedulerType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->schedtype);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SelectType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->select_type);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->select_type_param) {
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SelectTypeParameters");
key_pair->value = xstrdup(
select_type_param_string(slurm_ctl_conf_ptr->
select_type_param));
list_append(ret_list, key_pair);
}
snprintf(tmp_str, sizeof(tmp_str), "%s(%u)",
slurm_ctl_conf_ptr->slurm_user_name,
slurm_ctl_conf_ptr->slurm_user_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmUser");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%s",
log_num2string(slurm_ctl_conf_ptr->slurmctld_debug));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldDebug");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldLogFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmctld_logfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmSchedLogFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->sched_logfile);
list_append(ret_list, key_pair);
if (slurm_ctl_conf_ptr->slurmctld_port_count > 1) {
uint32_t high_port = slurm_ctl_conf_ptr->slurmctld_port;
high_port += (slurm_ctl_conf_ptr->slurmctld_port_count - 1);
snprintf(tmp_str, sizeof(tmp_str), "%u-%u",
slurm_ctl_conf_ptr->slurmctld_port, high_port);
} else {
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->slurmctld_port);
}
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->slurmctld_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%s",
log_num2string(slurm_ctl_conf_ptr->slurmd_debug));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdDebug");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdLogFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_logfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdPidFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_pidfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdPlugstack");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_plugstack);
list_append(ret_list, key_pair);
#ifndef MULTIPLE_SLURMD
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->slurmd_port);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdPort");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
#endif
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdSpoolDir");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmd_spooldir);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->slurmd_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%s(%u)",
slurm_ctl_conf_ptr->slurmd_user_name,
slurm_ctl_conf_ptr->slurmd_user_id);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmdUser");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->sched_log_level);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmSchedLogLevel");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldPidFile");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmctld_pidfile);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SlurmctldPlugstack");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurmctld_plugstack);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SLURM_CONF");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->slurm_conf);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SLURM_VERSION");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->version);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SrunEpilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->srun_epilog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SrunProlog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->srun_prolog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("StateSaveLocation");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->state_save_location);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendExcNodes");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->suspend_exc_nodes);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendExcParts");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->suspend_exc_parts);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->suspend_program);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u nodes/min",
slurm_ctl_conf_ptr->suspend_rate);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendRate");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
if (!slurm_ctl_conf_ptr->suspend_time)
snprintf(tmp_str, sizeof(tmp_str), "NONE");
else
snprintf(tmp_str, sizeof(tmp_str), "%d sec",
((int)slurm_ctl_conf_ptr->suspend_time - 1));
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->suspend_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SuspendTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("SwitchType");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->switch_type);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskEpilog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->task_epilog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskPlugin");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->task_plugin);
list_append(ret_list, key_pair);
slurm_sprint_cpu_bind_type(tmp_str,
slurm_ctl_conf_ptr->task_plugin_param);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskPluginParam");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TaskProlog");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->task_prolog);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TmpFS");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->tmp_fs);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TopologyPlugin");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->topology_plugin);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->track_wckey);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TrackWCKey");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->tree_width);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("TreeWidth");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u",
slurm_ctl_conf_ptr->use_pam);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("UsePam");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("UnkillableStepProgram");
key_pair->value = xstrdup(slurm_ctl_conf_ptr->unkillable_program);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->unkillable_timeout);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("UnkillableStepTimeout");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u percent",
slurm_ctl_conf_ptr->vsize_factor);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("VSizeFactor");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
snprintf(tmp_str, sizeof(tmp_str), "%u sec",
slurm_ctl_conf_ptr->wait_time);
key_pair = xmalloc(sizeof(config_key_pair_t));
key_pair->name = xstrdup("WaitTime");
key_pair->value = xstrdup(tmp_str);
list_append(ret_list, key_pair);
return (void *)ret_list;
}
/*
* Initialize context for node selection plugin
*/
extern int slurm_select_init(bool only_default)
{
int retval = SLURM_SUCCESS;
char *type = NULL;
int i, j, len;
DIR *dirp;
struct dirent *e;
char *dir_array = NULL, *head = NULL;
char *plugin_type = "select";
if ( init_run && select_context )
return retval;
slurm_mutex_lock( &select_context_lock );
if ( select_context )
goto done;
type = slurm_get_select_type();
if (working_cluster_rec) {
/* just ignore warnings here */
} else {
#ifdef HAVE_BG
if (xstrcasecmp(type, "select/bluegene")) {
error("%s is incompatible with BlueGene", type);
fatal("Use SelectType=select/bluegene");
}
#else
if (!xstrcasecmp(type, "select/bluegene")) {
fatal("Requested SelectType=select/bluegene "
"in slurm.conf, but not running on a BG[L|P|Q] "
"system. If looking to emulate a BG[L|P|Q] "
"system use --enable-bgl-emulation or "
"--enable-bgp-emulation respectively.");
}
#endif
#ifdef HAVE_ALPS_CRAY
if (xstrcasecmp(type, "select/alps")) {
error("%s is incompatible with Cray system "
"running alps", type);
fatal("Use SelectType=select/alps");
}
#else
if (!xstrcasecmp(type, "select/alps")) {
fatal("Requested SelectType=select/alps "
"in slurm.conf, but not running on a ALPS Cray "
"system. If looking to emulate a Alps Cray "
"system use --enable-alps-cray-emulation.");
}
#endif
#ifdef HAVE_NATIVE_CRAY
if (xstrcasecmp(type, "select/cray")) {
error("%s is incompatible with a native Cray system.",
type);
fatal("Use SelectType=select/cray");
}
#else
/* if (!xstrcasecmp(type, "select/cray")) { */
/* fatal("Requested SelectType=select/cray " */
/* "in slurm.conf, but not running on a native Cray " */
/* "system. If looking to run on a Cray " */
/* "system natively use --enable-native-cray."); */
/* } */
#endif
}
select_context_cnt = 0;
if (only_default) {
ops = xmalloc(sizeof(slurm_select_ops_t));
select_context = xmalloc(sizeof(plugin_context_t));
if ((select_context[0] = plugin_context_create(
plugin_type, type, (void **)&ops[0],
node_select_syms, sizeof(node_select_syms)))) {
select_context_default = 0;
select_context_cnt++;
}
goto skip_load_all;
}
if (!(dir_array = slurm_get_plugin_dir())) {
error("plugin_load_and_link: No plugin dir given");
goto done;
}
head = dir_array;
for (i=0; ; i++) {
bool got_colon = 0;
if (dir_array[i] == ':') {
dir_array[i] = '\0';
got_colon = 1;
} else if (dir_array[i] != '\0')
continue;
/* Open the directory. */
if (!(dirp = opendir(head))) {
error("cannot open plugin directory %s", head);
goto done;
}
while (1) {
char full_name[128];
if (!(e = readdir( dirp )))
break;
/* Check only files with select_ in them. */
if (xstrncmp(e->d_name, "select_", 7))
continue;
len = strlen(e->d_name);
#if defined(__CYGWIN__)
len -= 4;
#else
len -= 3;
#endif
/* Check only shared object files */
if (xstrcmp(e->d_name+len,
#if defined(__CYGWIN__)
".dll"
#else
".so"
#endif
))
continue;
/* add one for the / */
len++;
xassert(len<sizeof(full_name));
snprintf(full_name, len, "select/%s", e->d_name+7);
for (j=0; j<select_context_cnt; j++) {
if (!xstrcmp(full_name,
select_context[j]->type))
break;
}
if (j >= select_context_cnt) {
xrealloc(ops,
(sizeof(slurm_select_ops_t) *
(select_context_cnt + 1)));
xrealloc(select_context,
(sizeof(plugin_context_t) *
(select_context_cnt + 1)));
select_context[select_context_cnt] =
plugin_context_create(
plugin_type, full_name,
(void **)&ops[
select_context_cnt],
node_select_syms,
sizeof(node_select_syms));
if (select_context[select_context_cnt]) {
/* set the default */
if (!xstrcmp(full_name, type))
select_context_default =
select_context_cnt;
select_context_cnt++;
}
}
}
closedir(dirp);
if (got_colon) {
head = dir_array + i + 1;
} else
break;
}
skip_load_all:
if (select_context_default == -1)
fatal("Can't find plugin for %s", type);
/* Insure that plugin_id is valid and unique */
for (i=0; i<select_context_cnt; i++) {
for (j=i+1; j<select_context_cnt; j++) {
if (*(ops[i].plugin_id) !=
*(ops[j].plugin_id))
continue;
fatal("SelectPlugins: Duplicate plugin_id %u for "
"%s and %s",
*(ops[i].plugin_id),
select_context[i]->type,
select_context[j]->type);
}
if (*(ops[i].plugin_id) < 100) {
fatal("SelectPlugins: Invalid plugin_id %u (<100) %s",
*(ops[i].plugin_id),
select_context[i]->type);
}
}
init_run = true;
done:
slurm_mutex_unlock( &select_context_lock );
if (!working_cluster_rec) {
if (select_running_linear_based()) {
uint16_t cr_type = slurm_get_select_type_param();
if (cr_type & (CR_CPU | CR_CORE | CR_SOCKET)) {
fatal("Invalid SelectTypeParameters for "
"%s: %s (%u), it's can't contain "
"CR_(CPU|CORE|SOCKET).",
type,
select_type_param_string(cr_type),
cr_type);
}
}
}
xfree(type);
xfree(dir_array);
return retval;
}
