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