/* updates the burst buffer record on sview */
static void _update_bb_record(sview_bb_info_t *sview_bb_info_ptr,
GtkTreeStore *treestore)
{
char tmp_create_time[40];
char tmp_size[20], tmp_user_id[60], bb_name_id[32];
char *tmp_state, *tmp_user_name;
burst_buffer_resv_t *bb_ptr = sview_bb_info_ptr->bb_ptr;
if (bb_ptr->name) {
strncpy(bb_name_id, bb_ptr->name, sizeof(bb_name_id));
} else if (bb_ptr->array_task_id == NO_VAL) {
convert_num_unit(bb_ptr->job_id, bb_name_id,
sizeof(bb_name_id),
UNIT_NONE, working_sview_config.convert_flags);
} else {
snprintf(bb_name_id, sizeof(bb_name_id),
"%u_%u(%u)",
bb_ptr->array_job_id,
bb_ptr->array_task_id,
bb_ptr->job_id);
}
if (bb_ptr->create_time) {
slurm_make_time_str((time_t *)&bb_ptr->create_time,
tmp_create_time, sizeof(tmp_create_time));
} else {
time_t now = time(NULL);
slurm_make_time_str(&now, tmp_create_time,
sizeof(tmp_create_time));
}
_get_size_str(tmp_size, sizeof(tmp_size), bb_ptr->size);
tmp_state = bb_state_string(bb_ptr->state);
tmp_user_name = uid_to_string(bb_ptr->user_id);
snprintf(tmp_user_id, sizeof(tmp_user_id), "%s(%u)", tmp_user_name,
bb_ptr->user_id);
xfree(tmp_user_name);
/* Combining these records provides a slight performance improvement */
gtk_tree_store_set(treestore, &sview_bb_info_ptr->iter_ptr,
SORTID_COLOR,
sview_colors[sview_bb_info_ptr->color_inx],
SORTID_COLOR_INX, sview_bb_info_ptr->color_inx,
SORTID_PLUGIN, sview_bb_info_ptr->plugin,
SORTID_ACCOUNT, bb_ptr->account,
SORTID_CREATE_TIME, tmp_create_time,
SORTID_NAME, bb_name_id,
SORTID_PARTITION, bb_ptr->partition,
SORTID_POOL, bb_ptr->pool,
SORTID_QOS, bb_ptr->qos,
SORTID_SIZE, tmp_size,
SORTID_STATE, tmp_state,
SORTID_UPDATED, 1,
SORTID_USERID, tmp_user_id,
-1);
return;
}
static void _print_burst_buffer_resv(FILE *out,
burst_buffer_resv_t* burst_buffer_ptr,
int one_liner, bool verbose)
{
char sz_buf[32], time_buf[64], tmp_line[512];
char *out_buf = NULL;
/****** Line 1 ******/
if (burst_buffer_ptr->job_id &&
(burst_buffer_ptr->array_task_id == NO_VAL)) {
snprintf(tmp_line, sizeof(tmp_line),
" JobID=%u ", burst_buffer_ptr->job_id);
} else if (burst_buffer_ptr->job_id) {
snprintf(tmp_line, sizeof(tmp_line),
" JobID=%u_%u(%u) ",
burst_buffer_ptr->array_job_id,
burst_buffer_ptr->array_task_id,
burst_buffer_ptr->job_id);
} else {
snprintf(tmp_line, sizeof(tmp_line),
" Name=%s ", burst_buffer_ptr->name);
}
xstrcat(out_buf, tmp_line);
_get_size_str(sz_buf, sizeof(sz_buf), burst_buffer_ptr->size);
if (burst_buffer_ptr->create_time) {
slurm_make_time_str(&burst_buffer_ptr->create_time, time_buf,
sizeof(time_buf));
} else {
time_t now = time(NULL);
slurm_make_time_str(&now, time_buf, sizeof(time_buf));
}
if (verbose) {
snprintf(tmp_line, sizeof(tmp_line),
"Account=%s CreateTime=%s Partition=%s Pool=%s QOS=%s "
"Size=%s State=%s UserID=%s(%u)",
burst_buffer_ptr->account, time_buf,
burst_buffer_ptr->partition, burst_buffer_ptr->pool,
burst_buffer_ptr->qos,
sz_buf, bb_state_string(burst_buffer_ptr->state),
uid_to_string(burst_buffer_ptr->user_id),
burst_buffer_ptr->user_id);
} else {
snprintf(tmp_line, sizeof(tmp_line),
"CreateTime=%s Pool=%s Size=%s State=%s UserID=%s(%u)",
time_buf, burst_buffer_ptr->pool, sz_buf,
bb_state_string(burst_buffer_ptr->state),
uid_to_string(burst_buffer_ptr->user_id),
burst_buffer_ptr->user_id);
}
xstrcat(out_buf, tmp_line);
xstrcat(out_buf, "\n");
fprintf(out, "%s", out_buf);
xfree(out_buf);
}
/* Log recousrces to be allocated to a pending job */
static void _dump_job_sched(struct job_record *job_ptr, time_t end_time,
bitstr_t *avail_bitmap)
{
char begin_buf[32], end_buf[32], *node_list;
slurm_make_time_str(&job_ptr->start_time, begin_buf, sizeof(begin_buf));
slurm_make_time_str(&end_time, end_buf, sizeof(end_buf));
node_list = bitmap2node_name(avail_bitmap);
info("Job %u to start at %s, end at %s on %s",
job_ptr->job_id, begin_buf, end_buf, node_list);
xfree(node_list);
}
/*
* slurm_print_slurmd_status - output the contents of slurmd status
* message as loaded using slurm_load_slurmd_status
* IN out - file to write to
* IN slurmd_status_ptr - slurmd status pointer
*/
void slurm_print_slurmd_status (FILE* out,
slurmd_status_t * slurmd_status_ptr)
{
char time_str[32];
if (slurmd_status_ptr == NULL )
return ;
fprintf(out, "Active Steps = %s\n",
slurmd_status_ptr->step_list);
fprintf(out, "Actual CPUs = %u\n",
slurmd_status_ptr->actual_cpus);
fprintf(out, "Actual Boards = %u\n",
slurmd_status_ptr->actual_boards);
fprintf(out, "Actual sockets = %u\n",
slurmd_status_ptr->actual_sockets);
fprintf(out, "Actual cores = %u\n",
slurmd_status_ptr->actual_cores);
fprintf(out, "Actual threads per core = %u\n",
slurmd_status_ptr->actual_threads);
fprintf(out, "Actual real memory = %u MB\n",
slurmd_status_ptr->actual_real_mem);
fprintf(out, "Actual temp disk space = %u MB\n",
slurmd_status_ptr->actual_tmp_disk);
slurm_make_time_str ((time_t *)&slurmd_status_ptr->booted,
time_str, sizeof(time_str));
fprintf(out, "Boot time = %s\n", time_str);
fprintf(out, "Hostname = %s\n",
slurmd_status_ptr->hostname);
if (slurmd_status_ptr->last_slurmctld_msg) {
slurm_make_time_str ((time_t *)
&slurmd_status_ptr->last_slurmctld_msg,
time_str, sizeof(time_str));
fprintf(out, "Last slurmctld msg time = %s\n", time_str);
} else
fprintf(out, "Last slurmctld msg time = NONE\n");
fprintf(out, "Slurmd PID = %u\n",
slurmd_status_ptr->pid);
fprintf(out, "Slurmd Debug = %u\n",
slurmd_status_ptr->slurmd_debug);
fprintf(out, "Slurmd Logfile = %s\n",
slurmd_status_ptr->slurmd_logfile);
fprintf(out, "Version = %s\n",
slurmd_status_ptr->version);
return;
}
/*
* slurm_sprint_reservation_info - output information about a specific Slurm
* reservation based upon message as loaded using slurm_load_reservations
* IN resv_ptr - an individual reservation 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_reservation_info ( reserve_info_t * resv_ptr,
int one_liner )
{
char tmp1[32], tmp2[32], tmp3[32], *flag_str = NULL;
char tmp_line[MAXHOSTRANGELEN];
char *out = NULL;
uint32_t duration;
/****** Line 1 ******/
slurm_make_time_str(&resv_ptr->start_time, tmp1, sizeof(tmp1));
slurm_make_time_str(&resv_ptr->end_time, tmp2, sizeof(tmp2));
duration = difftime(resv_ptr->end_time, resv_ptr->start_time);
secs2time_str(duration, tmp3, sizeof(tmp3));
snprintf(tmp_line, sizeof(tmp_line),
"ReservationName=%s StartTime=%s EndTime=%s Duration=%s",
resv_ptr->name, tmp1, tmp2, tmp3);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 2 ******/
flag_str = reservation_flags_string(resv_ptr->flags);
snprintf(tmp_line, sizeof(tmp_line),
"Nodes=%s NodeCnt=%u Features=%s PartitionName=%s Flags=%s",
resv_ptr->node_list, resv_ptr->node_cnt,
resv_ptr->features, resv_ptr->partition, flag_str);
xfree(flag_str);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, " ");
else
xstrcat(out, "\n ");
/****** Line 3 ******/
snprintf(tmp_line, sizeof(tmp_line),
"Users=%s Accounts=%s Licenses=%s",
resv_ptr->users, resv_ptr->accounts, resv_ptr->licenses);
xstrcat(out, tmp_line);
if (one_liner)
xstrcat(out, "\n");
else
xstrcat(out, "\n\n");
return out;
}
/*
* slurm_job_will_run - determine if a job would execute immediately if
* submitted now
* IN job_desc_msg - description of resource allocation request
* RET 0 on success, otherwise return -1 and set errno to indicate the error
*/
int slurm_job_will_run(job_desc_msg_t *req)
{
will_run_response_msg_t *will_run_resp = NULL;
char buf[64], local_hostname[64];
int rc;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
char *type = "processors";
char *cluster_name = NULL;
void *ptr = NULL;
if ((req->alloc_node == NULL) &&
(gethostname_short(local_hostname, sizeof(local_hostname)) == 0)) {
req->alloc_node = local_hostname;
}
if (working_cluster_rec)
cluster_name = working_cluster_rec->name;
else
cluster_name = slurmctld_conf.cluster_name;
if (!slurm_load_federation(&ptr) &&
cluster_in_federation(ptr, cluster_name))
rc = _fed_job_will_run(req, &will_run_resp, ptr);
else
rc = slurm_job_will_run2(req, &will_run_resp);
if ((rc == 0) && will_run_resp) {
if (cluster_flags & CLUSTER_FLAG_BG)
type = "cnodes";
slurm_make_time_str(&will_run_resp->start_time,
buf, sizeof(buf));
info("Job %u to start at %s using %u %s on %s",
will_run_resp->job_id, buf,
will_run_resp->proc_cnt, type,
will_run_resp->node_list);
if (will_run_resp->preemptee_job_id) {
ListIterator itr;
uint32_t *job_id_ptr;
char *job_list = NULL, *sep = "";
itr = list_iterator_create(will_run_resp->
preemptee_job_id);
while ((job_id_ptr = list_next(itr))) {
if (job_list)
sep = ",";
xstrfmtcat(job_list, "%s%u", sep, *job_id_ptr);
}
list_iterator_destroy(itr);
info(" Preempts: %s", job_list);
xfree(job_list);
}
slurm_free_will_run_response_msg(will_run_resp);
}
if (req->alloc_node == local_hostname)
req->alloc_node = NULL;
if (ptr)
slurm_destroy_federation_rec(ptr);
return rc;
}
/*
* slurm_print_ctl_conf - output the contents of slurm control configuration
* message as loaded using slurm_load_ctl_conf
* IN out - file to write to
* IN slurm_ctl_conf_ptr - slurm control configuration pointer
*/
void slurm_print_ctl_conf ( FILE* out,
slurm_ctl_conf_info_msg_t * slurm_ctl_conf_ptr )
{
char time_str[32], tmp_str[128];
void *ret_list = NULL;
char *select_title = "";
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
if (cluster_flags & CLUSTER_FLAG_BGL)
select_title = "\nBluegene/L configuration\n";
else if (cluster_flags & CLUSTER_FLAG_BGP)
select_title = "\nBluegene/P configuration\n";
else if (cluster_flags & CLUSTER_FLAG_BGQ)
select_title = "\nBluegene/Q configuration\n";
if ( slurm_ctl_conf_ptr == NULL )
return ;
slurm_make_time_str((time_t *)&slurm_ctl_conf_ptr->last_update,
time_str, sizeof(time_str));
snprintf(tmp_str, sizeof(tmp_str), "Configuration data as of %s\n",
time_str);
ret_list = slurm_ctl_conf_2_key_pairs(slurm_ctl_conf_ptr);
if (ret_list) {
slurm_print_key_pairs(out, ret_list, tmp_str);
list_destroy((List)ret_list);
}
slurm_print_key_pairs(out, slurm_ctl_conf_ptr->select_conf_key_pairs,
select_title);
}
static void _print_slurm_config(void)
{
time_t now = time(NULL);
char tmp_str[128], *user_name = NULL;
slurm_make_time_str(&now, tmp_str, sizeof(tmp_str));
printf("Configuration data as of %s\n", tmp_str);
printf("AccountingStorageBackupHost = %s\n", acct_storage_backup_host);
printf("AccountingStorageHost = %s\n", acct_storage_host);
printf("AccountingStorageLoc = %s\n", acct_storage_loc);
printf("AccountingStoragePass = %s\n", acct_storage_pass);
printf("AccountingStoragePort = %u\n", acct_storage_port);
printf("AccountingStorageType = %s\n", acct_storage_type);
printf("AccountingStorageUser = %s\n", acct_storage_user);
printf("AuthType = %s\n", auth_type);
printf("MessageTimeout = %u sec\n", msg_timeout);
printf("PluginDir = %s\n", plugin_dir);
private_data_string(private_data, tmp_str, sizeof(tmp_str));
printf("PrivateData = %s\n", tmp_str);
user_name = uid_to_string(slurm_user_id);
printf("SlurmUserId = %s(%u)\n", user_name, slurm_user_id);
xfree(user_name);
printf("SLURM_CONF = %s\n", default_slurm_config_file);
printf("SLURM_VERSION = %s\n", SLURM_VERSION_STRING);
printf("TrackWCKey = %u\n", track_wckey);
}
extern uint16_t
scontrol_get_job_state(uint32_t job_id)
{
job_info_msg_t * job_buffer_ptr = NULL;
int error_code = SLURM_SUCCESS, i;
job_info_t *job_ptr = NULL;
error_code = scontrol_load_job(&job_buffer_ptr, job_id);
if (error_code) {
exit_code = 1;
if (quiet_flag == -1)
slurm_perror ("slurm_load_job error");
return (uint16_t) NO_VAL;
}
if (quiet_flag == -1) {
char time_str[32];
slurm_make_time_str((time_t *)&job_buffer_ptr->last_update,
time_str, sizeof(time_str));
printf("last_update_time=%s, records=%d\n",
time_str, job_buffer_ptr->record_count);
}
job_ptr = job_buffer_ptr->job_array ;
for (i = 0; i < job_buffer_ptr->record_count; i++) {
if (job_ptr->job_id == job_id)
return job_ptr->job_state;
}
if (quiet_flag == -1)
printf("Could not find job %u", job_id);
return (uint16_t) NO_VAL;
}
static void _update_resv_record(sview_resv_info_t *sview_resv_info_ptr,
GtkTreeStore *treestore)
{
char tmp_duration[40], tmp_end[40], tmp_nodes[40], tmp_start[40];
char *tmp_flags;
reserve_info_t *resv_ptr = sview_resv_info_ptr->resv_ptr;
secs2time_str((uint32_t)difftime(resv_ptr->end_time,
resv_ptr->start_time),
tmp_duration, sizeof(tmp_duration));
slurm_make_time_str((time_t *)&resv_ptr->end_time, tmp_end,
sizeof(tmp_end));
tmp_flags = reservation_flags_string(resv_ptr->flags);
convert_num_unit((float)resv_ptr->node_cnt,
tmp_nodes, sizeof(tmp_nodes), UNIT_NONE);
slurm_make_time_str((time_t *)&resv_ptr->start_time, tmp_start,
sizeof(tmp_start));
/* Combining these records provides a slight performance improvement */
gtk_tree_store_set(treestore, &sview_resv_info_ptr->iter_ptr,
SORTID_ACCOUNTS, resv_ptr->accounts,
SORTID_COLOR,
sview_colors[sview_resv_info_ptr->color_inx],
SORTID_COLOR_INX, sview_resv_info_ptr->color_inx,
SORTID_DURATION, tmp_duration,
SORTID_FEATURES, resv_ptr->features,
SORTID_FLAGS, tmp_flags,
SORTID_LICENSES, resv_ptr->licenses,
SORTID_NAME, resv_ptr->name,
SORTID_NODE_CNT, tmp_nodes,
SORTID_NODE_INX, resv_ptr->node_inx,
SORTID_NODELIST, resv_ptr->node_list,
SORTID_PARTITION, resv_ptr->partition,
SORTID_TIME_START, tmp_start,
SORTID_TIME_END, tmp_end,
SORTID_UPDATED, 1,
SORTID_USERS, resv_ptr->users,
-1);
xfree(tmp_flags);
return;
}
/*
* scontrol_print_node_list - print information about the supplied node list
* (or regular expression)
* IN node_list - print information about the supplied node list
* (or regular expression)
*/
extern void
scontrol_print_node_list (char *node_list)
{
node_info_msg_t *node_info_ptr = NULL;
hostlist_t host_list;
int error_code;
uint16_t show_flags = 0;
char *this_node_name;
if (all_flag)
show_flags |= SHOW_ALL;
if (detail_flag)
show_flags |= SHOW_DETAIL;
error_code = scontrol_load_nodes(&node_info_ptr, show_flags);
if (error_code) {
exit_code = 1;
if (quiet_flag != 1)
slurm_perror ("slurm_load_node error");
return;
}
if (quiet_flag == -1) {
char time_str[32];
slurm_make_time_str ((time_t *)&node_info_ptr->last_update,
time_str, sizeof(time_str));
printf ("last_update_time=%s, records=%d\n",
time_str, node_info_ptr->record_count);
}
if (node_list == NULL) {
scontrol_print_node (NULL, node_info_ptr);
} else {
if ((host_list = hostlist_create (node_list))) {
while ((this_node_name = hostlist_shift (host_list))) {
scontrol_print_node(this_node_name,
node_info_ptr);
free(this_node_name);
}
hostlist_destroy(host_list);
} else {
exit_code = 1;
if (quiet_flag != 1) {
if (errno == EINVAL) {
fprintf(stderr,
"unable to parse node list %s\n",
node_list);
} else if (errno == ERANGE) {
fprintf(stderr,
"too many nodes in supplied range %s\n",
node_list);
} else
perror("error parsing node list");
}
}
}
return;
}
/*
* scontrol_print_job - print the specified job's information
* IN job_id - job's id or NULL to print information about all jobs
*/
extern void
scontrol_print_job (char * job_id_str)
{
int error_code = SLURM_SUCCESS, i, print_cnt = 0;
uint32_t job_id = 0;
uint16_t array_id = (uint16_t) NO_VAL;
job_info_msg_t * job_buffer_ptr = NULL;
job_info_t *job_ptr = NULL;
char *end_ptr = NULL;
if (job_id_str) {
job_id = (uint32_t) strtol (job_id_str, &end_ptr, 10);
if (end_ptr[0] == '_')
array_id = strtol( end_ptr + 1, &end_ptr, 10 );
}
error_code = scontrol_load_job(&job_buffer_ptr, job_id);
if (error_code) {
exit_code = 1;
if (quiet_flag != 1)
slurm_perror ("slurm_load_jobs error");
return;
}
if (quiet_flag == -1) {
char time_str[32];
slurm_make_time_str ((time_t *)&job_buffer_ptr->last_update,
time_str, sizeof(time_str));
printf ("last_update_time=%s, records=%d\n",
time_str, job_buffer_ptr->record_count);
}
job_ptr = job_buffer_ptr->job_array ;
for (i = 0, job_ptr = job_buffer_ptr->job_array;
i < job_buffer_ptr->record_count; i++, job_ptr++) {
if ((array_id != (uint16_t) NO_VAL) &&
(array_id != job_ptr->array_task_id))
continue;
slurm_print_job_info(stdout, job_ptr, one_liner);
print_cnt++;
}
if (print_cnt == 0) {
if (job_id_str) {
exit_code = 1;
if (quiet_flag != 1) {
if (array_id == (uint16_t) NO_VAL) {
printf("Job %u not found\n", job_id);
} else {
printf("Job %u_%u not found\n",
job_id, array_id);
}
}
} else if (quiet_flag != 1)
printf ("No jobs in the system\n");
}
}
static void _handle_timeout(srun_timeout_msg_t *timeout_msg)
{
time_t now = time(NULL);
char time_str[24];
if (now < timeout_msg->timeout) {
slurm_make_time_str(&timeout_msg->timeout,
time_str, sizeof(time_str));
debug("step %u.%u will timeout at %s",
timeout_msg->job_id, timeout_msg->step_id, time_str);
return;
}
slurm_make_time_str(&now, time_str, sizeof(time_str));
error("*** STEP %u.%u CANCELLED AT %s DUE TO TIME LIMIT ***",
timeout_msg->job_id, timeout_msg->step_id, time_str);
launch_p_fwd_signal(SIGKILL);
return;
}
int _print_time(time_t t, int level, int width, bool right)
{
if (t) {
char time_str[32];
slurm_make_time_str(&t, time_str, sizeof(time_str));
_print_str(time_str, width, right, true);
} else
_print_str("N/A", width, right, true);
return SLURM_SUCCESS;
}
static void _layout_conf_ctl(GtkTreeStore *treestore,
slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr)
{
char temp_str[128];
int update = 0;
GtkTreeIter iter;
ListIterator itr = NULL;
config_key_pair_t *key_pair;
List ret_list = NULL;
char *select_title = "";
if (cluster_flags & CLUSTER_FLAG_BGL)
select_title = "Bluegene/L configuration";
else if (cluster_flags & CLUSTER_FLAG_BGP)
select_title = "Bluegene/P configuration";
else if (cluster_flags & CLUSTER_FLAG_BGQ)
select_title = "Bluegene/Q configuration";
if (!slurm_ctl_conf_ptr)
return;
slurm_make_time_str((time_t *)&slurm_ctl_conf_ptr->last_update,
temp_str, sizeof(temp_str));
add_display_treestore_line_with_font(
update, treestore, &iter,
"Configuration data as of", temp_str, "bold");
ret_list = slurm_ctl_conf_2_key_pairs(slurm_ctl_conf_ptr);
if (ret_list) {
itr = list_iterator_create(ret_list);
while ((key_pair = list_next(itr))) {
add_display_treestore_line(update, treestore, &iter,
key_pair->name,
key_pair->value);
}
list_iterator_destroy(itr);
list_destroy(ret_list);
}
if (!slurm_ctl_conf_ptr->select_conf_key_pairs)
return;
add_display_treestore_line(update, treestore, &iter,
"", NULL);
add_display_treestore_line_with_font(update, treestore, &iter,
select_title, NULL, "bold");
itr = list_iterator_create(
(List)slurm_ctl_conf_ptr->select_conf_key_pairs);
while ((key_pair = list_next(itr))) {
add_display_treestore_line(update, treestore, &iter,
key_pair->name, key_pair->value);
}
list_iterator_destroy(itr);
}
/* Log resource allocate table */
static void _dump_node_space_table(node_space_map_t *node_space_ptr)
{
int i = 0;
char begin_buf[32], end_buf[32], *node_list;
info("=========================================");
while (1) {
slurm_make_time_str(&node_space_ptr[i].begin_time,
begin_buf, sizeof(begin_buf));
slurm_make_time_str(&node_space_ptr[i].end_time,
end_buf, sizeof(end_buf));
node_list = bitmap2node_name(node_space_ptr[i].avail_bitmap);
info("Begin:%s End:%s Nodes:%s",
begin_buf, end_buf, node_list);
xfree(node_list);
if ((i = node_space_ptr[i].next) == 0)
break;
}
info("=========================================");
}
static void *_monitor(void *arg)
{
stepd_step_rec_t *job = (stepd_step_rec_t *)arg;
struct timespec ts = {0, 0};
int rc;
debug2("step_terminate_monitor will run for %d secs", timeout);
ts.tv_sec = time(NULL) + 1 + timeout;
slurm_mutex_lock(&lock);
if (stop_flag)
goto done;
rc = pthread_cond_timedwait(&cond, &lock, &ts);
if (rc == ETIMEDOUT) {
char entity[24], time_str[24];
time_t now = time(NULL);
int rc;
_call_external_program(job);
if (job->stepid == SLURM_BATCH_SCRIPT) {
snprintf(entity, sizeof(entity),
"JOB %u", job->jobid);
} else if (job->stepid == SLURM_EXTERN_CONT) {
snprintf(entity, sizeof(entity),
"EXTERN STEP FOR %u", job->jobid);
} else {
snprintf(entity, sizeof(entity), "STEP %u.%u",
job->jobid, job->stepid);
}
slurm_make_time_str(&now, time_str, sizeof(time_str));
if (job->state < SLURMSTEPD_STEP_RUNNING) {
error("*** %s STEPD TERMINATED ON %s AT %s DUE TO JOB NOT RUNNING ***",
entity, job->node_name, time_str);
rc = ESLURMD_JOB_NOTRUNNING;
} else {
error("*** %s STEPD TERMINATED ON %s AT %s DUE TO JOB NOT ENDING WITH SIGNALS ***",
entity, job->node_name, time_str);
rc = ESLURMD_KILL_TASK_FAILED;
}
exit(stepd_cleanup(NULL, job, NULL, NULL, rc, 0));
} else if (rc != 0) {
error("Error waiting on condition in _monitor: %m");
}
done:
slurm_mutex_unlock(&lock);
debug2("step_terminate_monitor is stopping");
return NULL;
}
static void _print_reservation(reserve_info_t *resv_ptr, int width)
{
char format[64], tmp1[32], tmp2[32], tmp3[32];
char *state = "INACTIVE";
uint32_t duration;
time_t now = time(NULL);
slurm_make_time_str(&resv_ptr->start_time, tmp1, sizeof(tmp1));
slurm_make_time_str(&resv_ptr->end_time, tmp2, sizeof(tmp2));
duration = difftime(resv_ptr->end_time, resv_ptr->start_time);
secs2time_str(duration, tmp3, sizeof(tmp3));
if ((resv_ptr->start_time <= now) && (resv_ptr->end_time >= now))
state = "ACTIVE";
snprintf(format, sizeof(format),
"%%-%ds %%8s %%19s %%19s %%11s %%s\n", width);
printf(format,
resv_ptr->name, state, tmp1, tmp2, tmp3, resv_ptr->node_list);
return;
}
static void _dump_job_test(struct job_record *job_ptr, bitstr_t *avail_bitmap,
time_t start_time)
{
char begin_buf[32], *node_list;
if (start_time == 0)
strcpy(begin_buf, "NOW");
else
slurm_make_time_str(&start_time, begin_buf, sizeof(begin_buf));
node_list = bitmap2node_name(avail_bitmap);
info("Test job %u at %s on %s", job_ptr->job_id, begin_buf, node_list);
xfree(node_list);
}
/*
* slurm_job_will_run - determine if a job would execute immediately if
* submitted now
* IN job_desc_msg - description of resource allocation request
* RET 0 on success, otherwise return -1 and set errno to indicate the error
*/
int slurm_job_will_run (job_desc_msg_t *req)
{
will_run_response_msg_t *will_run_resp = NULL;
char buf[64];
bool host_set = false;
int rc;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
char *type = "processors";
if ((req->alloc_node == NULL) &&
(gethostname_short(buf, sizeof(buf)) == 0)) {
req->alloc_node = buf;
host_set = true;
}
rc = slurm_job_will_run2(req, &will_run_resp);
if ((rc == 0) && will_run_resp) {
if (cluster_flags & CLUSTER_FLAG_BG)
type = "cnodes";
slurm_make_time_str(&will_run_resp->start_time,
buf, sizeof(buf));
info("Job %u to start at %s using %u %s"
" on %s",
will_run_resp->job_id, buf,
will_run_resp->proc_cnt, type,
will_run_resp->node_list);
if (will_run_resp->preemptee_job_id) {
ListIterator itr;
uint32_t *job_id_ptr;
char *job_list = NULL, *sep = "";
itr = list_iterator_create(will_run_resp->
preemptee_job_id);
while ((job_id_ptr = list_next(itr))) {
if (job_list)
sep = ",";
xstrfmtcat(job_list, "%s%u", sep, *job_id_ptr);
}
list_iterator_destroy(itr);
info(" Preempts: %s", job_list);
xfree(job_list);
}
slurm_free_will_run_response_msg(will_run_resp);
}
if (host_set)
req->alloc_node = NULL;
return rc;
}
/*
* slurm_print_job_info_msg - output information about all Slurm
* jobs based upon message as loaded using slurm_load_jobs
* IN out - file to write to
* IN job_info_msg_ptr - job information message pointer
* IN one_liner - print as a single line if true
*/
extern void
slurm_print_job_info_msg ( FILE* out, job_info_msg_t *jinfo, int one_liner )
{
int i;
job_info_t *job_ptr = jinfo->job_array;
char time_str[32];
slurm_make_time_str ((time_t *)&jinfo->last_update, time_str,
sizeof(time_str));
fprintf( out, "Job data as of %s, record count %d\n",
time_str, jinfo->record_count);
for (i = 0; i < jinfo->record_count; i++)
slurm_print_job_info(out, &job_ptr[i], one_liner);
}
/*
* slurm_print_block_info_msg - output information about all Bluegene
* blocks based upon message as loaded using slurm_load_block
* IN out - file to write to
* IN info_ptr - block information message pointer
* IN one_liner - print as a single line if true
*/
void slurm_print_block_info_msg(
FILE *out, block_info_msg_t *info_ptr, int one_liner)
{
int i ;
block_info_t * block_ptr = info_ptr->block_array;
char time_str[32];
slurm_make_time_str ((time_t *)&info_ptr->last_update, time_str,
sizeof(time_str));
fprintf( out, "Bluegene Block data as of %s, record count %d\n",
time_str, info_ptr->record_count);
for (i = 0; i < info_ptr->record_count; i++)
slurm_print_block_info(out, & block_ptr[i], one_liner);
}
extern void print_fields_date(print_field_t *field, time_t value, int last)
{
int abs_len = abs(field->len);
char temp_char[abs_len+1];
slurm_make_time_str(&value, (char *)temp_char, sizeof(temp_char));
if (print_fields_parsable_print == PRINT_FIELDS_PARSABLE_NO_ENDING
&& last)
printf("%s", temp_char);
else if (print_fields_parsable_print)
printf("%s|", temp_char);
else if (field->len == abs_len)
printf("%*.*s ", abs_len, abs_len, temp_char);
else
printf("%-*.*s ", abs_len, abs_len, temp_char);
}
/*
* slurm_print_partition_info_msg - output information about all Slurm
* partitions based upon message as loaded using slurm_load_partitions
* IN out - file to write to
* IN part_info_ptr - partitions information message pointer
* IN one_liner - print as a single line if true
*/
void slurm_print_partition_info_msg ( FILE* out,
partition_info_msg_t * part_info_ptr, int one_liner )
{
int i ;
partition_info_t * part_ptr = part_info_ptr->partition_array ;
char time_str[32];
slurm_make_time_str ((time_t *)&part_info_ptr->last_update, time_str,
sizeof(time_str));
fprintf( out, "Partition data as of %s, record count %d\n",
time_str, part_info_ptr->record_count);
for (i = 0; i < part_info_ptr->record_count; i++) {
slurm_print_partition_info ( out, & part_ptr[i], one_liner ) ;
}
}
int _print_timestamp(sinfo_data_t * sinfo_data, int width,
bool right_justify, char *suffix)
{
if (sinfo_data && sinfo_data->reason_time) {
char time_str[32];
slurm_make_time_str(&sinfo_data->reason_time,
time_str, sizeof(time_str));
_print_str(time_str, width, right_justify, true);
} else if (sinfo_data)
_print_str("Unknown", width, right_justify, true);
else
_print_str("TIMESTAMP", width, right_justify, true);
if (suffix)
printf("%s", suffix);
return SLURM_SUCCESS;
}
/*
* slurm_print_reservation_info_msg - output information about all Slurm
* reservations based upon message as loaded using slurm_load_reservation
* IN out - file to write to
* IN resv_info_ptr - reservation information message pointer
* IN one_liner - print as a single line if true
*/
void slurm_print_reservation_info_msg ( FILE* out,
reserve_info_msg_t * resv_info_ptr, int one_liner )
{
int i ;
reserve_info_t * resv_ptr = resv_info_ptr->reservation_array ;
char time_str[32];
slurm_make_time_str( (time_t *)&resv_info_ptr->last_update, time_str,
sizeof(time_str));
fprintf( out, "Reservation data as of %s, record count %d\n",
time_str, resv_info_ptr->record_count);
for (i = 0; i < resv_info_ptr->record_count; i++) {
slurm_print_reservation_info ( out, & resv_ptr[i], one_liner );
}
}
/*
* scontrol_print_block - print the specified block's information
* IN block_name - NULL to print information about all block
*/
extern void
scontrol_print_block (char *block_name)
{
int error_code, i, print_cnt = 0;
block_info_msg_t *block_info_ptr = NULL;
block_info_t *block_ptr = NULL;
error_code = scontrol_load_block(&block_info_ptr);
if (error_code) {
exit_code = 1;
if (quiet_flag != 1)
slurm_perror ("slurm_load_block error");
return;
}
if (quiet_flag == -1) {
char time_str[32];
slurm_make_time_str(
(time_t *)&block_info_ptr->last_update,
time_str, sizeof(time_str));
printf ("last_update_time=%s, records=%d\n",
time_str, block_info_ptr->record_count);
}
block_ptr = block_info_ptr->block_array;
for (i = 0; i < block_info_ptr->record_count; i++) {
if (block_name
&& xstrcmp(block_name, block_ptr[i].bg_block_id))
continue;
print_cnt++;
slurm_print_block_info(
stdout, &block_ptr[i], one_liner);
if (block_name)
break;
}
if (print_cnt == 0) {
if (block_name) {
exit_code = 1;
if (quiet_flag != 1)
printf ("Block %s not found\n",
block_name);
} else if (quiet_flag != 1)
printf ("No blocks in the system\n");
}
}
/*
* scontrol_print_part - print the specified partition's information
* IN partition_name - NULL to print information about all partition
*/
extern void
scontrol_print_part (char *partition_name)
{
int error_code, i, print_cnt = 0;
partition_info_msg_t *part_info_ptr = NULL;
partition_info_t *part_ptr = NULL;
error_code = scontrol_load_partitions(&part_info_ptr);
if (error_code) {
exit_code = 1;
if (quiet_flag != 1)
slurm_perror ("slurm_load_partitions error");
return;
}
if (quiet_flag == -1) {
char time_str[32];
slurm_make_time_str ((time_t *)&part_info_ptr->last_update,
time_str, sizeof(time_str));
printf ("last_update_time=%s, records=%d\n",
time_str, part_info_ptr->record_count);
}
part_ptr = part_info_ptr->partition_array;
for (i = 0; i < part_info_ptr->record_count; i++) {
if (partition_name &&
strcmp (partition_name, part_ptr[i].name) != 0)
continue;
print_cnt++;
slurm_print_partition_info (stdout, & part_ptr[i],
one_liner ) ;
if (partition_name)
break;
}
if (print_cnt == 0) {
if (partition_name) {
exit_code = 1;
if (quiet_flag != 1)
printf ("Partition %s not found\n",
partition_name);
} else if (quiet_flag != 1)
printf ("No partitions in the system\n");
}
}
/*
* slurm_print_node_info_msg - output information about all Slurm nodes
* based upon message as loaded using slurm_load_node
* IN out - file to write to
* IN node_info_msg_ptr - node information message pointer
* IN one_liner - print as a single line if true
*/
void
slurm_print_node_info_msg ( FILE * out, node_info_msg_t * node_info_msg_ptr,
int one_liner )
{
int i;
node_info_t * node_ptr = node_info_msg_ptr -> node_array ;
char time_str[32];
slurm_make_time_str ((time_t *)&node_info_msg_ptr->last_update,
time_str, sizeof(time_str));
fprintf( out, "Node data as of %s, record count %d\n",
time_str, node_info_msg_ptr->record_count);
for (i = 0; i < node_info_msg_ptr-> record_count; i++) {
slurm_print_node_table ( out, & node_ptr[i],
one_liner ) ;
}
}
/*
* slurm_print_job_step_info_msg - output information about all Slurm
* job steps based upon message as loaded using slurm_get_job_steps
* IN out - file to write to
* IN job_step_info_msg_ptr - job step information message pointer
* IN one_liner - print as a single line if true
*/
void
slurm_print_job_step_info_msg ( FILE* out,
job_step_info_response_msg_t * job_step_info_msg_ptr,
int one_liner )
{
int i;
job_step_info_t *job_step_ptr = job_step_info_msg_ptr->job_steps ;
char time_str[32];
slurm_make_time_str ((time_t *)&job_step_info_msg_ptr->last_update,
time_str, sizeof(time_str));
fprintf( out, "Job step data as of %s, record count %d\n",
time_str, job_step_info_msg_ptr->job_step_count);
for (i = 0; i < job_step_info_msg_ptr-> job_step_count; i++)
{
slurm_print_job_step_info ( out, & job_step_ptr[i],
one_liner ) ;
}
}
