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 (strncmp (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 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
name_unpublish_up(char *name)
{
Buf buf = NULL, resp_buf = NULL;
uint32_t size, tmp_32;
int rc;
buf = init_buf(1024);
pack16((uint16_t)TREE_CMD_NAME_UNPUBLISH, 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_unpack32(&tmp_32, resp_buf);
rc = (int) tmp_32;
}
unpack_error:
if (resp_buf)
free_buf(resp_buf);
return rc;
}
extern int select_p_select_jobinfo_unpack(select_jobinfo_t **jobinfo_pptr,
Buf buffer, uint16_t protocol_version)
{
int rc = SLURM_ERROR;
select_jobinfo_t *jobinfo = xmalloc(sizeof(struct select_jobinfo));
*jobinfo_pptr = jobinfo;
jobinfo->magic = JOBINFO_MAGIC;
if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
safe_unpack8(&jobinfo->confirmed, buffer);
safe_unpack32(&jobinfo->reservation_id, buffer);
safe_unpack64(&jobinfo->confirm_cookie, buffer);
rc = other_select_jobinfo_unpack(&jobinfo->other_jobinfo,
buffer, protocol_version);
} else {
error("select_p_select_jobinfo_unpack: protocol_version "
"%hu not supported", protocol_version);
}
if (rc != SLURM_SUCCESS)
goto unpack_error;
return SLURM_SUCCESS;
unpack_error:
select_p_select_jobinfo_free(jobinfo);
*jobinfo_pptr = 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;
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;
}
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;
}
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;
}
static int
io_init_msg_unpack(struct slurm_io_init_msg *hdr, Buf buffer)
{
uint32_t val;
safe_unpack16(&hdr->version, buffer);
safe_unpack32(&hdr->nodeid, buffer);
safe_unpack32(&hdr->stdout_objs, buffer);
safe_unpack32(&hdr->stderr_objs, buffer);
safe_unpackmem((char *) hdr->cred_signature, &val, buffer);
if (val != SLURM_IO_KEY_SIZE)
goto unpack_error;
return SLURM_SUCCESS;
unpack_error:
error("unpack error in io_init_msg_unpack");
return SLURM_ERROR;
}
static int _unpack_jobacct_id(jobacct_id_t *jobacct_id,
uint16_t rpc_version, Buf buffer)
{
safe_unpack32(&jobacct_id->nodeid, buffer);
safe_unpack16(&jobacct_id->taskid, buffer);
return SLURM_SUCCESS;
unpack_error:
return SLURM_ERROR;
}
static int _unpack_register_ctld_msg(dbd_register_ctld_msg_t **msg,
uint16_t rpc_version, Buf buffer)
{
dbd_register_ctld_msg_t *msg_ptr = xmalloc(
sizeof(dbd_register_ctld_msg_t));
*msg = msg_ptr;
if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) {
safe_unpack16(&msg_ptr->dimensions, buffer);
safe_unpack32(&msg_ptr->flags, buffer);
safe_unpack32(&msg_ptr->plugin_id_select, buffer);
safe_unpack16(&msg_ptr->port, buffer);
}
return SLURM_SUCCESS;
unpack_error:
slurmdbd_free_register_ctld_msg(msg_ptr);
*msg = NULL;
return SLURM_ERROR;
}
extern int slurmdbd_unpack_id_rc_msg(void **msg,
uint16_t rpc_version, Buf buffer)
{
dbd_id_rc_msg_t *msg_ptr = xmalloc(sizeof(dbd_id_rc_msg_t));
*msg = msg_ptr;
if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) {
safe_unpack32(&msg_ptr->job_id, buffer);
safe_unpack64(&msg_ptr->db_index, buffer);
safe_unpack32(&msg_ptr->return_code, buffer);
}
return SLURM_SUCCESS;
unpack_error:
slurmdbd_free_id_rc_msg(msg_ptr);
*msg = NULL;
return SLURM_ERROR;
}
extern int ext_sensors_data_unpack(ext_sensors_data_t **ext_sensors, Buf buffer,
uint16_t protocol_version)
{
ext_sensors_data_t *ext_sensors_ptr = ext_sensors_alloc();
*ext_sensors = ext_sensors_ptr;
if (ext_sensors_ptr == NULL)
return SLURM_ERROR;
safe_unpack32(&ext_sensors_ptr->consumed_energy, buffer);
safe_unpack32(&ext_sensors_ptr->temperature, buffer);
safe_unpack_time(&ext_sensors_ptr->energy_update_time, buffer);
safe_unpack32(&ext_sensors_ptr->current_watts, buffer);
return SLURM_SUCCESS;
unpack_error:
ext_sensors_destroy(ext_sensors_ptr);
*ext_sensors = NULL;
return SLURM_ERROR;
}
/* 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;
}
int
io_hdr_unpack(io_hdr_t *hdr, Buf buffer)
{
safe_unpack16(&hdr->type, buffer);
safe_unpack16(&hdr->gtaskid, buffer);
safe_unpack16(&hdr->ltaskid, buffer);
safe_unpack32(&hdr->length, buffer);
return SLURM_SUCCESS;
unpack_error:
error("io_hdr_unpack error: %m");
return SLURM_ERROR;
}
extern int acct_gather_energy_unpack(acct_gather_energy_t **energy, Buf buffer,
uint16_t protocol_version)
{
acct_gather_energy_t *energy_ptr = acct_gather_energy_alloc();
*energy = energy_ptr;
if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
safe_unpack32(&energy_ptr->base_consumed_energy, buffer);
safe_unpack32(&energy_ptr->base_watts, buffer);
safe_unpack32(&energy_ptr->consumed_energy, buffer);
safe_unpack32(&energy_ptr->current_watts, buffer);
safe_unpack32(&energy_ptr->previous_consumed_energy, buffer);
safe_unpack_time(&energy_ptr->poll_time, buffer);
}
return SLURM_SUCCESS;
unpack_error:
acct_gather_energy_destroy(energy_ptr);
*energy = NULL;
return SLURM_ERROR;
}
static int _unpack_job_suspend_msg(dbd_job_suspend_msg_t **msg,
uint16_t rpc_version, Buf buffer)
{
dbd_job_suspend_msg_t *msg_ptr = xmalloc(sizeof(dbd_job_suspend_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_unpack32(&msg_ptr->job_state, buffer);
safe_unpack_time(&msg_ptr->submit_time, buffer);
safe_unpack_time(&msg_ptr->suspend_time, buffer);
}
return SLURM_SUCCESS;
unpack_error:
slurmdbd_free_job_suspend_msg(msg_ptr);
*msg = NULL;
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_14_03_PROTOCOL_VERSION) {
uint16_t id;
uint32_t size;
safe_unpack16(&id, buffer);
safe_unpack32(&size, buffer);
if (id != CHECK_BLCR) {
uint32_t x;
x = get_buf_offset(buffer);
set_buf_offset(buffer, x + size);
} else {
safe_unpack16(&check_ptr->disabled, buffer);
safe_unpack_time(&check_ptr->time_stamp, buffer);
safe_unpack32(&check_ptr->error_code, buffer);
safe_unpackstr_xmalloc(&check_ptr->error_msg,
&uint32_tmp, buffer);
}
} else if (protocol_version >= SLURM_2_6_PROTOCOL_VERSION) {
safe_unpack16(&check_ptr->disabled, buffer);
safe_unpack_time(&check_ptr->time_stamp, buffer);
safe_unpack32(&check_ptr->error_code, buffer);
safe_unpackstr_xmalloc(&check_ptr->error_msg,
&uint32_tmp, buffer);
}
return SLURM_SUCCESS;
unpack_error:
xfree(check_ptr->error_msg);
return SLURM_ERROR;
}
/* Unpack a power management data structure
* Use power_mgmt_data_free() to free the returned structure */
extern int power_mgmt_data_unpack(power_mgmt_data_t **power, Buf buffer,
uint16_t protocol_version)
{
power_mgmt_data_t *power_ptr = xmalloc(sizeof(power_mgmt_data_t));
safe_unpack32(&power_ptr->cap_watts, buffer);
*power = power_ptr;
return SLURM_SUCCESS;
unpack_error:
xfree(power_ptr);
*power = NULL;
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;
}
/*
* Unmarshall a credential after transmission over the network according
* to SLURM's marshalling protocol.
*/
slurm_auth_credential_t *
slurm_auth_unpack( Buf buf )
{
slurm_auth_credential_t *cred = NULL;
char *type;
uint32_t size;
uint32_t version;
if ( buf == NULL ) {
plugin_errno = SLURM_AUTH_BADARG;
return NULL;
}
/*
* Get the authentication type.
*/
safe_unpackmem_ptr( &type, &size, buf );
if (( type == NULL ) ||
( strcmp( type, plugin_type ) != 0 )) {
plugin_errno = SLURM_AUTH_MISMATCH;
return NULL;
}
safe_unpack32( &version, buf );
if ( version < min_plug_version ) {
plugin_errno = SLURM_AUTH_VERSION;
return NULL;
}
/* Allocate and initialize credential. */
cred = xmalloc(sizeof(*cred));
cred->verified = false;
cred->m_str = NULL;
cred->buf = NULL;
cred->len = 0;
cred->cr_errno = SLURM_SUCCESS;
xassert(cred->magic = MUNGE_MAGIC);
safe_unpackstr_malloc(&cred->m_str, &size, buf);
return cred;
unpack_error:
plugin_errno = SLURM_AUTH_UNPACK;
xfree( cred );
return NULL;
}
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 _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;
}
extern int select_g_select_nodeinfo_unpack(dynamic_plugin_data_t **nodeinfo,
Buf buffer,
uint16_t protocol_version)
{
dynamic_plugin_data_t *nodeinfo_ptr = NULL;
if (slurm_select_init(0) < 0)
return SLURM_ERROR;
nodeinfo_ptr = xmalloc(sizeof(dynamic_plugin_data_t));
*nodeinfo = nodeinfo_ptr;
if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
int i;
uint32_t plugin_id;
safe_unpack32(&plugin_id, buffer);
for (i=0; i<select_context_cnt; i++)
if (*(ops[i].plugin_id) == plugin_id) {
nodeinfo_ptr->plugin_id = i;
break;
}
if (i >= select_context_cnt) {
error("we don't have select plugin type %u",plugin_id);
goto unpack_error;
}
} else {
nodeinfo_ptr->plugin_id = select_context_default;
error("select_g_select_nodeinfo_unpack: protocol_version"
" %hu not supported", protocol_version);
goto unpack_error;
}
if ((*(ops[nodeinfo_ptr->plugin_id].nodeinfo_unpack))
((select_nodeinfo_t **)&nodeinfo_ptr->data, buffer,
protocol_version) != SLURM_SUCCESS)
goto unpack_error;
return SLURM_SUCCESS;
unpack_error:
select_g_select_nodeinfo_free(nodeinfo_ptr);
*nodeinfo = NULL;
error("select_g_select_nodeinfo_unpack: unpack error");
return SLURM_ERROR;
}
extern int switch_g_unpack_jobinfo(dynamic_plugin_data_t **jobinfo, Buf buffer,
uint16_t protocol_version)
{
dynamic_plugin_data_t *jobinfo_ptr = NULL;
if ( switch_init(0) < 0 )
return SLURM_ERROR;
jobinfo_ptr = xmalloc(sizeof(dynamic_plugin_data_t));
*jobinfo = jobinfo_ptr;
if (protocol_version >= SLURM_17_11_PROTOCOL_VERSION) {
int i;
uint32_t plugin_id;
safe_unpack32(&plugin_id, buffer);
for (i = 0; i < switch_context_cnt; i++) {
if (*(ops[i].plugin_id) == plugin_id) {
jobinfo_ptr->plugin_id = i;
break;
}
}
if (i >= switch_context_cnt) {
error("we don't have switch plugin type %u", plugin_id);
goto unpack_error;
}
} else {
jobinfo_ptr->plugin_id = switch_context_default;
}
if ((*(ops[jobinfo_ptr->plugin_id].unpack_jobinfo))
((switch_jobinfo_t **)&jobinfo_ptr->data, buffer,
protocol_version))
goto unpack_error;
return SLURM_SUCCESS;
unpack_error:
switch_g_free_jobinfo(jobinfo_ptr);
*jobinfo = NULL;
error("%s: unpack error", __func__);
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;
}
extern int slurm_ckpt_unpack_job(check_jobinfo_t jobinfo, Buf buffer,
uint16_t protocol_version)
{
uint16_t id;
uint32_t x;
uint32_t size;
if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
safe_unpack16(&id, buffer);
safe_unpack32(&size, buffer);
if (id != CHECK_NONE) {
x = get_buf_offset(buffer);
set_buf_offset(buffer, x + size);
}
}
return SLURM_SUCCESS;
unpack_error:
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
* RET - slurm error code
* NOTE: returned value must be freed using select_g_free_jobinfo
*/
extern int select_g_select_jobinfo_unpack(dynamic_plugin_data_t **jobinfo,
Buf buffer,
uint16_t protocol_version)
{
dynamic_plugin_data_t *jobinfo_ptr = NULL;
if (slurm_select_init(0) < 0)
return SLURM_ERROR;
jobinfo_ptr = xmalloc(sizeof(dynamic_plugin_data_t));
*jobinfo = jobinfo_ptr;
if(protocol_version >= SLURM_2_2_PROTOCOL_VERSION) {
int i;
uint32_t plugin_id;
safe_unpack32(&plugin_id, buffer);
for (i=0; i<select_context_cnt; i++)
if(*(select_context[i].ops.plugin_id) == plugin_id) {
jobinfo_ptr->plugin_id = i;
break;
}
if (i >= select_context_cnt) {
error("we don't have this plugin type %u", plugin_id);
goto unpack_error;
}
} else
jobinfo_ptr->plugin_id = select_context_default;
if ((*(select_context[jobinfo_ptr->plugin_id].ops.jobinfo_unpack))
((select_jobinfo_t **)&jobinfo_ptr->data, buffer,
protocol_version) != SLURM_SUCCESS)
goto unpack_error;
return SLURM_SUCCESS;
unpack_error:
select_g_select_jobinfo_free(jobinfo_ptr);
*jobinfo = NULL;
error("select_g_select_jobinfo_unpack: unpack error");
return SLURM_ERROR;
}
extern int acct_gather_energy_unpack(acct_gather_energy_t **energy, Buf buffer,
uint16_t protocol_version, bool need_alloc)
{
uint32_t uint32_tmp;
acct_gather_energy_t *energy_ptr;
if (need_alloc) {
energy_ptr = acct_gather_energy_alloc(1);
*energy = energy_ptr;
} else {
energy_ptr = *energy;
}
if (protocol_version >= SLURM_15_08_PROTOCOL_VERSION) {
safe_unpack64(&energy_ptr->base_consumed_energy, buffer);
safe_unpack32(&energy_ptr->base_watts, buffer);
safe_unpack64(&energy_ptr->consumed_energy, buffer);
safe_unpack32(&energy_ptr->current_watts, buffer);
safe_unpack64(&energy_ptr->previous_consumed_energy, buffer);
safe_unpack_time(&energy_ptr->poll_time, buffer);
} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
safe_unpack32(&uint32_tmp, buffer);
energy_ptr->base_consumed_energy = (uint64_t) uint32_tmp;
safe_unpack32(&energy_ptr->base_watts, buffer);
safe_unpack32(&uint32_tmp, buffer);
energy_ptr->consumed_energy = (uint64_t) uint32_tmp;
safe_unpack32(&energy_ptr->current_watts, buffer);
safe_unpack32(&uint32_tmp, buffer);
energy_ptr->previous_consumed_energy = (uint64_t) uint32_tmp;
safe_unpack_time(&energy_ptr->poll_time, buffer);
}
return SLURM_SUCCESS;
unpack_error:
if (need_alloc) {
acct_gather_energy_destroy(energy_ptr);
*energy = NULL;
} else
memset(energy_ptr, 0, sizeof(acct_gather_energy_t));
return SLURM_ERROR;
}
static void _state_read_buf(Buf buffer)
{
uint16_t protocol_version = (uint16_t) NO_VAL;
uint32_t min_port, max_port;
int i;
/* Validate state version */
safe_unpack16(&protocol_version, buffer);
debug3("Version in switch_cray header is %u", protocol_version);
if (protocol_version < SLURM_MIN_PROTOCOL_VERSION) {
error("******************************************************");
error("Can't recover switch/cray state, incompatible version");
error("******************************************************");
return;
}
if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
safe_unpack32(&min_port, buffer);
safe_unpack32(&max_port, buffer);
safe_unpack32(&last_alloc_port, buffer);
unpack_bit_str(&port_resv, buffer);
} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
uint8_t port_set = 0;
safe_unpack32(&min_port, buffer);
safe_unpack32(&max_port, buffer);
safe_unpack32(&last_alloc_port, buffer);
port_resv = bit_alloc(PORT_CNT);
for (i = 0; i < PORT_CNT; i++) {
safe_unpack8(&port_set, buffer);
if (port_set)
bit_set(port_resv, i);
}
}
if ((min_port != MIN_PORT) || (max_port != MAX_PORT)) {
error("******************************************************");
error("Can not recover switch/cray state");
error("Changed MIN_PORT (%u != %u) and/or MAX_PORT (%u != %u)",
min_port, MIN_PORT, max_port, MAX_PORT);
error("******************************************************");
return;
}
return;
unpack_error:
CRAY_ERR("unpack error");
return;
}
