static void _layout_resv_record(GtkTreeView *treeview,
sview_resv_info_t *sview_resv_info,
int update)
{
GtkTreeIter iter;
char time_buf[20];
reserve_info_t *resv_ptr = sview_resv_info->resv_ptr;
char *temp_char = NULL;
GtkTreeStore *treestore =
GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_ACCOUNTS),
resv_ptr->accounts);
secs2time_str((uint32_t)difftime(resv_ptr->end_time,
resv_ptr->start_time),
time_buf, sizeof(time_buf));
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_DURATION),
time_buf);
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_FEATURES),
resv_ptr->features);
temp_char = reservation_flags_string(resv_ptr->flags);
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_FLAGS),
temp_char);
xfree(temp_char);
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_LICENSES),
resv_ptr->licenses);
/* NOTE: node_cnt in reservation info from slurmctld ONE number */
convert_num_unit((float)resv_ptr->node_cnt,
time_buf, sizeof(time_buf), UNIT_NONE);
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_NODE_CNT),
time_buf);
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_NODELIST),
resv_ptr->node_list);
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_PARTITION),
resv_ptr->partition);
slurm_make_time_str((time_t *)&resv_ptr->end_time, time_buf,
sizeof(time_buf));
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_TIME_END),
time_buf);
slurm_make_time_str((time_t *)&resv_ptr->start_time, time_buf,
sizeof(time_buf));
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_TIME_START),
time_buf);
add_display_treestore_line(update, treestore, &iter,
find_col_name(display_data_resv,
SORTID_USERS),
resv_ptr->users);
}
/*
* 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 tmp1[16], tmp2[16];
char tmp_line[MAXHOSTRANGELEN];
char *out = NULL;
char *allow_deny, *value;
uint16_t force, preempt_mode, val;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
/****** Line 1 ******/
snprintf(tmp_line, sizeof(tmp_line),
"PartitionName=%s",
part_ptr->name);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 2 ******/
if ((part_ptr->allow_groups == NULL) ||
(part_ptr->allow_groups[0] == '\0'))
sprintf(tmp_line, "AllowGroups=ALL");
else {
snprintf(tmp_line, sizeof(tmp_line),
"AllowGroups=%s", part_ptr->allow_groups);
}
xstrcat(out, tmp_line);
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;
}
snprintf(tmp_line, sizeof(tmp_line),
" %sAccounts=%s", allow_deny, value);
xstrcat(out, tmp_line);
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;
}
snprintf(tmp_line, sizeof(tmp_line),
" %sQos=%s", allow_deny, value);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 3 ******/
if (part_ptr->allow_alloc_nodes == NULL)
snprintf(tmp_line, sizeof(tmp_line), "AllocNodes=%s","ALL");
else
snprintf(tmp_line, sizeof(tmp_line), "AllocNodes=%s",
part_ptr->allow_alloc_nodes);
xstrcat(out, tmp_line);
if (part_ptr->alternate != NULL) {
snprintf(tmp_line, sizeof(tmp_line), " Alternate=%s",
part_ptr->alternate);
xstrcat(out, tmp_line);
}
if (part_ptr->flags & PART_FLAG_DEFAULT)
sprintf(tmp_line, " Default=YES");
else
sprintf(tmp_line, " Default=NO");
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 4 added here for BG partitions only
****** to maintain alphabetized output ******/
if (cluster_flags & CLUSTER_FLAG_BG) {
snprintf(tmp_line, sizeof(tmp_line), "BasePartitions=%s",
part_ptr->nodes);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
}
/****** Line 5 ******/
if (part_ptr->default_time == INFINITE)
sprintf(tmp_line, "DefaultTime=UNLIMITED");
else if (part_ptr->default_time == NO_VAL)
sprintf(tmp_line, "DefaultTime=NONE");
else {
char time_line[32];
secs2time_str(part_ptr->default_time * 60, time_line,
sizeof(time_line));
sprintf(tmp_line, "DefaultTime=%s", time_line);
}
xstrcat(out, tmp_line);
if (part_ptr->flags & PART_FLAG_NO_ROOT)
sprintf(tmp_line, " DisableRootJobs=YES");
else
sprintf(tmp_line, " DisableRootJobs=NO");
xstrcat(out, tmp_line);
sprintf(tmp_line, " GraceTime=%u", part_ptr->grace_time);
xstrcat(out, tmp_line);
if (part_ptr->flags & PART_FLAG_HIDDEN)
sprintf(tmp_line, " Hidden=YES");
else
sprintf(tmp_line, " Hidden=NO");
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 6 ******/
if (part_ptr->max_nodes == INFINITE)
sprintf(tmp_line, "MaxNodes=UNLIMITED");
else {
if (cluster_flags & CLUSTER_FLAG_BG)
convert_num_unit((float)part_ptr->max_nodes,
tmp1, sizeof(tmp1), UNIT_NONE);
else
snprintf(tmp1, sizeof(tmp1),"%u", part_ptr->max_nodes);
sprintf(tmp_line, "MaxNodes=%s", tmp1);
}
xstrcat(out, tmp_line);
if (part_ptr->max_time == INFINITE)
sprintf(tmp_line, " MaxTime=UNLIMITED");
else {
char time_line[32];
secs2time_str(part_ptr->max_time * 60, time_line,
sizeof(time_line));
sprintf(tmp_line, " MaxTime=%s", time_line);
}
xstrcat(out, tmp_line);
if (cluster_flags & CLUSTER_FLAG_BG)
convert_num_unit((float)part_ptr->min_nodes, tmp1, sizeof(tmp1),
UNIT_NONE);
else
snprintf(tmp1, sizeof(tmp1), "%u", part_ptr->min_nodes);
sprintf(tmp_line, " MinNodes=%s", tmp1);
xstrcat(out, tmp_line);
if (part_ptr->max_cpus_per_node == INFINITE)
sprintf(tmp_line, " MaxCPUsPerNode=UNLIMITED");
else {
sprintf(tmp_line, " MaxCPUsPerNode=%u",
part_ptr->max_cpus_per_node);
}
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line added here for non BG nodes
to keep with alphabetized output******/
if (!(cluster_flags & CLUSTER_FLAG_BG)) {
snprintf(tmp_line, sizeof(tmp_line), "Nodes=%s",
part_ptr->nodes);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
}
/****** Line 7 ******/
sprintf(tmp_line, "Priority=%u", part_ptr->priority);
xstrcat(out, tmp_line);
if (part_ptr->flags & PART_FLAG_ROOT_ONLY)
sprintf(tmp_line, " RootOnly=YES");
else
sprintf(tmp_line, " RootOnly=NO");
xstrcat(out, tmp_line);
if (part_ptr->flags & PART_FLAG_REQ_RESV)
sprintf(tmp_line, " ReqResv=YES");
else
sprintf(tmp_line, " ReqResv=NO");
xstrcat(out, tmp_line);
force = part_ptr->max_share & SHARED_FORCE;
val = part_ptr->max_share & (~SHARED_FORCE);
if (val == 0)
xstrcat(out, " Shared=EXCLUSIVE");
else if (force) {
sprintf(tmp_line, " Shared=FORCE:%u", val);
xstrcat(out, tmp_line);
} else if (val == 1)
xstrcat(out, " Shared=NO");
else {
sprintf(tmp_line, " Shared=YES:%u", val);
xstrcat(out, tmp_line);
}
preempt_mode = part_ptr->preempt_mode;
if (preempt_mode == (uint16_t) NO_VAL)
preempt_mode = slurm_get_preempt_mode(); /* use cluster param */
snprintf(tmp_line, sizeof(tmp_line), " PreemptMode=%s",
preempt_mode_string(preempt_mode));
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 8 ******/
if (part_ptr->state_up == PARTITION_UP)
sprintf(tmp_line, "State=UP");
else if (part_ptr->state_up == PARTITION_DOWN)
sprintf(tmp_line, "State=DOWN");
else if (part_ptr->state_up == PARTITION_INACTIVE)
sprintf(tmp_line, "State=INACTIVE");
else if (part_ptr->state_up == PARTITION_DRAIN)
sprintf(tmp_line, "State=DRAIN");
else
sprintf(tmp_line, "State=UNKNOWN");
xstrcat(out, tmp_line);
if (cluster_flags & CLUSTER_FLAG_BG)
convert_num_unit((float)part_ptr->total_cpus, tmp1,
sizeof(tmp1), UNIT_NONE);
else
snprintf(tmp1, sizeof(tmp1), "%u", part_ptr->total_cpus);
sprintf(tmp_line, " TotalCPUs=%s", tmp1);
xstrcat(out, tmp_line);
if (cluster_flags & CLUSTER_FLAG_BG)
convert_num_unit((float)part_ptr->total_nodes, tmp2,
sizeof(tmp2), UNIT_NONE);
else
snprintf(tmp2, sizeof(tmp2), "%u", part_ptr->total_nodes);
sprintf(tmp_line, " TotalNodes=%s", tmp2);
xstrcat(out, tmp_line);
if (part_ptr->cr_type & CR_CORE)
sprintf(tmp_line, " SelectTypeParameters=CR_CORE");
else if (part_ptr->cr_type & CR_SOCKET)
sprintf(tmp_line, " SelectTypeParameters=CR_SOCKET");
else
sprintf(tmp_line, " SelectTypeParameters=N/A");
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 9 ******/
if (part_ptr->def_mem_per_cpu & MEM_PER_CPU) {
snprintf(tmp_line, sizeof(tmp_line), "DefMemPerCPU=%u",
part_ptr->def_mem_per_cpu & (~MEM_PER_CPU));
xstrcat(out, tmp_line);
} else if (part_ptr->def_mem_per_cpu == 0) {
xstrcat(out, "DefMemPerNode=UNLIMITED");
} else {
snprintf(tmp_line, sizeof(tmp_line), "DefMemPerNode=%u",
part_ptr->def_mem_per_cpu);
xstrcat(out, tmp_line);
}
if (part_ptr->max_mem_per_cpu & MEM_PER_CPU) {
snprintf(tmp_line, sizeof(tmp_line), " MaxMemPerCPU=%u",
part_ptr->max_mem_per_cpu & (~MEM_PER_CPU));
xstrcat(out, tmp_line);
} else if (part_ptr->max_mem_per_cpu == 0) {
xstrcat(out, " MaxMemPerNode=UNLIMITED");
} else {
snprintf(tmp_line, sizeof(tmp_line), " MaxMemPerNode=%u",
part_ptr->max_mem_per_cpu);
xstrcat(out, tmp_line);
}
if (one_liner)
xstrcat(out, "\n");
else
xstrcat(out, "\n\n");
return out;
}
/*
* slurm_sprint_job_info - output information about a specific Slurm
* job based upon message as loaded using slurm_load_jobs
* IN job_ptr - an individual job 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.
*/
extern char *
slurm_sprint_job_info ( job_info_t * job_ptr, int one_liner )
{
int i, j;
char time_str[32], *group_name, *user_name;
char tmp1[128], tmp2[128], tmp3[128], tmp4[128], tmp5[128], *tmp6_ptr;
char tmp_line[512];
char *ionodes = NULL;
uint16_t exit_status = 0, term_sig = 0;
job_resources_t *job_resrcs = job_ptr->job_resrcs;
char *out = NULL;
time_t run_time;
uint32_t min_nodes, max_nodes = 0;
char *nodelist = "NodeList";
bitstr_t *core_bitmap;
char *host;
int sock_inx, sock_reps, last;
int abs_node_inx, rel_node_inx;
int bit_inx, bit_reps;
uint32_t *last_mem_alloc_ptr = NULL;
uint32_t last_mem_alloc = NO_VAL;
char *last_hosts;
hostlist_t hl, hl_last;
char select_buf[122];
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
if (cluster_flags & CLUSTER_FLAG_BG) {
nodelist = "MidplaneList";
select_g_select_jobinfo_get(job_ptr->select_jobinfo,
SELECT_JOBDATA_IONODES,
&ionodes);
}
/****** Line 1 ******/
snprintf(tmp_line, sizeof(tmp_line), "JobId=%u ", job_ptr->job_id);
out = xstrdup(tmp_line);
if (job_ptr->array_job_id) {
snprintf(tmp_line, sizeof(tmp_line),
"ArrayJobId=%u ArrayTaskId=%u ",
job_ptr->array_job_id, job_ptr->array_task_id);
xstrcat(out, tmp_line);
}
snprintf(tmp_line, sizeof(tmp_line), "Name=%s", job_ptr->name);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 2 ******/
user_name = uid_to_string((uid_t) job_ptr->user_id);
group_name = gid_to_string((gid_t) job_ptr->group_id);
snprintf(tmp_line, sizeof(tmp_line),
"UserId=%s(%u) GroupId=%s(%u)",
user_name, job_ptr->user_id, group_name, job_ptr->group_id);
xfree(user_name);
xfree(group_name);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 3 ******/
snprintf(tmp_line, sizeof(tmp_line),
"Priority=%u Account=%s QOS=%s",
job_ptr->priority, job_ptr->account, job_ptr->qos);
xstrcat(out, tmp_line);
if (slurm_get_track_wckey()) {
snprintf(tmp_line, sizeof(tmp_line),
" WCKey=%s", job_ptr->wckey);
xstrcat(out, tmp_line);
}
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 4 ******/
if (job_ptr->state_desc) {
/* Replace white space with underscore for easier parsing */
for (j=0; job_ptr->state_desc[j]; j++) {
if (isspace((int)job_ptr->state_desc[j]))
job_ptr->state_desc[j] = '_';
}
tmp6_ptr = job_ptr->state_desc;
} else
tmp6_ptr = job_reason_string(job_ptr->state_reason);
snprintf(tmp_line, sizeof(tmp_line),
"JobState=%s Reason=%s Dependency=%s",
job_state_string(job_ptr->job_state), tmp6_ptr,
job_ptr->dependency);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 5 ******/
snprintf(tmp_line, sizeof(tmp_line),
"Requeue=%u Restarts=%u BatchFlag=%u ",
job_ptr->requeue, job_ptr->restart_cnt, job_ptr->batch_flag);
xstrcat(out, tmp_line);
if (WIFSIGNALED(job_ptr->exit_code))
term_sig = WTERMSIG(job_ptr->exit_code);
exit_status = WEXITSTATUS(job_ptr->exit_code);
snprintf(tmp_line, sizeof(tmp_line),
"ExitCode=%u:%u", exit_status, term_sig);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 5a (optional) ******/
if (!(job_ptr->show_flags & SHOW_DETAIL))
goto line6;
if (WIFSIGNALED(job_ptr->derived_ec))
term_sig = WTERMSIG(job_ptr->derived_ec);
else
term_sig = 0;
exit_status = WEXITSTATUS(job_ptr->derived_ec);
snprintf(tmp_line, sizeof(tmp_line),
"DerivedExitCode=%u:%u", exit_status, term_sig);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 6 ******/
line6:
snprintf(tmp_line, sizeof(tmp_line), "RunTime=");
xstrcat(out, tmp_line);
if (IS_JOB_PENDING(job_ptr))
run_time = 0;
else if (IS_JOB_SUSPENDED(job_ptr))
run_time = job_ptr->pre_sus_time;
else {
time_t end_time;
if (IS_JOB_RUNNING(job_ptr) || (job_ptr->end_time == 0))
end_time = time(NULL);
else
end_time = job_ptr->end_time;
if (job_ptr->suspend_time) {
run_time = (time_t)
(difftime(end_time, job_ptr->suspend_time)
+ job_ptr->pre_sus_time);
} else
run_time = (time_t)
difftime(end_time, job_ptr->start_time);
}
secs2time_str(run_time, tmp1, sizeof(tmp1));
sprintf(tmp_line, "%s ", tmp1);
xstrcat(out, tmp_line);
snprintf(tmp_line, sizeof(tmp_line), "TimeLimit=");
xstrcat(out, tmp_line);
if (job_ptr->time_limit == NO_VAL)
sprintf(tmp_line, "Partition_Limit");
else {
mins2time_str(job_ptr->time_limit, tmp_line,
sizeof(tmp_line));
}
xstrcat(out, tmp_line);
snprintf(tmp_line, sizeof(tmp_line), " TimeMin=");
xstrcat(out, tmp_line);
if (job_ptr->time_min == 0)
sprintf(tmp_line, "N/A");
else {
mins2time_str(job_ptr->time_min, tmp_line,
sizeof(tmp_line));
}
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 7 ******/
slurm_make_time_str((time_t *)&job_ptr->submit_time, time_str,
sizeof(time_str));
snprintf(tmp_line, sizeof(tmp_line), "SubmitTime=%s ", time_str);
xstrcat(out, tmp_line);
slurm_make_time_str((time_t *)&job_ptr->eligible_time, time_str,
sizeof(time_str));
snprintf(tmp_line, sizeof(tmp_line), "EligibleTime=%s", time_str);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 8 (optional) ******/
if (job_ptr->resize_time) {
slurm_make_time_str((time_t *)&job_ptr->resize_time, time_str,
sizeof(time_str));
snprintf(tmp_line, sizeof(tmp_line), "ResizeTime=%s", time_str);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
}
/****** Line 9 ******/
slurm_make_time_str((time_t *)&job_ptr->start_time, time_str,
sizeof(time_str));
snprintf(tmp_line, sizeof(tmp_line), "StartTime=%s ", time_str);
xstrcat(out, tmp_line);
snprintf(tmp_line, sizeof(tmp_line), "EndTime=");
xstrcat(out, tmp_line);
if ((job_ptr->time_limit == INFINITE) &&
(job_ptr->end_time > time(NULL)))
sprintf(tmp_line, "Unknown");
else {
slurm_make_time_str ((time_t *)&job_ptr->end_time, time_str,
sizeof(time_str));
sprintf(tmp_line, "%s", time_str);
}
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 10 ******/
if (job_ptr->preempt_time == 0)
sprintf(tmp_line, "PreemptTime=None ");
else {
slurm_make_time_str((time_t *)&job_ptr->preempt_time,
time_str, sizeof(time_str));
snprintf(tmp_line, sizeof(tmp_line), "PreemptTime=%s ",
time_str);
}
xstrcat(out, tmp_line);
if (job_ptr->suspend_time) {
slurm_make_time_str ((time_t *)&job_ptr->suspend_time,
time_str, sizeof(time_str));
} else {
strncpy(time_str, "None", sizeof(time_str));
}
snprintf(tmp_line, sizeof(tmp_line),
"SuspendTime=%s SecsPreSuspend=%ld",
time_str, (long int)job_ptr->pre_sus_time);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 11 ******/
snprintf(tmp_line, sizeof(tmp_line),
"Partition=%s AllocNode:Sid=%s:%u",
job_ptr->partition, job_ptr->alloc_node, job_ptr->alloc_sid);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 12 ******/
snprintf(tmp_line, sizeof(tmp_line), "Req%s=%s Exc%s=%s",
nodelist, job_ptr->req_nodes, nodelist, job_ptr->exc_nodes);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 13 ******/
xstrfmtcat(out, "%s=", nodelist);
xstrcat(out, job_ptr->nodes);
if (job_ptr->nodes && ionodes) {
snprintf(tmp_line, sizeof(tmp_line), "[%s]", ionodes);
xstrcat(out, tmp_line);
xfree(ionodes);
}
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 14 (optional) ******/
if (job_ptr->batch_host) {
snprintf(tmp_line, sizeof(tmp_line), "BatchHost=%s",
job_ptr->batch_host);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
}
/****** Line 15 ******/
if (cluster_flags & CLUSTER_FLAG_BG) {
select_g_select_jobinfo_get(job_ptr->select_jobinfo,
SELECT_JOBDATA_NODE_CNT,
&min_nodes);
if ((min_nodes == 0) || (min_nodes == NO_VAL)) {
min_nodes = job_ptr->num_nodes;
max_nodes = job_ptr->max_nodes;
} else if (job_ptr->max_nodes)
max_nodes = min_nodes;
} else {
min_nodes = job_ptr->num_nodes;
max_nodes = job_ptr->max_nodes;
}
_sprint_range(tmp1, sizeof(tmp1), job_ptr->num_cpus, job_ptr->max_cpus);
_sprint_range(tmp2, sizeof(tmp2), min_nodes, max_nodes);
if (job_ptr->sockets_per_node == (uint16_t) NO_VAL)
strcpy(tmp3, "*");
else
snprintf(tmp3, sizeof(tmp3), "%u", job_ptr->sockets_per_node);
if (job_ptr->cores_per_socket == (uint16_t) NO_VAL)
strcpy(tmp4, "*");
else
snprintf(tmp4, sizeof(tmp4), "%u", job_ptr->cores_per_socket);
if (job_ptr->threads_per_core == (uint16_t) NO_VAL)
strcpy(tmp5, "*");
else
snprintf(tmp5, sizeof(tmp5), "%u", job_ptr->threads_per_core);
snprintf(tmp_line, sizeof(tmp_line),
"NumNodes=%s NumCPUs=%s CPUs/Task=%u ReqS:C:T=%s:%s:%s",
tmp2, tmp1, job_ptr->cpus_per_task, tmp3, tmp4, tmp5);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
if (!job_resrcs)
goto line15;
if (cluster_flags & CLUSTER_FLAG_BG) {
if ((job_resrcs->cpu_array_cnt > 0) &&
(job_resrcs->cpu_array_value) &&
(job_resrcs->cpu_array_reps)) {
int length = 0;
xstrcat(out, "CPUs=");
length += 10;
for (i = 0; i < job_resrcs->cpu_array_cnt; i++) {
if (length > 70) {
/* skip to last CPU group entry */
if (i < job_resrcs->cpu_array_cnt - 1) {
continue;
}
/* add ellipsis before last entry */
xstrcat(out, "...,");
length += 4;
}
snprintf(tmp_line, sizeof(tmp_line), "%d",
job_resrcs->cpus[i]);
xstrcat(out, tmp_line);
length += strlen(tmp_line);
if (job_resrcs->cpu_array_reps[i] > 1) {
snprintf(tmp_line, sizeof(tmp_line),
"*%d",
job_resrcs->cpu_array_reps[i]);
xstrcat(out, tmp_line);
length += strlen(tmp_line);
}
if (i < job_resrcs->cpu_array_cnt - 1) {
xstrcat(out, ",");
length++;
}
}
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
}
} else {
if (!job_resrcs->core_bitmap)
goto line15;
last = bit_fls(job_resrcs->core_bitmap);
if (last == -1)
goto line15;
hl = hostlist_create(job_ptr->nodes);
if (!hl) {
error("slurm_sprint_job_info: hostlist_create: %s",
job_ptr->nodes);
return NULL;
}
hl_last = hostlist_create(NULL);
if (!hl_last) {
error("slurm_sprint_job_info: hostlist_create: NULL");
hostlist_destroy(hl);
return NULL;
}
bit_inx = 0;
i = sock_inx = sock_reps = 0;
abs_node_inx = job_ptr->node_inx[i];
/* tmp1[] stores the current cpu(s) allocated */
tmp2[0] = '\0'; /* stores last cpu(s) allocated */
for (rel_node_inx=0; rel_node_inx < job_resrcs->nhosts;
rel_node_inx++) {
if (sock_reps >=
job_resrcs->sock_core_rep_count[sock_inx]) {
sock_inx++;
sock_reps = 0;
}
sock_reps++;
bit_reps = job_resrcs->sockets_per_node[sock_inx] *
job_resrcs->cores_per_socket[sock_inx];
core_bitmap = bit_alloc(bit_reps);
for (j=0; j < bit_reps; j++) {
if (bit_test(job_resrcs->core_bitmap, bit_inx))
bit_set(core_bitmap, j);
bit_inx++;
}
bit_fmt(tmp1, sizeof(tmp1), core_bitmap);
FREE_NULL_BITMAP(core_bitmap);
host = hostlist_shift(hl);
/*
* If the allocation values for this host are not the same as the
* last host, print the report of the last group of hosts that had
* identical allocation values.
*/
if (strcmp(tmp1, tmp2) ||
(last_mem_alloc_ptr != job_resrcs->memory_allocated) ||
(job_resrcs->memory_allocated &&
(last_mem_alloc !=
job_resrcs->memory_allocated[rel_node_inx]))) {
if (hostlist_count(hl_last)) {
last_hosts =
hostlist_ranged_string_xmalloc(
hl_last);
snprintf(tmp_line, sizeof(tmp_line),
" Nodes=%s CPU_IDs=%s Mem=%u",
last_hosts, tmp2,
last_mem_alloc_ptr ?
last_mem_alloc : 0);
xfree(last_hosts);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
hostlist_destroy(hl_last);
hl_last = hostlist_create(NULL);
}
strcpy(tmp2, tmp1);
last_mem_alloc_ptr = job_resrcs->memory_allocated;
if (last_mem_alloc_ptr)
last_mem_alloc = job_resrcs->
memory_allocated[rel_node_inx];
else
last_mem_alloc = NO_VAL;
}
hostlist_push_host(hl_last, host);
free(host);
if (bit_inx > last)
break;
if (abs_node_inx > job_ptr->node_inx[i+1]) {
i += 2;
abs_node_inx = job_ptr->node_inx[i];
} else {
abs_node_inx++;
}
}
if (hostlist_count(hl_last)) {
last_hosts = hostlist_ranged_string_xmalloc(hl_last);
snprintf(tmp_line, sizeof(tmp_line),
" Nodes=%s CPU_IDs=%s Mem=%u",
last_hosts, tmp2,
last_mem_alloc_ptr ? last_mem_alloc : 0);
xfree(last_hosts);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
}
hostlist_destroy(hl);
hostlist_destroy(hl_last);
}
/****** Line 15 ******/
line15:
if (job_ptr->pn_min_memory & MEM_PER_CPU) {
job_ptr->pn_min_memory &= (~MEM_PER_CPU);
tmp6_ptr = "CPU";
} else
tmp6_ptr = "Node";
if (cluster_flags & CLUSTER_FLAG_BG) {
convert_num_unit((float)job_ptr->pn_min_cpus,
tmp1, sizeof(tmp1), UNIT_NONE);
snprintf(tmp_line, sizeof(tmp_line), "MinCPUsNode=%s", tmp1);
} else {
snprintf(tmp_line, sizeof(tmp_line), "MinCPUsNode=%u",
job_ptr->pn_min_cpus);
}
xstrcat(out, tmp_line);
convert_num_unit((float)job_ptr->pn_min_memory, tmp1, sizeof(tmp1),
UNIT_MEGA);
convert_num_unit((float)job_ptr->pn_min_tmp_disk, tmp2, sizeof(tmp2),
UNIT_MEGA);
snprintf(tmp_line, sizeof(tmp_line),
" MinMemory%s=%s MinTmpDiskNode=%s",
tmp6_ptr, tmp1, tmp2);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 16 ******/
snprintf(tmp_line, sizeof(tmp_line),
"Features=%s Gres=%s Reservation=%s",
job_ptr->features, job_ptr->gres, job_ptr->resv_name);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 17 ******/
snprintf(tmp_line, sizeof(tmp_line),
"Shared=%s Contiguous=%d Licenses=%s Network=%s",
(job_ptr->shared == 0 ? "0" :
job_ptr->shared == 1 ? "1" : "OK"),
job_ptr->contiguous, job_ptr->licenses, job_ptr->network);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 18 ******/
snprintf(tmp_line, sizeof(tmp_line), "Command=%s",
job_ptr->command);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 19 ******/
snprintf(tmp_line, sizeof(tmp_line), "WorkDir=%s",
job_ptr->work_dir);
xstrcat(out, tmp_line);
if (cluster_flags & CLUSTER_FLAG_BG) {
/****** Line 20 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_BG_ID);
if (select_buf[0] != '\0') {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
snprintf(tmp_line, sizeof(tmp_line),
"Block_ID=%s", select_buf);
xstrcat(out, tmp_line);
}
/****** Line 21 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_MIXED_SHORT);
if (select_buf[0] != '\0') {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
xstrcat(out, select_buf);
}
if (cluster_flags & CLUSTER_FLAG_BGL) {
/****** Line 22 (optional) ******/
select_g_select_jobinfo_sprint(
job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_BLRTS_IMAGE);
if (select_buf[0] != '\0') {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
snprintf(tmp_line, sizeof(tmp_line),
"BlrtsImage=%s", select_buf);
xstrcat(out, tmp_line);
}
}
/****** Line 23 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_LINUX_IMAGE);
if (select_buf[0] != '\0') {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
if (cluster_flags & CLUSTER_FLAG_BGL)
snprintf(tmp_line, sizeof(tmp_line),
"LinuxImage=%s", select_buf);
else
snprintf(tmp_line, sizeof(tmp_line),
"CnloadImage=%s", select_buf);
xstrcat(out, tmp_line);
}
/****** Line 24 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_MLOADER_IMAGE);
if (select_buf[0] != '\0') {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
snprintf(tmp_line, sizeof(tmp_line),
"MloaderImage=%s", select_buf);
xstrcat(out, tmp_line);
}
/****** Line 25 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_RAMDISK_IMAGE);
if (select_buf[0] != '\0') {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
if (cluster_flags & CLUSTER_FLAG_BGL)
snprintf(tmp_line, sizeof(tmp_line),
"RamDiskImage=%s", select_buf);
else
snprintf(tmp_line, sizeof(tmp_line),
"IoloadImage=%s", select_buf);
xstrcat(out, tmp_line);
}
}
/****** Line 26 (optional) ******/
if (job_ptr->comment) {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
snprintf(tmp_line, sizeof(tmp_line), "Comment=%s ",
job_ptr->comment);
xstrcat(out, tmp_line);
}
/****** Line 27 (optional) ******/
if (job_ptr->batch_script) {
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
xstrcat(out, "BatchScript=\n");
xstrcat(out, job_ptr->batch_script);
}
/****** Line 28 (optional) ******/
if (job_ptr->req_switch) {
char time_buf[32];
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
secs2time_str((time_t) job_ptr->wait4switch, time_buf,
sizeof(time_buf));
snprintf(tmp_line, sizeof(tmp_line), "Switches=%u@%s\n",
job_ptr->req_switch, time_buf);
xstrcat(out, tmp_line);
}
/****** Line 29 (optional) ******/
if (one_liner)
xstrcat(out, "\n");
else
xstrcat(out, "\n\n");
return out;
}
static int _print_text_job(job_info_t * job_ptr)
{
time_t time_diff;
int printed = 0;
int tempxcord;
int prefixlen = 0;
int i = 0;
int width = 0;
char time_buf[20];
char tmp_cnt[8];
uint32_t node_cnt = 0;
char *uname;
node_cnt = job_ptr->num_nodes;
if ((node_cnt == 0) || (node_cnt == NO_VAL))
node_cnt = job_ptr->num_nodes;
snprintf(tmp_cnt, sizeof(tmp_cnt), "%d", node_cnt);
if (!params.commandline) {
mvwprintw(text_win, main_ycord,
main_xcord, "%c", job_ptr->num_cpus);
main_xcord += 3;
if (job_ptr->array_task_str) {
mvwprintw(text_win, main_ycord,
main_xcord, "%u_[%s]",
job_ptr->array_job_id,
job_ptr->array_task_str);
} else if (job_ptr->array_task_id != NO_VAL) {
mvwprintw(text_win, main_ycord,
main_xcord, "%u_%u (%u)",
job_ptr->array_job_id,
job_ptr->array_task_id, job_ptr->job_id);
} else if (job_ptr->pack_job_id) {
mvwprintw(text_win, main_ycord, main_xcord, "%u+%u ",
job_ptr->pack_job_id,
job_ptr->pack_job_offset);
} else {
mvwprintw(text_win, main_ycord, main_xcord, "%u",
job_ptr->job_id);
}
main_xcord += 19;
mvwprintw(text_win, main_ycord,
main_xcord, "%.10s", job_ptr->partition);
main_xcord += 10;
if (params.cluster_flags & CLUSTER_FLAG_CRAY_A) {
mvwprintw(text_win, main_ycord,
main_xcord, "%.16s",
select_g_select_jobinfo_sprint(
job_ptr->select_jobinfo,
time_buf, sizeof(time_buf),
SELECT_PRINT_DATA));
main_xcord += 18;
}
uname = uid_to_string_cached((uid_t) job_ptr->user_id);
mvwprintw(text_win, main_ycord,
main_xcord, "%.8s", uname);
main_xcord += 9;
mvwprintw(text_win, main_ycord,
main_xcord, "%.9s", job_ptr->name);
main_xcord += 10;
mvwprintw(text_win, main_ycord,
main_xcord, "%.2s",
job_state_string_compact(job_ptr->job_state));
main_xcord += 2;
if (!xstrcasecmp(job_ptr->nodes,"waiting...")) {
sprintf(time_buf,"00:00:00");
} else {
time_diff = (time_t) _job_time_used(job_ptr);
secs2time_str(time_diff, time_buf, sizeof(time_buf));
}
width = strlen(time_buf);
mvwprintw(text_win, main_ycord,
main_xcord + (10 - width), "%s",
time_buf);
main_xcord += 11;
mvwprintw(text_win,
main_ycord,
main_xcord, "%5s", tmp_cnt);
main_xcord += 6;
tempxcord = main_xcord;
i=0;
while (job_ptr->nodes[i] != '\0') {
if ((printed = mvwaddch(text_win,
main_ycord,
main_xcord,
job_ptr->nodes[i])) < 0) {
return printed;
}
main_xcord++;
width = getmaxx(text_win) - 1 - main_xcord;
if (job_ptr->nodes[i] == '[')
prefixlen = i + 1;
else if (job_ptr->nodes[i] == ','
&& (width - 9) <= 0) {
main_ycord++;
main_xcord = tempxcord + prefixlen;
}
i++;
}
main_xcord = 1;
main_ycord++;
} else {
if (job_ptr->pack_job_id) {
printf("%8u+%u ", job_ptr->pack_job_id,
job_ptr->pack_job_offset);
} else
printf("%8u ", job_ptr->job_id);
printf("%9.9s ", job_ptr->partition);
if (params.cluster_flags & CLUSTER_FLAG_CRAY_A)
printf("%16.16s ",
select_g_select_jobinfo_sprint(
job_ptr->select_jobinfo,
time_buf, sizeof(time_buf),
SELECT_PRINT_DATA));
uname = uid_to_string_cached((uid_t) job_ptr->user_id);
printf("%8.8s ", uname);
printf("%6.6s ", job_ptr->name);
printf("%2.2s ",
job_state_string_compact(job_ptr->job_state));
if (!xstrcasecmp(job_ptr->nodes,"waiting...")) {
sprintf(time_buf,"00:00:00");
} else {
time_diff = (time_t) _job_time_used(job_ptr);
secs2time_str(time_diff, time_buf, sizeof(time_buf));
}
printf("%10.10s ", time_buf);
printf("%5s ", tmp_cnt);
printf("%s", job_ptr->nodes);
printf("\n");
}
return printed;
}
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("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);
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("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(
sched_param_type_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);
#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;
}
/*
* slurm_sprint_job_step_info - output information about a specific Slurm
* job step based upon message as loaded using slurm_get_job_steps
* IN job_ptr - an individual job step 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_job_step_info ( job_step_info_t * job_step_ptr,
int one_liner )
{
char tmp_node_cnt[40];
char time_str[32];
char limit_str[32];
char tmp_line[128];
char *out = NULL;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
/****** Line 1 ******/
slurm_make_time_str ((time_t *)&job_step_ptr->start_time, time_str,
sizeof(time_str));
if (job_step_ptr->time_limit == INFINITE)
sprintf(limit_str, "UNLIMITED");
else
secs2time_str ((time_t)job_step_ptr->time_limit * 60,
limit_str, sizeof(limit_str));
if (job_step_ptr->array_job_id) {
if (job_step_ptr->step_id == INFINITE) { /* Pending */
snprintf(tmp_line, sizeof(tmp_line), "StepId=%u_%u.TBD ",
job_step_ptr->array_job_id,
job_step_ptr->array_task_id);
} else {
snprintf(tmp_line, sizeof(tmp_line), "StepId=%u_%u.%u ",
job_step_ptr->array_job_id,
job_step_ptr->array_task_id,
job_step_ptr->step_id);
}
out = xstrdup(tmp_line);
} else {
if (job_step_ptr->step_id == INFINITE) { /* Pending */
snprintf(tmp_line, sizeof(tmp_line), "StepId=%u.TBD ",
job_step_ptr->job_id);
} else {
snprintf(tmp_line, sizeof(tmp_line), "StepId=%u.%u ",
job_step_ptr->job_id, job_step_ptr->step_id);
}
out = xstrdup(tmp_line);
}
snprintf(tmp_line, sizeof(tmp_line),
"UserId=%u StartTime=%s TimeLimit=%s",
job_step_ptr->user_id, time_str, limit_str);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 2 ******/
snprintf(tmp_line, sizeof(tmp_line),
"State=%s ",
job_state_string(job_step_ptr->state));
xstrcat(out, tmp_line);
if (cluster_flags & CLUSTER_FLAG_BG) {
char *io_nodes;
select_g_select_jobinfo_get(job_step_ptr->select_jobinfo,
SELECT_JOBDATA_IONODES,
&io_nodes);
if (io_nodes) {
snprintf(tmp_line, sizeof(tmp_line),
"Partition=%s MidplaneList=%s[%s] Gres=%s",
job_step_ptr->partition,
job_step_ptr->nodes, io_nodes,
job_step_ptr->gres);
xfree(io_nodes);
} else
snprintf(tmp_line, sizeof(tmp_line),
"Partition=%s MidplaneList=%s Gres=%s",
job_step_ptr->partition,
job_step_ptr->nodes,
job_step_ptr->gres);
} else {
snprintf(tmp_line, sizeof(tmp_line),
"Partition=%s NodeList=%s Gres=%s",
job_step_ptr->partition, job_step_ptr->nodes,
job_step_ptr->gres);
}
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 3 ******/
if (cluster_flags & CLUSTER_FLAG_BGQ) {
uint32_t nodes = 0;
select_g_select_jobinfo_get(job_step_ptr->select_jobinfo,
SELECT_JOBDATA_NODE_CNT,
&nodes);
convert_num_unit((float)nodes, tmp_node_cnt,
sizeof(tmp_node_cnt), UNIT_NONE);
} else {
convert_num_unit((float)_nodes_in_list(job_step_ptr->nodes),
tmp_node_cnt, sizeof(tmp_node_cnt),
UNIT_NONE);
}
snprintf(tmp_line, sizeof(tmp_line),
"Nodes=%s Tasks=%u Name=%s Network=%s",
tmp_node_cnt, job_step_ptr->num_tasks, job_step_ptr->name,
job_step_ptr->network);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 4 ******/
snprintf(tmp_line, sizeof(tmp_line),
"ResvPorts=%s Checkpoint=%u CheckpointDir=%s",
job_step_ptr->resv_ports,
job_step_ptr->ckpt_interval, job_step_ptr->ckpt_dir);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 5 ******/
if (job_step_ptr->cpu_freq == NO_VAL) {
snprintf(tmp_line, sizeof(tmp_line),
"CPUFreqReq=Default\n\n");
} else if (job_step_ptr->cpu_freq & CPU_FREQ_RANGE_FLAG) {
char buf[32];
cpu_freq_to_string(buf, sizeof(buf), job_step_ptr->cpu_freq);
snprintf(tmp_line, sizeof(tmp_line), "CPUFreqReq=%s\n\n", buf);
} else {
snprintf(tmp_line, sizeof(tmp_line),
"CPUFreqReq=%u\n\n", job_step_ptr->cpu_freq);
}
xstrcat(out, tmp_line);
return out;
}
/*
* slurm_sprint_job_info - output information about a specific Slurm
* job based upon message as loaded using slurm_load_jobs
* IN job_ptr - an individual job 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.
*/
extern char *
slurm_sprint_job_info ( job_info_t * job_ptr, int one_liner )
{
int i, j, k;
char time_str[32], *group_name, *user_name;
char *gres_last = "", tmp1[128], tmp2[128];
char *tmp6_ptr;
char tmp_line[1024 * 128];
char tmp_path[MAXPATHLEN];
char *ionodes = NULL;
uint16_t exit_status = 0, term_sig = 0;
job_resources_t *job_resrcs = job_ptr->job_resrcs;
char *out = NULL;
time_t run_time;
uint32_t min_nodes, max_nodes = 0;
char *nodelist = "NodeList";
bitstr_t *cpu_bitmap;
char *host;
int sock_inx, sock_reps, last;
int abs_node_inx, rel_node_inx;
int64_t nice;
int bit_inx, bit_reps;
uint64_t *last_mem_alloc_ptr = NULL;
uint64_t last_mem_alloc = NO_VAL64;
char *last_hosts;
hostlist_t hl, hl_last;
char select_buf[122];
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
uint32_t threads;
char *line_end = (one_liner) ? " " : "\n ";
if (cluster_flags & CLUSTER_FLAG_BG) {
nodelist = "MidplaneList";
select_g_select_jobinfo_get(job_ptr->select_jobinfo,
SELECT_JOBDATA_IONODES,
&ionodes);
}
/****** Line 1 ******/
xstrfmtcat(out, "JobId=%u ", job_ptr->job_id);
if (job_ptr->array_job_id) {
if (job_ptr->array_task_str) {
xstrfmtcat(out, "ArrayJobId=%u ArrayTaskId=%s ",
job_ptr->array_job_id,
job_ptr->array_task_str);
} else {
xstrfmtcat(out, "ArrayJobId=%u ArrayTaskId=%u ",
job_ptr->array_job_id,
job_ptr->array_task_id);
}
}
xstrfmtcat(out, "JobName=%s", job_ptr->name);
xstrcat(out, line_end);
/****** Line 2 ******/
user_name = uid_to_string((uid_t) job_ptr->user_id);
group_name = gid_to_string((gid_t) job_ptr->group_id);
xstrfmtcat(out, "UserId=%s(%u) GroupId=%s(%u) MCS_label=%s",
user_name, job_ptr->user_id, group_name, job_ptr->group_id,
(job_ptr->mcs_label==NULL) ? "N/A" : job_ptr->mcs_label);
xfree(user_name);
xfree(group_name);
xstrcat(out, line_end);
/****** Line 3 ******/
nice = ((int64_t)job_ptr->nice) - NICE_OFFSET;
xstrfmtcat(out, "Priority=%u Nice=%"PRIi64" Account=%s QOS=%s",
job_ptr->priority, nice, job_ptr->account, job_ptr->qos);
if (slurm_get_track_wckey())
xstrfmtcat(out, " WCKey=%s", job_ptr->wckey);
xstrcat(out, line_end);
/****** Line 4 ******/
xstrfmtcat(out, "JobState=%s ", job_state_string(job_ptr->job_state));
if (job_ptr->state_desc) {
/* Replace white space with underscore for easier parsing */
for (j=0; job_ptr->state_desc[j]; j++) {
if (isspace((int)job_ptr->state_desc[j]))
job_ptr->state_desc[j] = '_';
}
xstrfmtcat(out, "Reason=%s ", job_ptr->state_desc);
} else
xstrfmtcat(out, "Reason=%s ", job_reason_string(job_ptr->state_reason));
xstrfmtcat(out, "Dependency=%s", job_ptr->dependency);
xstrcat(out, line_end);
/****** Line 5 ******/
xstrfmtcat(out, "Requeue=%u Restarts=%u BatchFlag=%u Reboot=%u ",
job_ptr->requeue, job_ptr->restart_cnt, job_ptr->batch_flag,
job_ptr->reboot);
if (WIFSIGNALED(job_ptr->exit_code))
term_sig = WTERMSIG(job_ptr->exit_code);
exit_status = WEXITSTATUS(job_ptr->exit_code);
xstrfmtcat(out, "ExitCode=%u:%u", exit_status, term_sig);
xstrcat(out, line_end);
/****** Line 5a (optional) ******/
if (job_ptr->show_flags & SHOW_DETAIL) {
if (WIFSIGNALED(job_ptr->derived_ec))
term_sig = WTERMSIG(job_ptr->derived_ec);
else
term_sig = 0;
exit_status = WEXITSTATUS(job_ptr->derived_ec);
xstrfmtcat(out, "DerivedExitCode=%u:%u", exit_status, term_sig);
xstrcat(out, line_end);
}
/****** Line 6 ******/
if (IS_JOB_PENDING(job_ptr))
run_time = 0;
else if (IS_JOB_SUSPENDED(job_ptr))
run_time = job_ptr->pre_sus_time;
else {
time_t end_time;
if (IS_JOB_RUNNING(job_ptr) || (job_ptr->end_time == 0))
end_time = time(NULL);
else
end_time = job_ptr->end_time;
if (job_ptr->suspend_time) {
run_time = (time_t)
(difftime(end_time, job_ptr->suspend_time)
+ job_ptr->pre_sus_time);
} else
run_time = (time_t)
difftime(end_time, job_ptr->start_time);
}
secs2time_str(run_time, time_str, sizeof(time_str));
xstrfmtcat(out, "RunTime=%s ", time_str);
if (job_ptr->time_limit == NO_VAL)
xstrcat(out, "TimeLimit=Partition_Limit ");
else {
mins2time_str(job_ptr->time_limit, time_str, sizeof(time_str));
xstrfmtcat(out, "TimeLimit=%s ", time_str);
}
if (job_ptr->time_min == 0)
xstrcat(out, "TimeMin=N/A");
else {
mins2time_str(job_ptr->time_min, time_str, sizeof(time_str));
xstrfmtcat(out, "TimeMin=%s", time_str);
}
xstrcat(out, line_end);
/****** Line 7 ******/
slurm_make_time_str(&job_ptr->submit_time, time_str, sizeof(time_str));
xstrfmtcat(out, "SubmitTime=%s ", time_str);
slurm_make_time_str(&job_ptr->eligible_time, time_str, sizeof(time_str));
xstrfmtcat(out, "EligibleTime=%s", time_str);
xstrcat(out, line_end);
/****** Line 8 (optional) ******/
if (job_ptr->resize_time) {
slurm_make_time_str(&job_ptr->resize_time, time_str, sizeof(time_str));
xstrfmtcat(out, "ResizeTime=%s", time_str);
xstrcat(out, line_end);
}
/****** Line 9 ******/
slurm_make_time_str(&job_ptr->start_time, time_str, sizeof(time_str));
xstrfmtcat(out, "StartTime=%s ", time_str);
if ((job_ptr->time_limit == INFINITE) &&
(job_ptr->end_time > time(NULL)))
xstrcat(out, "EndTime=Unknown ");
else {
slurm_make_time_str(&job_ptr->end_time, time_str, sizeof(time_str));
xstrfmtcat(out, "EndTime=%s ", time_str);
}
if (job_ptr->deadline) {
slurm_make_time_str(&job_ptr->deadline, time_str, sizeof(time_str));
xstrfmtcat(out, "Deadline=%s", time_str);
} else {
xstrcat(out, "Deadline=N/A");
}
xstrcat(out, line_end);
/****** Line 10 ******/
if (job_ptr->preempt_time == 0)
xstrcat(out, "PreemptTime=None ");
else {
slurm_make_time_str(&job_ptr->preempt_time, time_str, sizeof(time_str));
xstrfmtcat(out, "PreemptTime=%s ", time_str);
}
if (job_ptr->suspend_time) {
slurm_make_time_str(&job_ptr->suspend_time, time_str, sizeof(time_str));
xstrfmtcat(out, "SuspendTime=%s ", time_str);
} else
xstrcat(out, "SuspendTime=None ");
xstrfmtcat(out, "SecsPreSuspend=%ld", (long int)job_ptr->pre_sus_time);
xstrcat(out, line_end);
/****** Line 11 ******/
xstrfmtcat(out, "Partition=%s AllocNode:Sid=%s:%u",
job_ptr->partition, job_ptr->alloc_node, job_ptr->alloc_sid);
xstrcat(out, line_end);
/****** Line 12 ******/
xstrfmtcat(out, "Req%s=%s Exc%s=%s", nodelist, job_ptr->req_nodes,
nodelist, job_ptr->exc_nodes);
xstrcat(out, line_end);
/****** Line 13 ******/
xstrfmtcat(out, "%s=%s", nodelist, job_ptr->nodes);
if (job_ptr->nodes && ionodes) {
xstrfmtcat(out, "[%s]", ionodes);
xfree(ionodes);
}
if (job_ptr->sched_nodes)
xstrfmtcat(out, " Sched%s=%s", nodelist, job_ptr->sched_nodes);
xstrcat(out, line_end);
/****** Line 14 (optional) ******/
if (job_ptr->batch_host) {
xstrfmtcat(out, "BatchHost=%s", job_ptr->batch_host);
xstrcat(out, line_end);
}
/****** Line 14a (optional) ******/
if (job_ptr->fed_siblings) {
xstrfmtcat(out, "FedOrigin=%s FedSiblings=%s",
job_ptr->fed_origin_str, job_ptr->fed_siblings_str);
xstrcat(out, line_end);
}
/****** Line 15 ******/
if (cluster_flags & CLUSTER_FLAG_BG) {
select_g_select_jobinfo_get(job_ptr->select_jobinfo,
SELECT_JOBDATA_NODE_CNT,
&min_nodes);
if ((min_nodes == 0) || (min_nodes == NO_VAL)) {
min_nodes = job_ptr->num_nodes;
max_nodes = job_ptr->max_nodes;
} else if (job_ptr->max_nodes)
max_nodes = min_nodes;
} else if (IS_JOB_PENDING(job_ptr)) {
min_nodes = job_ptr->num_nodes;
max_nodes = job_ptr->max_nodes;
if (max_nodes && (max_nodes < min_nodes))
min_nodes = max_nodes;
} else {
min_nodes = job_ptr->num_nodes;
max_nodes = 0;
}
_sprint_range(tmp_line, sizeof(tmp_line), min_nodes, max_nodes);
xstrfmtcat(out, "NumNodes=%s ", tmp_line);
_sprint_range(tmp_line, sizeof(tmp_line), job_ptr->num_cpus, job_ptr->max_cpus);
xstrfmtcat(out, "NumCPUs=%s ", tmp_line);
xstrfmtcat(out, "NumTasks=%u ", job_ptr->num_tasks);
xstrfmtcat(out, "CPUs/Task=%u ", job_ptr->cpus_per_task);
if (job_ptr->boards_per_node == (uint16_t) NO_VAL)
xstrcat(out, "ReqB:S:C:T=*:");
else
xstrfmtcat(out, "ReqB:S:C:T=%u:", job_ptr->boards_per_node);
if (job_ptr->sockets_per_board == (uint16_t) NO_VAL)
xstrcat(out, "*:");
else
xstrfmtcat(out, "%u:", job_ptr->sockets_per_board);
if (job_ptr->cores_per_socket == (uint16_t) NO_VAL)
xstrcat(out, "*:");
else
xstrfmtcat(out, "%u:", job_ptr->cores_per_socket);
if (job_ptr->threads_per_core == (uint16_t) NO_VAL)
xstrcat(out, "*");
else
xstrfmtcat(out, "%u", job_ptr->threads_per_core);
xstrcat(out, line_end);
/****** Line 16 ******/
/* Tres should already of been converted at this point from simple */
xstrfmtcat(out, "TRES=%s",
job_ptr->tres_alloc_str ? job_ptr->tres_alloc_str
: job_ptr->tres_req_str);
xstrcat(out, line_end);
/****** Line 17 ******/
if (job_ptr->sockets_per_node == (uint16_t) NO_VAL)
xstrcat(out, "Socks/Node=* ");
else
xstrfmtcat(out, "Socks/Node=%u ", job_ptr->sockets_per_node);
if (job_ptr->ntasks_per_node == (uint16_t) NO_VAL)
xstrcat(out, "NtasksPerN:B:S:C=*:");
else
xstrfmtcat(out, "NtasksPerN:B:S:C=%u:", job_ptr->ntasks_per_node);
if (job_ptr->ntasks_per_board == (uint16_t) NO_VAL)
xstrcat(out, "*:");
else
xstrfmtcat(out, "%u:", job_ptr->ntasks_per_board);
if ((job_ptr->ntasks_per_socket == (uint16_t) NO_VAL) ||
(job_ptr->ntasks_per_socket == (uint16_t) INFINITE))
xstrcat(out, "*:");
else
xstrfmtcat(out, "%u:", job_ptr->ntasks_per_socket);
if ((job_ptr->ntasks_per_core == (uint16_t) NO_VAL) ||
(job_ptr->ntasks_per_core == (uint16_t) INFINITE))
xstrcat(out, "* ");
else
xstrfmtcat(out, "%u ", job_ptr->ntasks_per_core);
if (job_ptr->core_spec == (uint16_t) NO_VAL)
xstrcat(out, "CoreSpec=*");
else if (job_ptr->core_spec & CORE_SPEC_THREAD)
xstrfmtcat(out, "ThreadSpec=%d",
(job_ptr->core_spec & (~CORE_SPEC_THREAD)));
else
xstrfmtcat(out, "CoreSpec=%u", job_ptr->core_spec);
xstrcat(out, line_end);
if (job_resrcs && cluster_flags & CLUSTER_FLAG_BG) {
if ((job_resrcs->cpu_array_cnt > 0) &&
(job_resrcs->cpu_array_value) &&
(job_resrcs->cpu_array_reps)) {
int length = 0;
xstrcat(out, "CPUs=");
for (i = 0; i < job_resrcs->cpu_array_cnt; i++) {
/* only print 60 characters worth of this record */
if (length > 60) {
/* skip to last CPU group entry */
if (i < job_resrcs->cpu_array_cnt - 1) {
continue;
}
/* add ellipsis before last entry */
xstrcat(out, "...,");
}
length += xstrfmtcat(out, "%d", job_resrcs->cpus[i]);
if (job_resrcs->cpu_array_reps[i] > 1) {
length += xstrfmtcat(out, "*%d",
job_resrcs->cpu_array_reps[i]);
}
if (i < job_resrcs->cpu_array_cnt - 1) {
xstrcat(out, ",");
length++;
}
}
xstrcat(out, line_end);
}
} else if (job_resrcs && job_resrcs->core_bitmap &&
((last = bit_fls(job_resrcs->core_bitmap)) != -1)) {
hl = hostlist_create(job_resrcs->nodes);
if (!hl) {
error("slurm_sprint_job_info: hostlist_create: %s",
job_resrcs->nodes);
return NULL;
}
hl_last = hostlist_create(NULL);
if (!hl_last) {
error("slurm_sprint_job_info: hostlist_create: NULL");
hostlist_destroy(hl);
return NULL;
}
bit_inx = 0;
i = sock_inx = sock_reps = 0;
abs_node_inx = job_ptr->node_inx[i];
gres_last = "";
/* tmp1[] stores the current cpu(s) allocated */
tmp2[0] = '\0'; /* stores last cpu(s) allocated */
for (rel_node_inx=0; rel_node_inx < job_resrcs->nhosts;
rel_node_inx++) {
if (sock_reps >=
job_resrcs->sock_core_rep_count[sock_inx]) {
sock_inx++;
sock_reps = 0;
}
sock_reps++;
bit_reps = job_resrcs->sockets_per_node[sock_inx] *
job_resrcs->cores_per_socket[sock_inx];
host = hostlist_shift(hl);
threads = _threads_per_core(host);
cpu_bitmap = bit_alloc(bit_reps * threads);
for (j = 0; j < bit_reps; j++) {
if (bit_test(job_resrcs->core_bitmap, bit_inx)){
for (k = 0; k < threads; k++)
bit_set(cpu_bitmap,
(j * threads) + k);
}
bit_inx++;
}
bit_fmt(tmp1, sizeof(tmp1), cpu_bitmap);
FREE_NULL_BITMAP(cpu_bitmap);
/*
* If the allocation values for this host are not the
* same as the last host, print the report of the last
* group of hosts that had identical allocation values.
*/
if (xstrcmp(tmp1, tmp2) ||
((rel_node_inx < job_ptr->gres_detail_cnt) &&
xstrcmp(job_ptr->gres_detail_str[rel_node_inx],
gres_last)) ||
(last_mem_alloc_ptr != job_resrcs->memory_allocated) ||
(job_resrcs->memory_allocated &&
(last_mem_alloc !=
job_resrcs->memory_allocated[rel_node_inx]))) {
if (hostlist_count(hl_last)) {
last_hosts =
hostlist_ranged_string_xmalloc(
hl_last);
xstrfmtcat(out,
" Nodes=%s CPU_IDs=%s "
"Mem=%"PRIu64" GRES_IDX=%s",
last_hosts, tmp2,
last_mem_alloc_ptr ?
last_mem_alloc : 0,
gres_last);
xfree(last_hosts);
xstrcat(out, line_end);
hostlist_destroy(hl_last);
hl_last = hostlist_create(NULL);
}
strcpy(tmp2, tmp1);
if (rel_node_inx < job_ptr->gres_detail_cnt) {
gres_last = job_ptr->
gres_detail_str[rel_node_inx];
} else {
gres_last = "";
}
last_mem_alloc_ptr = job_resrcs->memory_allocated;
if (last_mem_alloc_ptr)
last_mem_alloc = job_resrcs->
memory_allocated[rel_node_inx];
else
last_mem_alloc = NO_VAL64;
}
hostlist_push_host(hl_last, host);
free(host);
if (bit_inx > last)
break;
if (abs_node_inx > job_ptr->node_inx[i+1]) {
i += 2;
abs_node_inx = job_ptr->node_inx[i];
} else {
abs_node_inx++;
}
}
if (hostlist_count(hl_last)) {
last_hosts = hostlist_ranged_string_xmalloc(hl_last);
xstrfmtcat(out, " Nodes=%s CPU_IDs=%s Mem=%"PRIu64" GRES_IDX=%s",
last_hosts, tmp2,
last_mem_alloc_ptr ? last_mem_alloc : 0,
gres_last);
xfree(last_hosts);
xstrcat(out, line_end);
}
hostlist_destroy(hl);
hostlist_destroy(hl_last);
}
/****** Line 18 ******/
if (job_ptr->pn_min_memory & MEM_PER_CPU) {
job_ptr->pn_min_memory &= (~MEM_PER_CPU);
tmp6_ptr = "CPU";
} else
tmp6_ptr = "Node";
if (cluster_flags & CLUSTER_FLAG_BG) {
convert_num_unit((float)job_ptr->pn_min_cpus, tmp1,
sizeof(tmp1), UNIT_NONE, NO_VAL,
CONVERT_NUM_UNIT_EXACT);
xstrfmtcat(out, "MinCPUsNode=%s ", tmp1);
} else {
xstrfmtcat(out, "MinCPUsNode=%u ", job_ptr->pn_min_cpus);
}
convert_num_unit((float)job_ptr->pn_min_memory, tmp1, sizeof(tmp1),
UNIT_MEGA, NO_VAL, CONVERT_NUM_UNIT_EXACT);
convert_num_unit((float)job_ptr->pn_min_tmp_disk, tmp2, sizeof(tmp2),
UNIT_MEGA, NO_VAL, CONVERT_NUM_UNIT_EXACT);
xstrfmtcat(out, "MinMemory%s=%s MinTmpDiskNode=%s", tmp6_ptr, tmp1, tmp2);
xstrcat(out, line_end);
/****** Line ******/
secs2time_str((time_t)job_ptr->delay_boot, tmp1, sizeof(tmp1));
xstrfmtcat(out, "Features=%s DelayBoot=%s", job_ptr->features, tmp1);
xstrcat(out, line_end);
/****** Line ******/
xstrfmtcat(out, "Gres=%s Reservation=%s",
job_ptr->gres, job_ptr->resv_name);
xstrcat(out, line_end);
/****** Line 20 ******/
xstrfmtcat(out, "OverSubscribe=%s Contiguous=%d Licenses=%s Network=%s",
job_share_string(job_ptr->shared), job_ptr->contiguous,
job_ptr->licenses, job_ptr->network);
xstrcat(out, line_end);
/****** Line 21 ******/
xstrfmtcat(out, "Command=%s", job_ptr->command);
xstrcat(out, line_end);
/****** Line 22 ******/
xstrfmtcat(out, "WorkDir=%s", job_ptr->work_dir);
if (cluster_flags & CLUSTER_FLAG_BG) {
/****** Line 23 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_BG_ID);
if (select_buf[0] != '\0') {
xstrcat(out, line_end);
xstrfmtcat(out, "Block_ID=%s", select_buf);
}
/****** Line 24 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_MIXED_SHORT);
if (select_buf[0] != '\0') {
xstrcat(out, line_end);
xstrcat(out, select_buf);
}
/****** Line 26 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_LINUX_IMAGE);
if (select_buf[0] != '\0') {
xstrcat(out, line_end);
xstrfmtcat(out, "CnloadImage=%s", select_buf);
}
/****** Line 27 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_MLOADER_IMAGE);
if (select_buf[0] != '\0') {
xstrcat(out, line_end);
xstrfmtcat(out, "MloaderImage=%s", select_buf);
}
/****** Line 28 (optional) ******/
select_g_select_jobinfo_sprint(job_ptr->select_jobinfo,
select_buf, sizeof(select_buf),
SELECT_PRINT_RAMDISK_IMAGE);
if (select_buf[0] != '\0') {
xstrcat(out, line_end);
xstrfmtcat(out, "IoloadImage=%s", select_buf);
}
}
/****** Line (optional) ******/
if (job_ptr->admin_comment) {
xstrcat(out, line_end);
xstrfmtcat(out, "AdminComment=%s ", job_ptr->admin_comment);
}
/****** Line (optional) ******/
if (job_ptr->comment) {
xstrcat(out, line_end);
xstrfmtcat(out, "Comment=%s ", job_ptr->comment);
}
/****** Line 30 (optional) ******/
if (job_ptr->batch_flag) {
xstrcat(out, line_end);
slurm_get_job_stderr(tmp_path, sizeof(tmp_path), job_ptr);
xstrfmtcat(out, "StdErr=%s", tmp_path);
}
/****** Line 31 (optional) ******/
if (job_ptr->batch_flag) {
xstrcat(out, line_end);
slurm_get_job_stdin(tmp_path, sizeof(tmp_path), job_ptr);
xstrfmtcat(out, "StdIn=%s", tmp_path);
}
/****** Line 32 (optional) ******/
if (job_ptr->batch_flag) {
xstrcat(out, line_end);
slurm_get_job_stdout(tmp_path, sizeof(tmp_path), job_ptr);
xstrfmtcat(out, "StdOut=%s", tmp_path);
}
/****** Line 33 (optional) ******/
if (job_ptr->batch_script) {
xstrcat(out, line_end);
xstrcat(out, "BatchScript=\n");
xstrcat(out, job_ptr->batch_script);
}
/****** Line 34 (optional) ******/
if (job_ptr->req_switch) {
char time_buf[32];
xstrcat(out, line_end);
secs2time_str((time_t) job_ptr->wait4switch, time_buf,
sizeof(time_buf));
xstrfmtcat(out, "Switches=%u@%s\n", job_ptr->req_switch, time_buf);
}
/****** Line 35 (optional) ******/
if (job_ptr->burst_buffer) {
xstrcat(out, line_end);
xstrfmtcat(out, "BurstBuffer=%s", job_ptr->burst_buffer);
}
/****** Line (optional) ******/
if (job_ptr->burst_buffer_state) {
xstrcat(out, line_end);
xstrfmtcat(out, "BurstBufferState=%s",
job_ptr->burst_buffer_state);
}
/****** Line 36 (optional) ******/
if (cpu_freq_debug(NULL, NULL, tmp1, sizeof(tmp1),
job_ptr->cpu_freq_gov, job_ptr->cpu_freq_min,
job_ptr->cpu_freq_max, NO_VAL) != 0) {
xstrcat(out, line_end);
xstrcat(out, tmp1);
}
/****** Line 37 ******/
xstrcat(out, line_end);
xstrfmtcat(out, "Power=%s", power_flags_str(job_ptr->power_flags));
/****** Line 38 (optional) ******/
if (job_ptr->bitflags) {
xstrcat(out, line_end);
if (job_ptr->bitflags & GRES_ENFORCE_BIND)
xstrcat(out, "GresEnforceBind=Yes");
if (job_ptr->bitflags & KILL_INV_DEP)
xstrcat(out, "KillOInInvalidDependent=Yes");
if (job_ptr->bitflags & NO_KILL_INV_DEP)
xstrcat(out, "KillOInInvalidDependent=No");
if (job_ptr->bitflags & SPREAD_JOB)
xstrcat(out, "SpreadJob=Yes");
}
/****** END OF JOB RECORD ******/
if (one_liner)
xstrcat(out, "\n");
else
xstrcat(out, "\n\n");
return out;
}
/*
* 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);
preempt_mode = part_ptr->preempt_mode;
if (preempt_mode == (uint16_t) NO_VAL)
preempt_mode = slurm_get_preempt_mode(); /* use cluster param */
xstrfmtcat(out, " PreemptMode=%s", preempt_mode_string(preempt_mode));
xstrcat(out, line_end);
/****** Line 8 ******/
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;
}
static int _print_text_part(partition_info_t *part_ptr,
db2_block_info_t *db2_info_ptr)
{
int printed = 0;
int tempxcord;
int prefixlen;
int i = 0;
int width = 0;
char *nodes = NULL, time_buf[20], *conn_str = NULL;
char tmp_cnt[8];
char tmp_char[8];
if (params.cluster_flags & CLUSTER_FLAG_BG)
convert_num_unit((float)part_ptr->total_nodes, tmp_cnt,
sizeof(tmp_cnt), UNIT_NONE);
else
snprintf(tmp_cnt, sizeof(tmp_cnt), "%u", part_ptr->total_nodes);
if (!params.commandline) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%c",
part_ptr->flags);
main_xcord += 4;
if (part_ptr->name) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%.9s",
part_ptr->name);
main_xcord += 10;
if (params.display != BGPART) {
char *tmp_state;
if (part_ptr->state_up == PARTITION_INACTIVE)
tmp_state = "inact";
else if (part_ptr->state_up == PARTITION_UP)
tmp_state = "up";
else if (part_ptr->state_up == PARTITION_DOWN)
tmp_state = "down";
else if (part_ptr->state_up == PARTITION_DRAIN)
tmp_state = "drain";
else
tmp_state = "unk";
mvwprintw(text_win, main_ycord, main_xcord,
tmp_state);
main_xcord += 7;
if (part_ptr->max_time == INFINITE)
snprintf(time_buf, sizeof(time_buf),
"infinite");
else {
secs2time_str((part_ptr->max_time
* 60),
time_buf,
sizeof(time_buf));
}
width = strlen(time_buf);
mvwprintw(text_win,
main_ycord,
main_xcord + (9 - width),
"%s",
time_buf);
main_xcord += 11;
}
} else
main_xcord += 10;
if (params.display == BGPART) {
if (db2_info_ptr) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%.16s",
db2_info_ptr->bg_block_name);
main_xcord += 18;
mvwprintw(text_win,
main_ycord,
main_xcord,
bg_block_state_string(
db2_info_ptr->state));
main_xcord += 7;
if (db2_info_ptr->job_running > NO_JOB_RUNNING)
snprintf(tmp_char, sizeof(tmp_char),
"%d",
db2_info_ptr->job_running);
else
snprintf(tmp_char, sizeof(tmp_char),
"-");
mvwprintw(text_win,
main_ycord,
main_xcord,
"%.8s", tmp_char);
main_xcord += 8;
mvwprintw(text_win,
main_ycord,
main_xcord, "%.8s",
db2_info_ptr->bg_user_name);
main_xcord += 9;
conn_str = conn_type_string_full(
db2_info_ptr->bg_conn_type);
mvwprintw(text_win,
main_ycord,
main_xcord, "%.7s",
conn_str);
xfree(conn_str);
main_xcord += 8;
if (params.cluster_flags & CLUSTER_FLAG_BGL) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%.9s",
node_use_string(
db2_info_ptr->
bg_node_use));
main_xcord += 10;
}
} else {
mvwprintw(text_win,
main_ycord,
main_xcord, "?");
main_xcord += 18;
mvwprintw(text_win,
main_ycord,
main_xcord, "?");
main_xcord += 7;
mvwprintw(text_win,
main_ycord,
main_xcord, "?");
main_xcord += 8;
mvwprintw(text_win,
main_ycord,
main_xcord, "?");
main_xcord += 9;
mvwprintw(text_win,
main_ycord,
main_xcord, "?");
main_xcord += 7;
mvwprintw(text_win,
main_ycord,
main_xcord, "?");
main_xcord += 10;
}
}
mvwprintw(text_win,
main_ycord,
main_xcord, "%5s", tmp_cnt);
main_xcord += 7;
tempxcord = main_xcord;
if (params.display == BGPART)
nodes = part_ptr->allow_groups;
else
nodes = part_ptr->nodes;
i = 0;
prefixlen = i;
while (nodes && nodes[i]) {
width = text_win->_maxx
- main_xcord;
if (!prefixlen && (nodes[i] == '[') &&
(nodes[i - 1] == ','))
prefixlen = i + 1;
if (nodes[i - 1] == ',' && (width - 12) <= 0) {
main_ycord++;
main_xcord = tempxcord + prefixlen;
} else if (main_xcord >
text_win->_maxx) {
main_ycord++;
main_xcord = tempxcord + prefixlen;
}
if ((printed = mvwaddch(text_win,
main_ycord,
main_xcord,
nodes[i])) < 0)
return printed;
main_xcord++;
i++;
}
if ((params.display == BGPART) && db2_info_ptr &&
(db2_info_ptr->ionode_str)) {
mvwprintw(text_win,
main_ycord,
main_xcord, "[%s]",
db2_info_ptr->ionode_str);
}
main_xcord = 1;
main_ycord++;
} else {
if (part_ptr->name) {
printf("%9.9s ", part_ptr->name);
if (params.display != BGPART) {
if (part_ptr->state_up == PARTITION_INACTIVE)
printf(" inact ");
else if (part_ptr->state_up == PARTITION_UP)
printf(" up ");
else if (part_ptr->state_up == PARTITION_DOWN)
printf(" down ");
else if (part_ptr->state_up == PARTITION_DRAIN)
printf(" drain ");
else
printf(" unk ");
if (part_ptr->max_time == INFINITE)
snprintf(time_buf, sizeof(time_buf),
"infinite");
else {
secs2time_str((part_ptr->max_time
* 60),
time_buf,
sizeof(time_buf));
}
width = strlen(time_buf);
printf("%9.9s ", time_buf);
}
}
if (params.display == BGPART) {
if (db2_info_ptr) {
printf("%16.16s ",
db2_info_ptr->bg_block_name);
printf("%5.5s ",
bg_block_state_string(
db2_info_ptr->state));
if (db2_info_ptr->job_running > NO_JOB_RUNNING)
snprintf(tmp_char, sizeof(tmp_char),
"%d",
db2_info_ptr->job_running);
else
snprintf(tmp_char, sizeof(tmp_char),
"-");
printf("%8.8s ", tmp_char);
printf("%8.8s ", db2_info_ptr->bg_user_name);
conn_str = conn_type_string_full(
db2_info_ptr->bg_conn_type);
printf("%8.8s ", conn_str);
xfree(conn_str);
if (params.cluster_flags & CLUSTER_FLAG_BGL)
printf("%9.9s ", node_use_string(
db2_info_ptr->
bg_node_use));
}
}
printf("%5s ", tmp_cnt);
if (params.display == BGPART)
nodes = part_ptr->allow_groups;
else
nodes = part_ptr->nodes;
if ((params.display == BGPART) && db2_info_ptr &&
(db2_info_ptr->ionode_str)) {
printf("%s[%s]\n", nodes, db2_info_ptr->ionode_str);
} else
printf("%s\n",nodes);
}
return printed;
}
/*
* slurm_sprint_job_step_info - output information about a specific Slurm
* job step based upon message as loaded using slurm_get_job_steps
* IN job_ptr - an individual job step 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_job_step_info ( job_step_info_t * job_step_ptr,
int one_liner )
{
char time_str[32];
char limit_str[32];
char tmp_line[128];
char *out = NULL;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
/****** Line 1 ******/
slurm_make_time_str ((time_t *)&job_step_ptr->start_time, time_str,
sizeof(time_str));
if (job_step_ptr->time_limit == INFINITE)
sprintf(limit_str, "UNLIMITED");
else
secs2time_str ((time_t)job_step_ptr->time_limit * 60,
limit_str, sizeof(limit_str));
snprintf(tmp_line, sizeof(tmp_line),
"StepId=%u.%u UserId=%u StartTime=%s TimeLimit=%s",
job_step_ptr->job_id, job_step_ptr->step_id,
job_step_ptr->user_id, time_str, limit_str);
out = xstrdup(tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 2 ******/
if (cluster_flags & CLUSTER_FLAG_BG) {
char *io_nodes;
select_g_select_jobinfo_get(job_step_ptr->select_jobinfo,
SELECT_JOBDATA_IONODES,
&io_nodes);
snprintf(tmp_line, sizeof(tmp_line),
"Partition=%s BP_List=%s[%s] Gres=%s",
job_step_ptr->partition,
job_step_ptr->nodes, io_nodes,
job_step_ptr->gres);
xfree(io_nodes);
} else {
snprintf(tmp_line, sizeof(tmp_line),
"Partition=%s Nodes=%s Gres=%s",
job_step_ptr->partition, job_step_ptr->nodes,
job_step_ptr->gres);
}
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 3 ******/
snprintf(tmp_line, sizeof(tmp_line),
"Tasks=%u Name=%s Network=%s",
job_step_ptr->num_tasks, job_step_ptr->name,
job_step_ptr->network);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 4 ******/
snprintf(tmp_line, sizeof(tmp_line),
"ResvPorts=%s Checkpoint=%u CheckpointDir=%s\n\n",
job_step_ptr->resv_ports,
job_step_ptr->ckpt_interval, job_step_ptr->ckpt_dir);
xstrcat(out, tmp_line);
return out;
}
/*
* 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 *out = NULL;
char *allow_deny, *value;
uint16_t force, preempt_mode, val;
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->cpu_bind) {
char tmp_str[128];
slurm_sprint_cpu_bind_type(tmp_str, part_ptr->cpu_bind);
xstrfmtcat(out, " CpuBind=%s ", tmp_str);
}
if (part_ptr->qos_char)
xstrfmtcat(out, " QoS=%s", part_ptr->qos_char);
else
xstrcat(out, " QoS=N/A");
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
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);
}
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 7 ******/
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 == INFINITE16)
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");
xstrfmtcat(out, " TotalCPUs=%u", part_ptr->total_cpus);
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 ******/
value = job_defaults_str(part_ptr->job_defaults_list);
xstrfmtcat(out, "JobDefaults=%s", value);
xfree(value);
xstrcat(out, line_end);
/****** Line ******/
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;
}
static void
_print_conf(void)
{
slurm_ctl_conf_t *cf;
char *str, time_str[32];
int i;
cf = slurm_conf_lock();
debug3("NodeName = %s", conf->node_name);
debug3("TopoAddr = %s", conf->node_topo_addr);
debug3("TopoPattern = %s", conf->node_topo_pattern);
if (cf->group_info & GROUP_CACHE)
i = 1;
else
i = 0;
debug3("CacheGroups = %d", i);
debug3("Confile = `%s'", conf->conffile);
debug3("Debug = %d", cf->slurmd_debug);
debug3("CPUs = %-2u (CF: %2u, HW: %2u)",
conf->cpus,
conf->conf_cpus,
conf->actual_cpus);
debug3("Boards = %-2u (CF: %2u, HW: %2u)",
conf->boards,
conf->conf_boards,
conf->actual_boards);
debug3("Sockets = %-2u (CF: %2u, HW: %2u)",
conf->sockets,
conf->conf_sockets,
conf->actual_sockets);
debug3("Cores = %-2u (CF: %2u, HW: %2u)",
conf->cores,
conf->conf_cores,
conf->actual_cores);
debug3("Threads = %-2u (CF: %2u, HW: %2u)",
conf->threads,
conf->conf_threads,
conf->actual_threads);
secs2time_str((time_t)conf->up_time, time_str, sizeof(time_str));
debug3("UpTime = %u = %s", conf->up_time, time_str);
str = xmalloc(conf->block_map_size*5);
str[0] = '\0';
for (i = 0; i < conf->block_map_size; i++) {
char id[10];
sprintf(id, "%u,", conf->block_map[i]);
strcat(str, id);
}
str[strlen(str)-1] = '\0'; /* trim trailing "," */
debug3("Block Map = %s", str);
str[0] = '\0';
for (i = 0; i < conf->block_map_size; i++) {
char id[10];
sprintf(id, "%u,", conf->block_map_inv[i]);
strcat(str, id);
}
str[strlen(str)-1] = '\0'; /* trim trailing "," */
debug3("Inverse Map = %s", str);
xfree(str);
debug3("RealMemory = %u", conf->real_memory_size);
debug3("TmpDisk = %u", conf->tmp_disk_space);
debug3("Epilog = `%s'", conf->epilog);
debug3("Logfile = `%s'", cf->slurmd_logfile);
debug3("HealthCheck = `%s'", conf->health_check_program);
debug3("NodeName = %s", conf->node_name);
debug3("NodeAddr = %s", conf->node_addr);
debug3("Port = %u", conf->port);
debug3("Prolog = `%s'", conf->prolog);
debug3("TmpFS = `%s'", conf->tmpfs);
debug3("Public Cert = `%s'", conf->pubkey);
debug3("Slurmstepd = `%s'", conf->stepd_loc);
debug3("Spool Dir = `%s'", conf->spooldir);
debug3("Pid File = `%s'", conf->pidfile);
debug3("Slurm UID = %u", conf->slurm_user_id);
debug3("TaskProlog = `%s'", conf->task_prolog);
debug3("TaskEpilog = `%s'", conf->task_epilog);
debug3("TaskPluginParam = %u", conf->task_plugin_param);
debug3("Use PAM = %u", conf->use_pam);
slurm_conf_unlock();
}
static int _print_text_part(partition_info_t *part_ptr)
{
int printed = 0;
int tempxcord;
int prefixlen;
int i = 0;
int width = 0;
char *nodes = NULL, time_buf[20];
char tmp_cnt[8];
snprintf(tmp_cnt, sizeof(tmp_cnt), "%u", part_ptr->total_nodes);
if (!params.commandline) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%c",
part_ptr->flags);
main_xcord += 4;
if (part_ptr->name) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%.9s",
part_ptr->name);
main_xcord += 10;
char *tmp_state;
if (part_ptr->state_up == PARTITION_INACTIVE)
tmp_state = "inact";
else if (part_ptr->state_up == PARTITION_UP)
tmp_state = "up";
else if (part_ptr->state_up == PARTITION_DOWN)
tmp_state = "down";
else if (part_ptr->state_up == PARTITION_DRAIN)
tmp_state = "drain";
else
tmp_state = "unk";
mvwprintw(text_win, main_ycord, main_xcord,
tmp_state);
main_xcord += 7;
if (part_ptr->max_time == INFINITE)
snprintf(time_buf, sizeof(time_buf),
"infinite");
else
secs2time_str((part_ptr->max_time * 60),
time_buf, sizeof(time_buf));
width = strlen(time_buf);
mvwprintw(text_win, main_ycord,
main_xcord + (9 - width),
"%s", time_buf);
main_xcord += 11;
} else
main_xcord += 10;
mvwprintw(text_win,
main_ycord,
main_xcord, "%5s", tmp_cnt);
main_xcord += 7;
tempxcord = main_xcord;
nodes = part_ptr->nodes;
i = 0;
prefixlen = i;
while (nodes && nodes[i]) {
width = getmaxx(text_win) - 1 - main_xcord;
if (!prefixlen && (nodes[i] == '[') &&
(nodes[i - 1] == ','))
prefixlen = i + 1;
if (nodes[i - 1] == ',' && (width - 12) <= 0) {
main_ycord++;
main_xcord = tempxcord + prefixlen;
} else if (main_xcord >= getmaxx(text_win)) {
main_ycord++;
main_xcord = tempxcord + prefixlen;
}
if ((printed = mvwaddch(text_win,
main_ycord,
main_xcord,
nodes[i])) < 0)
return printed;
main_xcord++;
i++;
}
main_xcord = 1;
main_ycord++;
} else {
if (part_ptr->name) {
printf("%9.9s ", part_ptr->name);
if (part_ptr->state_up == PARTITION_INACTIVE)
printf(" inact ");
else if (part_ptr->state_up == PARTITION_UP)
printf(" up ");
else if (part_ptr->state_up == PARTITION_DOWN)
printf(" down ");
else if (part_ptr->state_up == PARTITION_DRAIN)
printf(" drain ");
else
printf(" unk ");
if (part_ptr->max_time == INFINITE)
snprintf(time_buf, sizeof(time_buf),
"infinite");
else
secs2time_str((part_ptr->max_time * 60),
time_buf, sizeof(time_buf));
printf("%9.9s ", time_buf);
}
printf("%5s ", tmp_cnt);
printf("%s\n", part_ptr->nodes);
}
return printed;
}
