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; }