extern int slurm_persist_unpack_init_req_msg( persist_init_req_msg_t **msg, Buf buffer) { uint32_t tmp32; persist_init_req_msg_t *msg_ptr = xmalloc(sizeof(persist_init_req_msg_t)); *msg = msg_ptr; safe_unpack16(&msg_ptr->version, buffer); if (msg_ptr->version >= SLURM_17_11_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&msg_ptr->cluster_name, &tmp32, buffer); safe_unpack16(&msg_ptr->persist_type, buffer); safe_unpack16(&msg_ptr->port, buffer); } else if (msg_ptr->version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&msg_ptr->cluster_name, &tmp32, buffer); safe_unpack16(&msg_ptr->port, buffer); } else { error("%s: invalid protocol_version %u", __func__, msg_ptr->version); goto unpack_error; } return SLURM_SUCCESS; unpack_error: slurm_persist_free_init_req_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
static int _unpack_node_state_msg(dbd_node_state_msg_t **msg, uint16_t rpc_version, Buf buffer) { dbd_node_state_msg_t *msg_ptr; uint32_t uint32_tmp; msg_ptr = xmalloc(sizeof(dbd_node_state_msg_t)); *msg = msg_ptr; msg_ptr->reason_uid = NO_VAL; if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&msg_ptr->hostlist, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&msg_ptr->reason, &uint32_tmp, buffer); safe_unpack32(&msg_ptr->reason_uid, buffer); safe_unpack16(&msg_ptr->new_state, buffer); safe_unpack_time(&msg_ptr->event_time, buffer); safe_unpack32(&msg_ptr->state, buffer); safe_unpackstr_xmalloc(&msg_ptr->tres_str, &uint32_tmp, buffer); } return SLURM_SUCCESS; unpack_error: slurmdbd_free_node_state_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
int switch_p_unpack_jobinfo(switch_jobinfo_t *switch_job, Buf buffer, uint16_t protocol_version) { sw_gen_step_info_t *gen_step_info = (sw_gen_step_info_t *) switch_job; sw_gen_node_t *node_ptr; sw_gen_ifa_t *ifa_ptr; uint32_t uint32_tmp; int i, j; if (debug_flags & DEBUG_FLAG_SWITCH) info("switch_p_unpack_jobinfo() starting"); safe_unpack32(&gen_step_info->node_cnt, buffer); gen_step_info->node_array = xmalloc(sizeof(sw_gen_node_t *) * gen_step_info->node_cnt); for (i = 0; i < gen_step_info->node_cnt; i++) { node_ptr = xmalloc(sizeof(sw_gen_node_t)); gen_step_info->node_array[i] = node_ptr; safe_unpackstr_xmalloc(&node_ptr->node_name, &uint32_tmp, buffer); safe_unpack16(&node_ptr->ifa_cnt, buffer); node_ptr->ifa_array = xmalloc(sizeof(sw_gen_ifa_t *) * node_ptr->ifa_cnt); for (j = 0; j < node_ptr->ifa_cnt; j++) { ifa_ptr = xmalloc(sizeof(sw_gen_ifa_t)); node_ptr->ifa_array[j] = ifa_ptr; safe_unpackstr_xmalloc(&ifa_ptr->ifa_addr, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&ifa_ptr->ifa_family, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&ifa_ptr->ifa_name, &uint32_tmp, buffer); if (debug_flags & DEBUG_FLAG_SWITCH) { info("node=%s name=%s family=%s addr=%s", node_ptr->node_name, ifa_ptr->ifa_name, ifa_ptr->ifa_family, ifa_ptr->ifa_addr); } } } return SLURM_SUCCESS; unpack_error: for (i = 0; i < gen_step_info->node_cnt; i++) { node_ptr = gen_step_info->node_array[i]; for (j = 0; j < node_ptr->ifa_cnt; j++) { ifa_ptr = node_ptr->ifa_array[j]; xfree(ifa_ptr->ifa_addr); xfree(ifa_ptr->ifa_family); xfree(ifa_ptr->ifa_name); xfree(ifa_ptr); } xfree(node_ptr->ifa_array); xfree(node_ptr->node_name); xfree(node_ptr); } gen_step_info->node_cnt = 0; xfree(gen_step_info->node_array); return SLURM_ERROR; }
extern int unpack_slurmd_conf_lite_no_alloc(slurmd_conf_t *conf, Buf buffer) { uint32_t uint32_tmp; safe_unpackstr_xmalloc(&conf->hostname, &uint32_tmp, buffer); safe_unpack16(&conf->cpus, buffer); safe_unpack16(&conf->boards, buffer); safe_unpack16(&conf->sockets, buffer); safe_unpack16(&conf->cores, buffer); safe_unpack16(&conf->threads, buffer); safe_unpack32(&conf->real_memory_size, buffer); safe_unpack16(&conf->block_map_size, buffer); safe_unpack16_array(&conf->block_map, &uint32_tmp, buffer); safe_unpack16_array(&conf->block_map_inv, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->spooldir, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_name, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->logfile, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_prolog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_epilog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_freq, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_type, &uint32_tmp, buffer); safe_unpack16(&conf->propagate_prio, buffer); safe_unpack32(&conf->debug_flags, buffer); safe_unpack32(&uint32_tmp, buffer); conf->debug_level = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->daemonize = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->slurm_user_id = (uid_t)uint32_tmp; safe_unpack16(&conf->use_pam, buffer); safe_unpack16(&conf->task_plugin_param, buffer); safe_unpackstr_xmalloc(&conf->node_topo_addr, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_topo_pattern, &uint32_tmp, buffer); safe_unpack32(&uint32_tmp, buffer); safe_unpack16(&conf->log_fmt, buffer); safe_unpack16(&conf->mem_limit_enforce, buffer); conf->port = uint32_tmp; return SLURM_SUCCESS; unpack_error: error("unpack_error in unpack_slurmd_conf_lite_no_alloc: %m"); xfree(conf->job_acct_gather_freq); xfree(conf->job_acct_gather_type); xfree(conf->hostname); xfree(conf->spooldir); xfree(conf->node_name); xfree(conf->logfile); xfree(conf->task_prolog); xfree(conf->task_epilog); xfree(conf->node_topo_addr); xfree(conf->node_topo_pattern); return SLURM_ERROR; }
extern int spawn_resp_unpack(spawn_resp_t **resp_ptr, Buf buf) { spawn_resp_t *resp = NULL; uint32_t temp32; int i; resp = xmalloc(sizeof(spawn_resp_t)); safe_unpack32(&resp->seq, buf); safe_unpack32((uint32_t *)&resp->rc, buf); safe_unpack16((uint16_t *)&resp->pmi_port, buf); safe_unpackstr_xmalloc(&resp->jobid, &temp32, buf); safe_unpack32(&resp->error_cnt, buf); if (resp->error_cnt > 0) { resp->error_codes = xmalloc(resp->error_cnt * sizeof(int)); for (i = 0; i < resp->error_cnt; i ++) { safe_unpack32((uint32_t *)&(resp->error_codes[i]), buf); } } *resp_ptr = resp; return SLURM_SUCCESS; unpack_error: spawn_resp_free(resp); return SLURM_ERROR; }
extern int slurm_ckpt_unpack_job(check_jobinfo_t jobinfo, Buf buffer, uint16_t protocol_version) { uint32_t uint32_tmp; struct check_job_info *check_ptr = (struct check_job_info *)jobinfo; if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { uint16_t id; uint32_t size; safe_unpack16(&id, buffer); safe_unpack32(&size, buffer); if (id != CHECK_POE) { uint32_t x; x = get_buf_offset(buffer); set_buf_offset(buffer, x + size); } else { safe_unpack16(&check_ptr->disabled, buffer); safe_unpack16(&check_ptr->node_cnt, buffer); safe_unpack16(&check_ptr->reply_cnt, buffer); safe_unpack16(&check_ptr->wait_time, buffer); safe_unpack32(&check_ptr->error_code, buffer); safe_unpackstr_xmalloc(&check_ptr->error_msg, &uint32_tmp, buffer); safe_unpack_time(&check_ptr->time_stamp, buffer); } } return SLURM_SUCCESS; unpack_error: xfree(check_ptr->error_msg); return SLURM_ERROR; }
extern int slurm_ckpt_unpack_job(check_jobinfo_t jobinfo, Buf buffer, uint16_t protocol_version) { uint32_t uint32_tmp; struct check_job_info *check_ptr = (struct check_job_info *)jobinfo; if (protocol_version >= SLURM_2_3_PROTOCOL_VERSION) { safe_unpack16(&check_ptr->disabled, buffer); safe_unpack16(&check_ptr->node_cnt, buffer); safe_unpack16(&check_ptr->reply_cnt, buffer); safe_unpack16(&check_ptr->wait_time, buffer); safe_unpack32(&check_ptr->error_code, buffer); safe_unpackstr_xmalloc(&check_ptr->error_msg, &uint32_tmp, buffer); safe_unpack_time(&check_ptr->time_stamp, buffer); } return SLURM_SUCCESS; unpack_error: xfree(check_ptr->error_msg); return SLURM_ERROR; }
extern int slurm_persist_unpack_rc_msg( persist_rc_msg_t **msg, Buf buffer, uint16_t protocol_version) { uint32_t uint32_tmp; persist_rc_msg_t *msg_ptr = xmalloc(sizeof(persist_rc_msg_t)); *msg = msg_ptr; if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&msg_ptr->comment, &uint32_tmp, buffer); safe_unpack16(&msg_ptr->flags, buffer); safe_unpack32(&msg_ptr->rc, buffer); safe_unpack16(&msg_ptr->ret_info, buffer); } else { error("%s: invalid protocol_version %u", __func__, protocol_version); goto unpack_error; } return SLURM_SUCCESS; unpack_error: slurm_persist_free_rc_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
static int _unpack_acct_coord_msg(dbd_acct_coord_msg_t **msg, uint16_t rpc_version, Buf buffer) { uint32_t uint32_tmp; int i; char *acct = NULL; uint32_t count = 0; dbd_acct_coord_msg_t *msg_ptr = xmalloc(sizeof(dbd_acct_coord_msg_t)); *msg = msg_ptr; safe_unpack32(&count, buffer); if (count) { msg_ptr->acct_list = list_create(slurm_destroy_char); for(i=0; i<count; i++) { safe_unpackstr_xmalloc(&acct, &uint32_tmp, buffer); list_append(msg_ptr->acct_list, acct); } } if (slurmdb_unpack_user_cond((void *)&msg_ptr->cond, rpc_version, buffer) == SLURM_ERROR) goto unpack_error; return SLURM_SUCCESS; unpack_error: slurmdbd_free_acct_coord_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
/* * Unpack options from buffer "buf" into options container opts. */ int job_options_unpack (job_options_t opts, Buf buf) { uint32_t count; uint32_t len; char * tag = NULL; int i; safe_unpackstr_xmalloc (&tag, &len, buf); if (xstrncmp (tag, JOB_OPTIONS_PACK_TAG, len) != 0) { xfree(tag); return (-1); } xfree(tag); safe_unpack32 (&count, buf); for (i = 0; i < count; i++) { struct job_option_info *ji; if ((ji = job_option_info_unpack (buf)) == NULL) return (SLURM_ERROR); list_append (opts->options, ji); } return (0); unpack_error: xfree(tag); return SLURM_ERROR; }
extern int select_nodeinfo_unpack(select_nodeinfo_t **nodeinfo, Buf buffer, uint16_t protocol_version) { uint16_t size = 0; select_nodeinfo_t *nodeinfo_ptr = NULL; uint32_t j = 0; uint32_t uint32_tmp; if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpack16(&size, buffer); nodeinfo_ptr = select_nodeinfo_alloc((uint32_t)size); *nodeinfo = nodeinfo_ptr; safe_unpackstr_xmalloc(&nodeinfo_ptr->extra_info, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&nodeinfo_ptr->failed_cnodes, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&nodeinfo_ptr->rack_mp, &uint32_tmp, buffer); safe_unpack16(&size, buffer); nodeinfo_ptr->subgrp_list = list_create(_free_node_subgrp); for (j=0; j<size; j++) { node_subgrp_t *subgrp = NULL; if (_unpack_node_subgrp(&subgrp, buffer, nodeinfo_ptr->bitmap_size, protocol_version) != SLURM_SUCCESS) goto unpack_error; list_append(nodeinfo_ptr->subgrp_list, subgrp); } } else { error("select_nodeinfo_unpack: protocol_version " "%hu not supported", protocol_version); } return SLURM_SUCCESS; unpack_error: error("select_nodeinfo_unpack: error unpacking here"); select_nodeinfo_free(nodeinfo_ptr); *nodeinfo = NULL; return SLURM_ERROR; }
extern int unpack_slurm_step_layout(slurm_step_layout_t **layout, Buf buffer, uint16_t protocol_version) { uint16_t uint16_tmp; uint32_t num_tids, uint32_tmp; slurm_step_layout_t *step_layout = NULL; int i; if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpack16(&uint16_tmp, buffer); if (!uint16_tmp) return SLURM_SUCCESS; step_layout = xmalloc(sizeof(slurm_step_layout_t)); *layout = step_layout; safe_unpackstr_xmalloc(&step_layout->front_end, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&step_layout->node_list, &uint32_tmp, buffer); safe_unpack32(&step_layout->node_cnt, buffer); safe_unpack16(&step_layout->start_protocol_ver, buffer); safe_unpack32(&step_layout->task_cnt, buffer); safe_unpack32(&step_layout->task_dist, buffer); step_layout->tasks = xmalloc(sizeof(uint32_t) * step_layout->node_cnt); step_layout->tids = xmalloc(sizeof(uint32_t *) * step_layout->node_cnt); for (i = 0; i < step_layout->node_cnt; i++) { safe_unpack32_array(&(step_layout->tids[i]), &num_tids, buffer); step_layout->tasks[i] = num_tids; } } else { error("unpack_slurm_step_layout: protocol_version " "%hu not supported", protocol_version); goto unpack_error; } return SLURM_SUCCESS; unpack_error: slurm_step_layout_destroy(step_layout); *layout = NULL; return SLURM_ERROR; }
static int _slurmdbd_unpackstr(void **str, uint16_t rpc_version, Buf buffer) { uint32_t uint32_tmp; safe_unpackstr_xmalloc((char **)str, &uint32_tmp, buffer); return SLURM_SUCCESS; unpack_error: return SLURM_ERROR; }
extern int switch_p_unpack_node_info(switch_node_info_t *switch_node, Buf buffer, uint16_t protocol_version) { sw_gen_node_info_t *gen_node_info = (sw_gen_node_info_t *) switch_node; sw_gen_ifa_t *ifa_ptr; uint32_t uint32_tmp; int i; if (debug_flags & DEBUG_FLAG_SWITCH) info("switch_p_unpack_node_info() starting"); safe_unpack16(&gen_node_info->ifa_cnt, buffer); gen_node_info->ifa_array = xmalloc(sizeof(sw_gen_ifa_t *) * gen_node_info->ifa_cnt); safe_unpackstr_xmalloc(&gen_node_info->node_name, &uint32_tmp, buffer); for (i = 0; i < gen_node_info->ifa_cnt; i++) { ifa_ptr = xmalloc(sizeof(sw_gen_ifa_t)); gen_node_info->ifa_array[i] = ifa_ptr; safe_unpackstr_xmalloc(&ifa_ptr->ifa_addr, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&ifa_ptr->ifa_family, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&ifa_ptr->ifa_name, &uint32_tmp, buffer); if (debug_flags & DEBUG_FLAG_SWITCH) { info("%s: node=%s name=%s ip_family=%s address=%s", plugin_type, gen_node_info->node_name, ifa_ptr->ifa_name, ifa_ptr->ifa_family, ifa_ptr->ifa_addr); } } _cache_node_info(gen_node_info); return SLURM_SUCCESS; unpack_error: for (i = 0; i < gen_node_info->ifa_cnt; i++) { xfree(gen_node_info->ifa_array[i]->ifa_addr); xfree(gen_node_info->ifa_array[i]->ifa_family); xfree(gen_node_info->ifa_array[i]->ifa_name); xfree(gen_node_info->ifa_array[i]); } xfree(gen_node_info->ifa_array); xfree(gen_node_info->node_name); gen_node_info->ifa_cnt = 0; return SLURM_ERROR; }
static struct job_option_info * job_option_info_unpack (Buf buf) { struct job_option_info *ji = xmalloc (sizeof (*ji)); uint32_t type; uint32_t len; safe_unpack32 (&type, buf); safe_unpackstr_xmalloc (&ji->option, &len, buf); safe_unpackstr_xmalloc (&ji->optarg, &len, buf); ji->type = (int) type; return (ji); unpack_error: job_option_info_destroy (ji); return (NULL); }
static int _handle_kvs_fence(int fd, Buf buf) { uint32_t from_nodeid, num_children, temp32, seq; char *from_node = NULL; int rc = SLURM_SUCCESS; safe_unpack32(&from_nodeid, buf); safe_unpackstr_xmalloc(&from_node, &temp32, buf); safe_unpack32(&num_children, buf); safe_unpack32(&seq, buf); debug3("mpi/pmi2: in _handle_kvs_fence, from node %u(%s) representing" " %u offspring, seq=%u", from_nodeid, from_node, num_children, seq); if (seq != kvs_seq) { error("mpi/pmi2: invalid kvs seq from node %u(%s) ignored, " "expect %u got %u", from_nodeid, from_node, kvs_seq, seq); goto out; } if (seq == tree_info.children_kvs_seq[from_nodeid]) { info("mpi/pmi2: duplicate KVS_FENCE request from node %u(%s) " "ignored, seq=%u", from_nodeid, from_node, seq); goto out; } tree_info.children_kvs_seq[from_nodeid] = seq; if (tasks_to_wait == 0 && children_to_wait == 0) { tasks_to_wait = job_info.ltasks; children_to_wait = tree_info.num_children; } children_to_wait -= num_children; temp_kvs_merge(buf); if (children_to_wait == 0 && tasks_to_wait == 0) { rc = temp_kvs_send(); if (rc != SLURM_SUCCESS) { if (in_stepd()) { error("mpi/pmi2: failed to send temp kvs" " to %s", tree_info.parent_node ?: "srun"); send_kvs_fence_resp_to_clients( rc, "mpi/pmi2: failed to send temp kvs"); } else { error("mpi/pmi2: failed to send temp kvs" " to compute nodes"); } /* cancel the step to avoid tasks hang */ slurm_kill_job_step(job_info.jobid, job_info.stepid, SIGKILL); } else {
/* Load jobcomp data from save state file */ static int _load_pending_jobs(void) { int i, rc = SLURM_SUCCESS; char *saved_data = NULL, *state_file = NULL, *job_data = NULL; uint32_t data_size, job_cnt = 0, tmp32 = 0; Buf buffer; struct job_node *jnode; state_file = slurm_get_state_save_location(); if (state_file == NULL) { error("%s: Could not retrieve StateSaveLocation from conf", plugin_type); return SLURM_ERROR; } if (state_file[strlen(state_file) - 1] != '/') xstrcat(state_file, "/"); xstrcat(state_file, save_state_file); slurm_mutex_lock(&save_lock); data_size = _read_file(state_file, &saved_data); if ((data_size <= 0) || (saved_data == NULL)) { slurm_mutex_unlock(&save_lock); xfree(saved_data); xfree(state_file); return rc; } slurm_mutex_unlock(&save_lock); buffer = create_buf(saved_data, data_size); safe_unpack32(&job_cnt, buffer); for (i = 0; i < job_cnt; i++) { safe_unpackstr_xmalloc(&job_data, &tmp32, buffer); jnode = xmalloc(sizeof(struct job_node)); jnode->serialized_job = job_data; list_enqueue(jobslist, jnode); } if (job_cnt > 0) { if (slurm_get_debug_flags() & DEBUG_FLAG_ESEARCH) info("%s: Loaded %u jobs from state file", plugin_type, job_cnt); } free_buf(buffer); xfree(state_file); return rc; unpack_error: error("%s: Error unpacking file %s", plugin_type, state_file); free_buf(buffer); xfree(state_file); return SLURM_ERROR; }
static int _unpack_config_name(char **object, uint16_t rpc_version, Buf buffer) { char *config_name; uint32_t uint32_tmp; safe_unpackstr_xmalloc(&config_name, &uint32_tmp, buffer); *object = config_name; return SLURM_SUCCESS; unpack_error: *object = NULL; return SLURM_ERROR; }
static int _unpack_step_start_msg(dbd_step_start_msg_t **msg, uint16_t rpc_version, Buf buffer) { uint32_t uint32_tmp = 0; dbd_step_start_msg_t *msg_ptr = xmalloc(sizeof(dbd_step_start_msg_t)); *msg = msg_ptr; if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpack32(&msg_ptr->assoc_id, buffer); safe_unpack64(&msg_ptr->db_index, buffer); safe_unpack32(&msg_ptr->job_id, buffer); safe_unpackstr_xmalloc(&msg_ptr->name, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&msg_ptr->node_inx, &uint32_tmp, buffer); safe_unpack32(&msg_ptr->node_cnt, buffer); safe_unpack_time(&msg_ptr->start_time, buffer); safe_unpack_time(&msg_ptr->job_submit_time, buffer); safe_unpack32(&msg_ptr->req_cpufreq_min, buffer); safe_unpack32(&msg_ptr->req_cpufreq_max, buffer); safe_unpack32(&msg_ptr->req_cpufreq_gov, buffer); safe_unpack32(&msg_ptr->step_id, buffer); safe_unpack32(&msg_ptr->task_dist, buffer); safe_unpack32(&msg_ptr->total_tasks, buffer); safe_unpackstr_xmalloc(&msg_ptr->tres_alloc_str, &uint32_tmp, buffer); } else goto unpack_error; return SLURM_SUCCESS; unpack_error: debug2("slurmdbd_unpack_step_start_msg:" "unpack_error: size_buf(buffer) %u", size_buf(buffer)); slurmdbd_free_step_start_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
static int _unpack_cluster_tres_msg(dbd_cluster_tres_msg_t **msg, uint16_t rpc_version, Buf buffer) { dbd_cluster_tres_msg_t *msg_ptr; uint32_t uint32_tmp; msg_ptr = xmalloc(sizeof(dbd_cluster_tres_msg_t)); *msg = msg_ptr; if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&msg_ptr->cluster_nodes, &uint32_tmp, buffer); safe_unpack_time(&msg_ptr->event_time, buffer); safe_unpackstr_xmalloc(&msg_ptr->tres_str, &uint32_tmp, buffer); } return SLURM_SUCCESS; unpack_error: slurmdbd_free_cluster_tres_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
static int _unpack_job_complete_msg(dbd_job_comp_msg_t **msg, uint16_t rpc_version, Buf buffer) { uint32_t uint32_tmp; dbd_job_comp_msg_t *msg_ptr = xmalloc(sizeof(dbd_job_comp_msg_t)); *msg = msg_ptr; if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&msg_ptr->admin_comment, &uint32_tmp, buffer); safe_unpack32(&msg_ptr->assoc_id, buffer); safe_unpackstr_xmalloc(&msg_ptr->comment, &uint32_tmp, buffer); safe_unpack64(&msg_ptr->db_index, buffer); safe_unpack32(&msg_ptr->derived_ec, buffer); safe_unpack_time(&msg_ptr->end_time, buffer); safe_unpack32(&msg_ptr->exit_code, buffer); safe_unpack32(&msg_ptr->job_id, buffer); safe_unpack32(&msg_ptr->job_state, buffer); safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer); safe_unpack32(&msg_ptr->req_uid, buffer); safe_unpack_time(&msg_ptr->start_time, buffer); safe_unpack_time(&msg_ptr->submit_time, buffer); safe_unpackstr_xmalloc(&msg_ptr->system_comment, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&msg_ptr->tres_alloc_str, &uint32_tmp, buffer); } else goto unpack_error; return SLURM_SUCCESS; unpack_error: slurmdbd_free_job_complete_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
extern int slurm_persist_unpack_rc_msg( persist_rc_msg_t **msg, Buf buffer, uint16_t protocol_version) { uint32_t uint32_tmp; persist_rc_msg_t *msg_ptr = xmalloc(sizeof(persist_rc_msg_t)); *msg = msg_ptr; safe_unpackstr_xmalloc(&msg_ptr->comment, &uint32_tmp, buffer); safe_unpack32(&msg_ptr->rc, buffer); safe_unpack16(&msg_ptr->ret_info, buffer); return SLURM_SUCCESS; unpack_error: slurm_persist_free_rc_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
static int _unpack_node_subgrp(node_subgrp_t **subgrp_pptr, Buf buffer, uint16_t bitmap_size, uint16_t protocol_version) { node_subgrp_t *subgrp = xmalloc(sizeof(node_subgrp_t)); int j; uint32_t uint32_tmp; uint16_t uint16_tmp; *subgrp_pptr = subgrp; if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&subgrp->str, &uint32_tmp, buffer); if (!subgrp->str) subgrp->inx = bitfmt2int(""); else subgrp->inx = bitfmt2int(subgrp->str); subgrp->bitmap = bit_alloc(bitmap_size); j = 0; while (subgrp->inx[j] >= 0) { bit_nset(subgrp->bitmap, subgrp->inx[j], subgrp->inx[j+1]); j+=2; } safe_unpack16(&subgrp->cnode_cnt, buffer); safe_unpack16(&uint16_tmp, buffer); subgrp->state = uint16_tmp; } return SLURM_SUCCESS; unpack_error: _free_node_subgrp(subgrp); *subgrp_pptr = NULL; return SLURM_ERROR; }
static int _unpack_step_complete_msg(dbd_step_comp_msg_t **msg, uint16_t rpc_version, Buf buffer) { uint32_t uint32_tmp; dbd_step_comp_msg_t *msg_ptr = xmalloc(sizeof(dbd_step_comp_msg_t)); *msg = msg_ptr; if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpack32(&msg_ptr->assoc_id, buffer); safe_unpack64(&msg_ptr->db_index, buffer); safe_unpack_time(&msg_ptr->end_time, buffer); safe_unpack32(&msg_ptr->exit_code, buffer); jobacctinfo_unpack((struct jobacctinfo **)&msg_ptr->jobacct, rpc_version, PROTOCOL_TYPE_DBD, buffer, 1); safe_unpack32(&msg_ptr->job_id, buffer); safe_unpack_time(&msg_ptr->job_submit_time, buffer); safe_unpackstr_xmalloc(&msg_ptr->job_tres_alloc_str, &uint32_tmp, buffer); safe_unpack32(&msg_ptr->req_uid, buffer); safe_unpack_time(&msg_ptr->start_time, buffer); safe_unpack16(&msg_ptr->state, buffer); safe_unpack32(&msg_ptr->step_id, buffer); safe_unpack32(&msg_ptr->total_tasks, buffer); } else goto unpack_error; return SLURM_SUCCESS; unpack_error: debug2("slurmdbd_unpack_step_complete_msg:" "unpack_error: size_buf(buffer) %u", size_buf(buffer)); slurmdbd_free_step_complete_msg(msg_ptr); *msg = NULL; return SLURM_ERROR; }
extern char * name_lookup_up(char *name) { Buf buf = NULL, resp_buf = NULL; uint32_t size; char * port = NULL; int rc; buf = init_buf(1024); pack16((uint16_t)TREE_CMD_NAME_LOOKUP, buf); packstr(name, buf); size = get_buf_offset(buf); rc = tree_msg_to_srun_with_resp(size, get_buf_data(buf), &resp_buf); free_buf(buf); if (rc == SLURM_SUCCESS) safe_unpackstr_xmalloc(&port, (uint32_t *)&size, resp_buf); unpack_error: if (resp_buf) free_buf(resp_buf); return port; }
extern int unpack_slurmd_conf_lite_no_alloc(slurmd_conf_t *conf, Buf buffer) { uint32_t uint32_tmp; uint16_t protocol_version; char *ver_str = NULL; safe_unpackstr_xmalloc(&ver_str, &uint32_tmp, buffer); if (ver_str && !xstrcmp(ver_str, PROTOCOL_VERSION)) { safe_unpack16(&protocol_version, buffer); xfree(ver_str); } else { /* Kludge to add protocol version in existing data structure: * use "hostname" as a version marker. Eliminate this in * the future. */ conf->hostname = ver_str; protocol_version = SLURM_16_05_PROTOCOL_VERSION; } if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&conf->hostname, &uint32_tmp, buffer); safe_unpack16(&conf->cpus, buffer); safe_unpack16(&conf->boards, buffer); safe_unpack16(&conf->sockets, buffer); safe_unpack16(&conf->cores, buffer); safe_unpack16(&conf->threads, buffer); safe_unpack64(&conf->real_memory_size, buffer); safe_unpack16(&conf->block_map_size, buffer); safe_unpack16_array(&conf->block_map, &uint32_tmp, buffer); safe_unpack16_array(&conf->block_map_inv, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->spooldir, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_name, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->logfile, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_prolog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_epilog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_freq, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_type, &uint32_tmp, buffer); safe_unpack16(&conf->propagate_prio, buffer); safe_unpack64(&conf->debug_flags, buffer); safe_unpack32(&uint32_tmp, buffer); conf->debug_level = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->daemonize = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->slurm_user_id = (uid_t)uint32_tmp; safe_unpack16(&conf->use_pam, buffer); safe_unpack32(&conf->task_plugin_param, buffer); safe_unpackstr_xmalloc(&conf->node_topo_addr, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_topo_pattern, &uint32_tmp, buffer); safe_unpack32(&uint32_tmp, buffer); conf->port = uint32_tmp; safe_unpack16(&conf->log_fmt, buffer); safe_unpack16(&conf->mem_limit_enforce, buffer); safe_unpack64(&conf->msg_aggr_window_msgs, buffer); } else { uint32_t real_memory_size = 0; // safe_unpackstr_xmalloc(&conf->hostname, &uint32_tmp, buffer); safe_unpack16(&conf->cpus, buffer); safe_unpack16(&conf->boards, buffer); safe_unpack16(&conf->sockets, buffer); safe_unpack16(&conf->cores, buffer); safe_unpack16(&conf->threads, buffer); safe_unpack32(&real_memory_size, buffer); conf->real_memory_size = real_memory_size; safe_unpack16(&conf->block_map_size, buffer); safe_unpack16_array(&conf->block_map, &uint32_tmp, buffer); safe_unpack16_array(&conf->block_map_inv, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->spooldir, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_name, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->logfile, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_prolog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_epilog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_freq, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_type, &uint32_tmp, buffer); safe_unpack16(&conf->propagate_prio, buffer); safe_unpack64(&conf->debug_flags, buffer); safe_unpack32(&uint32_tmp, buffer); conf->debug_level = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->daemonize = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->slurm_user_id = (uid_t)uint32_tmp; safe_unpack16(&conf->use_pam, buffer); safe_unpack32(&conf->task_plugin_param, buffer); safe_unpackstr_xmalloc(&conf->node_topo_addr, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_topo_pattern, &uint32_tmp, buffer); safe_unpack32(&uint32_tmp, buffer); conf->port = uint32_tmp; safe_unpack16(&conf->log_fmt, buffer); safe_unpack16(&conf->mem_limit_enforce, buffer); safe_unpack64(&conf->msg_aggr_window_msgs, buffer); } return SLURM_SUCCESS; unpack_error: error("unpack_error in unpack_slurmd_conf_lite_no_alloc: %m"); xfree(conf->job_acct_gather_freq); xfree(conf->job_acct_gather_type); xfree(conf->hostname); xfree(conf->spooldir); xfree(conf->node_name); xfree(conf->logfile); xfree(conf->task_prolog); xfree(conf->task_epilog); xfree(conf->node_topo_addr); xfree(conf->node_topo_pattern); return SLURM_ERROR; }
extern int unpack_job_resources(job_resources_t **job_resrcs_pptr, Buf buffer, uint16_t protocol_version) { char *bit_fmt = NULL; uint32_t empty, tmp32; job_resources_t *job_resrcs; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); xassert(job_resrcs_pptr); if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) { safe_unpack32(&empty, buffer); if (empty == NO_VAL) { *job_resrcs_pptr = NULL; return SLURM_SUCCESS; } job_resrcs = xmalloc(sizeof(struct job_resources)); job_resrcs->nhosts = empty; safe_unpack32(&job_resrcs->ncpus, buffer); safe_unpack32(&job_resrcs->node_req, buffer); safe_unpackstr_xmalloc(&job_resrcs->nodes, &tmp32, buffer); safe_unpack32_array(&job_resrcs->cpu_array_reps, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpu_array_reps); job_resrcs->cpu_array_cnt = tmp32; safe_unpack16_array(&job_resrcs->cpu_array_value, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpu_array_value); if (tmp32 != job_resrcs->cpu_array_cnt) goto unpack_error; safe_unpack16_array(&job_resrcs->cpus, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpus); if (tmp32 != job_resrcs->nhosts) goto unpack_error; safe_unpack16_array(&job_resrcs->cpus_used, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpus_used); safe_unpack32_array(&job_resrcs->memory_allocated, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->memory_allocated); safe_unpack32_array(&job_resrcs->memory_used, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->memory_used); if (!(cluster_flags & CLUSTER_FLAG_BG)) { safe_unpack16_array(&job_resrcs->sockets_per_node, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->sockets_per_node); safe_unpack16_array(&job_resrcs->cores_per_socket, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cores_per_socket); safe_unpack32_array(&job_resrcs->sock_core_rep_count, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->sock_core_rep_count); unpack_bit_str(&job_resrcs->core_bitmap, buffer); unpack_bit_str(&job_resrcs->core_bitmap_used, buffer); } } else if (protocol_version >= SLURM_2_3_PROTOCOL_VERSION) { uint8_t tmp_8; safe_unpack32(&empty, buffer); if (empty == NO_VAL) { *job_resrcs_pptr = NULL; return SLURM_SUCCESS; } job_resrcs = xmalloc(sizeof(struct job_resources)); job_resrcs->nhosts = empty; safe_unpack32(&job_resrcs->ncpus, buffer); safe_unpack8(&tmp_8, buffer); if (tmp_8 < 100) /* Not NODE_CR_RESERVED */ job_resrcs->node_req = tmp_8; /* 32-bit in v2.5 */ else job_resrcs->node_req = NODE_CR_RESERVED; safe_unpackstr_xmalloc(&job_resrcs->nodes, &tmp32, buffer); safe_unpack32_array(&job_resrcs->cpu_array_reps, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpu_array_reps); job_resrcs->cpu_array_cnt = tmp32; safe_unpack16_array(&job_resrcs->cpu_array_value, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpu_array_value); if (tmp32 != job_resrcs->cpu_array_cnt) goto unpack_error; safe_unpack16_array(&job_resrcs->cpus, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpus); if (tmp32 != job_resrcs->nhosts) goto unpack_error; safe_unpack16_array(&job_resrcs->cpus_used, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cpus_used); safe_unpack32_array(&job_resrcs->memory_allocated, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->memory_allocated); safe_unpack32_array(&job_resrcs->memory_used, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->memory_used); if (!(cluster_flags & CLUSTER_FLAG_BG)) { safe_unpack16_array(&job_resrcs->sockets_per_node, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->sockets_per_node); safe_unpack16_array(&job_resrcs->cores_per_socket, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->cores_per_socket); safe_unpack32_array(&job_resrcs->sock_core_rep_count, &tmp32, buffer); if (tmp32 == 0) xfree(job_resrcs->sock_core_rep_count); unpack_bit_str(&job_resrcs->core_bitmap, buffer); unpack_bit_str(&job_resrcs->core_bitmap_used, buffer); } } else { error("unpack_job_resources: protocol_version %hu not " "supported", protocol_version); goto unpack_error; } *job_resrcs_pptr = job_resrcs; return SLURM_SUCCESS; unpack_error: error("unpack_job_resources: unpack error"); free_job_resources(&job_resrcs); xfree(bit_fmt); *job_resrcs_pptr = NULL; return SLURM_ERROR; }
/* * load_all_part_state - load the partition state from file, recover on * slurmctld restart. execute this after loading the configuration * file data. * NOTE: READ lock_slurmctld config before entry */ int load_all_part_state(void) { char *part_name = NULL, *allow_groups = NULL, *nodes = NULL; char *state_file, *data = NULL; uint32_t max_time, default_time, max_nodes, min_nodes; uint32_t max_cpus_per_node = INFINITE, grace_time = 0; time_t time; uint16_t flags; uint16_t max_share, preempt_mode, priority, state_up, cr_type; struct part_record *part_ptr; uint32_t data_size = 0, name_len; int data_allocated, data_read = 0, error_code = 0, part_cnt = 0; int state_fd; Buf buffer; char *ver_str = NULL; char* allow_alloc_nodes = NULL; uint16_t protocol_version = (uint16_t)NO_VAL; char* alternate = NULL; /* read the file */ lock_state_files(); state_fd = _open_part_state_file(&state_file); if (state_fd < 0) { info("No partition state file (%s) to recover", state_file); error_code = ENOENT; } else { data_allocated = BUF_SIZE; data = xmalloc(data_allocated); while (1) { data_read = read(state_fd, &data[data_size], BUF_SIZE); if (data_read < 0) { if (errno == EINTR) continue; else { error("Read error on %s: %m", state_file); break; } } else if (data_read == 0) /* eof */ break; data_size += data_read; data_allocated += data_read; xrealloc(data, data_allocated); } close(state_fd); } xfree(state_file); unlock_state_files(); buffer = create_buf(data, data_size); safe_unpackstr_xmalloc( &ver_str, &name_len, buffer); debug3("Version string in part_state header is %s", ver_str); if (ver_str) { if (!strcmp(ver_str, PART_STATE_VERSION)) { protocol_version = SLURM_PROTOCOL_VERSION; } else if (!strcmp(ver_str, PART_2_5_STATE_VERSION)) { protocol_version = SLURM_2_5_PROTOCOL_VERSION; } } if (protocol_version == (uint16_t)NO_VAL) { error("**********************************************************"); error("Can not recover partition state, data version incompatible"); error("**********************************************************"); xfree(ver_str); free_buf(buffer); return EFAULT; } xfree(ver_str); safe_unpack_time(&time, buffer); while (remaining_buf(buffer) > 0) { if (protocol_version >= SLURM_2_6_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&part_name, &name_len, buffer); safe_unpack32(&grace_time, buffer); safe_unpack32(&max_time, buffer); safe_unpack32(&default_time, buffer); safe_unpack32(&max_cpus_per_node, buffer); safe_unpack32(&max_nodes, buffer); safe_unpack32(&min_nodes, buffer); safe_unpack16(&flags, buffer); safe_unpack16(&max_share, buffer); safe_unpack16(&preempt_mode, buffer); safe_unpack16(&priority, buffer); if (priority > part_max_priority) part_max_priority = priority; safe_unpack16(&state_up, buffer); safe_unpack16(&cr_type, buffer); safe_unpackstr_xmalloc(&allow_groups, &name_len, buffer); safe_unpackstr_xmalloc(&allow_alloc_nodes, &name_len, buffer); safe_unpackstr_xmalloc(&alternate, &name_len, buffer); safe_unpackstr_xmalloc(&nodes, &name_len, buffer); if ((flags & PART_FLAG_DEFAULT_CLR) || (flags & PART_FLAG_HIDDEN_CLR) || (flags & PART_FLAG_NO_ROOT_CLR) || (flags & PART_FLAG_ROOT_ONLY_CLR) || (flags & PART_FLAG_REQ_RESV_CLR)) { error("Invalid data for partition %s: flags=%u", part_name, flags); error_code = EINVAL; } } else if (protocol_version >= SLURM_2_4_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&part_name, &name_len, buffer); safe_unpack32(&grace_time, buffer); safe_unpack32(&max_time, buffer); safe_unpack32(&default_time, buffer); safe_unpack32(&max_nodes, buffer); safe_unpack32(&min_nodes, buffer); safe_unpack16(&flags, buffer); safe_unpack16(&max_share, buffer); safe_unpack16(&preempt_mode, buffer); safe_unpack16(&priority, buffer); if (priority > part_max_priority) part_max_priority = priority; cr_type = 0; /* Default value */ safe_unpack16(&state_up, buffer); safe_unpackstr_xmalloc(&allow_groups, &name_len, buffer); safe_unpackstr_xmalloc(&allow_alloc_nodes, &name_len, buffer); safe_unpackstr_xmalloc(&alternate, &name_len, buffer); safe_unpackstr_xmalloc(&nodes, &name_len, buffer); if ((flags & PART_FLAG_DEFAULT_CLR) || (flags & PART_FLAG_HIDDEN_CLR) || (flags & PART_FLAG_NO_ROOT_CLR) || (flags & PART_FLAG_ROOT_ONLY_CLR) || (flags & PART_FLAG_REQ_RESV_CLR)) { error("Invalid data for partition %s: flags=%u", part_name, flags); error_code = EINVAL; } } else { error("load_all_part_state: protocol_version " "%hu not supported", protocol_version); goto unpack_error; } /* validity test as possible */ if (state_up > PARTITION_UP) { error("Invalid data for partition %s: state_up=%u", part_name, state_up); error_code = EINVAL; } if (error_code) { error("No more partition data will be processed from " "the checkpoint file"); xfree(allow_groups); xfree(allow_alloc_nodes); xfree(alternate); xfree(part_name); xfree(nodes); error_code = EINVAL; break; } /* find record and perform update */ part_ptr = list_find_first(part_list, &list_find_part, part_name); part_cnt++; if (part_ptr == NULL) { info("load_all_part_state: partition %s missing from " "configuration file", part_name); part_ptr = create_part_record(); xfree(part_ptr->name); part_ptr->name = xstrdup(part_name); } part_ptr->flags = flags; if (part_ptr->flags & PART_FLAG_DEFAULT) { xfree(default_part_name); default_part_name = xstrdup(part_name); default_part_loc = part_ptr; } part_ptr->max_time = max_time; part_ptr->default_time = default_time; part_ptr->max_cpus_per_node = max_cpus_per_node; part_ptr->max_nodes = max_nodes; part_ptr->max_nodes_orig = max_nodes; part_ptr->min_nodes = min_nodes; part_ptr->min_nodes_orig = min_nodes; part_ptr->max_share = max_share; part_ptr->grace_time = grace_time; if (preempt_mode != (uint16_t) NO_VAL) part_ptr->preempt_mode = preempt_mode; part_ptr->priority = priority; part_ptr->state_up = state_up; part_ptr->cr_type = cr_type; xfree(part_ptr->allow_groups); part_ptr->allow_groups = allow_groups; xfree(part_ptr->allow_alloc_nodes); part_ptr->allow_alloc_nodes = allow_alloc_nodes; xfree(part_ptr->alternate); part_ptr->alternate = alternate; xfree(part_ptr->nodes); part_ptr->nodes = nodes; xfree(part_name); } info("Recovered state of %d partitions", part_cnt); free_buf(buffer); return error_code; unpack_error: error("Incomplete partition data checkpoint file"); info("Recovered state of %d partitions", part_cnt); free_buf(buffer); return EFAULT; }
extern int unpack_slurmd_conf_lite_no_alloc(slurmd_conf_t *conf, Buf buffer) { uint32_t uint32_tmp; uint16_t protocol_version; char *ver_str = NULL; safe_unpackstr_xmalloc(&ver_str, &uint32_tmp, buffer); safe_unpack16(&protocol_version, buffer); xfree(ver_str); if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_unpackstr_xmalloc(&conf->hostname, &uint32_tmp, buffer); safe_unpack16(&conf->cpus, buffer); safe_unpack16(&conf->boards, buffer); safe_unpack16(&conf->sockets, buffer); safe_unpack16(&conf->cores, buffer); safe_unpack16(&conf->threads, buffer); safe_unpack64(&conf->real_memory_size, buffer); safe_unpack16(&conf->block_map_size, buffer); safe_unpack16_array(&conf->block_map, &uint32_tmp, buffer); safe_unpack16_array(&conf->block_map_inv, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->spooldir, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_name, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->logfile, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_prolog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->task_epilog, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_freq, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->job_acct_gather_type, &uint32_tmp, buffer); safe_unpack16(&conf->propagate_prio, buffer); safe_unpack64(&conf->debug_flags, buffer); safe_unpack32(&uint32_tmp, buffer); conf->debug_level = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->daemonize = uint32_tmp; safe_unpack32(&uint32_tmp, buffer); conf->slurm_user_id = (uid_t)uint32_tmp; safe_unpack16(&conf->use_pam, buffer); safe_unpack32(&conf->task_plugin_param, buffer); safe_unpackstr_xmalloc(&conf->node_topo_addr, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->node_topo_pattern, &uint32_tmp, buffer); safe_unpack32(&uint32_tmp, buffer); conf->port = uint32_tmp; safe_unpack16(&conf->log_fmt, buffer); safe_unpack16(&conf->mem_limit_enforce, buffer); safe_unpack64(&conf->msg_aggr_window_msgs, buffer); safe_unpackstr_xmalloc(&conf->tmpfs, &uint32_tmp, buffer); safe_unpackstr_xmalloc(&conf->x11_params, &uint32_tmp, buffer); } return SLURM_SUCCESS; unpack_error: error("unpack_error in unpack_slurmd_conf_lite_no_alloc: %m"); xfree(conf->job_acct_gather_freq); xfree(conf->job_acct_gather_type); xfree(conf->hostname); xfree(conf->spooldir); xfree(conf->node_name); xfree(conf->logfile); xfree(conf->task_prolog); xfree(conf->task_epilog); xfree(conf->node_topo_addr); xfree(conf->node_topo_pattern); xfree(conf->tmpfs); xfree(conf->x11_params); return SLURM_ERROR; }
/* unpack a select job credential from a buffer * OUT jobinfo - the select job credential read * IN buffer - buffer with select credential read from current pointer loc * IN protocol_version - slurm protocol version of client * RET - slurm error code * NOTE: returned value must be freed using free_jobinfo */ extern int unpack_select_jobinfo(select_jobinfo_t **jobinfo_pptr, Buf buffer, uint16_t protocol_version) { int i; uint32_t uint32_tmp; uint16_t mp_cnode_cnt; int dims = slurmdb_setup_cluster_dims(); select_jobinfo_t *jobinfo = xmalloc(sizeof(struct select_jobinfo)); char *bit_char = NULL; *jobinfo_pptr = jobinfo; jobinfo->magic = JOBINFO_MAGIC; if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) { safe_unpack16(&jobinfo->dim_cnt, buffer); xassert(jobinfo->dim_cnt); dims = jobinfo->dim_cnt; for (i=0; i<dims; i++) { safe_unpack16(&(jobinfo->geometry[i]), buffer); safe_unpack16(&(jobinfo->conn_type[i]), buffer); safe_unpack16(&(jobinfo->start_loc[i]), buffer); } safe_unpack16(&(jobinfo->reboot), buffer); safe_unpack16(&(jobinfo->rotate), buffer); safe_unpack32(&(jobinfo->block_cnode_cnt), buffer); safe_unpack32(&(jobinfo->cnode_cnt), buffer); safe_unpackstr_xmalloc(&(jobinfo->bg_block_id), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->mp_str), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->ionode_str), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->blrtsimage), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->linuximage), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->mloaderimage), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->ramdiskimage), &uint32_tmp, buffer); safe_unpack16(&mp_cnode_cnt, buffer); safe_unpackstr_xmalloc(&bit_char, &uint32_tmp, buffer); if (bit_char) { jobinfo->units_avail = bit_alloc(mp_cnode_cnt); bit_unfmt(jobinfo->units_avail, bit_char); xfree(bit_char); } safe_unpackstr_xmalloc(&bit_char, &uint32_tmp, buffer); if (bit_char) { jobinfo->units_used = bit_alloc(mp_cnode_cnt); bit_unfmt(jobinfo->units_used, bit_char); xfree(bit_char); } } else { error("unpack_select_jobinfo: protocol_version " "%hu not supported", protocol_version); } return SLURM_SUCCESS; unpack_error: free_select_jobinfo(jobinfo); *jobinfo_pptr = NULL; return SLURM_ERROR; }