int switch_p_pack_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;
int i, j;
if (debug_flags & DEBUG_FLAG_SWITCH)
info("switch_p_pack_jobinfo() starting");
xassert(gen_step_info);
xassert(gen_step_info->magic == SW_GEN_STEP_INFO_MAGIC);
pack32(gen_step_info->node_cnt, buffer);
for (i = 0; i < gen_step_info->node_cnt; i++) {
node_ptr = gen_step_info->node_array[i];
packstr(node_ptr->node_name, buffer);
pack16(node_ptr->ifa_cnt, buffer);
for (j = 0; j < node_ptr->ifa_cnt; j++) {
ifa_ptr = node_ptr->ifa_array[j];
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);
}
packstr(ifa_ptr->ifa_addr, buffer);
packstr(ifa_ptr->ifa_family, buffer);
packstr(ifa_ptr->ifa_name, buffer);
}
}
return SLURM_SUCCESS;
}
static void job_option_info_pack (struct job_option_info *ji, Buf buf)
{
pack32 (ji->type, buf);
packstr (ji->option, buf);
packstr (ji->optarg, buf); /* packstr() handles NULL optarg */
return;
}
int switch_p_pack_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;
int i, j;
if (debug_flags & DEBUG_FLAG_SWITCH)
info("switch_p_pack_jobinfo() starting");
xassert(gen_step_info);
xassert(gen_step_info->magic == SW_GEN_STEP_INFO_MAGIC);
if (!libstate) {
/* The function is being called from srun or slurmd.
* There is no more need for moving this data. */
pack32((uint32_t) 0, buffer);
return SLURM_SUCCESS;
}
pack32(gen_step_info->node_cnt, buffer);
for (i = 0; i < gen_step_info->node_cnt; i++) {
node_ptr = gen_step_info->node_array[i];
packstr(node_ptr->node_name, buffer);
pack16(node_ptr->ifa_cnt, buffer);
for (j = 0; j < node_ptr->ifa_cnt; j++) {
ifa_ptr = node_ptr->ifa_array[j];
packstr(ifa_ptr->ifa_addr, buffer);
packstr(ifa_ptr->ifa_family, buffer);
packstr(ifa_ptr->ifa_name, buffer);
}
}
return SLURM_SUCCESS;
}
/*
* Marshall a credential for transmission over the network, according to
* SLURM's marshalling protocol.
*/
int
slurm_auth_pack( slurm_auth_credential_t *cred, Buf buf )
{
if (cred == NULL) {
plugin_errno = SLURM_AUTH_BADARG;
return SLURM_ERROR;
}
if (buf == NULL) {
cred->cr_errno = SLURM_AUTH_BADARG;
return SLURM_ERROR;
}
xassert(cred->magic == MUNGE_MAGIC);
/*
* Prefix the credential with a description of the credential
* type so that it can be sanity-checked at the receiving end.
*/
packstr( (char *) plugin_type, buf );
pack32( plugin_version, buf );
/*
* Pack the data.
*/
packstr(cred->m_str, buf);
return SLURM_SUCCESS;
}
extern int
name_publish_up(char *name, char *port)
{
Buf buf = NULL, resp_buf = NULL;
uint32_t size, tmp_32;
int rc;
buf = init_buf(1024);
pack16((uint16_t)TREE_CMD_NAME_PUBLISH, buf);
packstr(name, buf);
packstr(port, 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 void pack_slurm_step_layout(slurm_step_layout_t *step_layout,
Buf buffer, uint16_t protocol_version)
{
uint32_t i = 0;
if (protocol_version >= SLURM_2_3_PROTOCOL_VERSION) {
if (step_layout)
i=1;
pack16(i, buffer);
if (!i)
return;
packstr(step_layout->front_end, buffer);
packstr(step_layout->node_list, buffer);
pack32(step_layout->node_cnt, buffer);
pack32(step_layout->task_cnt, buffer);
pack16(step_layout->task_dist, buffer);
for (i=0; i<step_layout->node_cnt; i++) {
pack32_array(step_layout->tids[i],
step_layout->tasks[i],
buffer);
}
} else {
error("pack_slurm_step_layout: protocol_version "
"%hu not supported", protocol_version);
}
}
/*
* _dump_part_state - dump the state of a specific partition to a buffer
* IN part_ptr - pointer to partition for which information
* is requested
* IN/OUT buffer - location to store data, pointers automatically advanced
*/
static void _dump_part_state(struct part_record *part_ptr, Buf buffer)
{
xassert(part_ptr);
if (default_part_loc == part_ptr)
part_ptr->flags |= PART_FLAG_DEFAULT;
else
part_ptr->flags &= (~PART_FLAG_DEFAULT);
packstr(part_ptr->name, buffer);
pack32(part_ptr->grace_time, buffer);
pack32(part_ptr->max_time, buffer);
pack32(part_ptr->default_time, buffer);
pack32(part_ptr->max_cpus_per_node, buffer);
pack32(part_ptr->max_nodes_orig, buffer);
pack32(part_ptr->min_nodes_orig, buffer);
pack16(part_ptr->flags, buffer);
pack16(part_ptr->max_share, buffer);
pack16(part_ptr->preempt_mode, buffer);
pack16(part_ptr->priority, buffer);
pack16(part_ptr->state_up, buffer);
pack16(part_ptr->cr_type, buffer);
packstr(part_ptr->allow_groups, buffer);
packstr(part_ptr->allow_alloc_nodes, buffer);
packstr(part_ptr->alternate, buffer);
packstr(part_ptr->nodes, buffer);
}
/* Assume that the slurmd and slurmstepd are the same version level when slurmd
* starts slurmstepd, so we do not need to support different protocol versions
* for the different message formats. */
extern void pack_slurmd_conf_lite(slurmd_conf_t *conf, Buf buffer)
{
xassert(conf != NULL);
packstr(conf->hostname, buffer);
pack16(conf->cpus, buffer);
pack16(conf->boards, buffer);
pack16(conf->sockets, buffer);
pack16(conf->cores, buffer);
pack16(conf->threads, buffer);
pack32(conf->real_memory_size, buffer);
pack16(conf->block_map_size, buffer);
pack16_array(conf->block_map, conf->block_map_size, buffer);
pack16_array(conf->block_map_inv, conf->block_map_size, buffer);
packstr(conf->spooldir, buffer);
packstr(conf->node_name, buffer);
packstr(conf->logfile, buffer);
packstr(conf->task_prolog, buffer);
packstr(conf->task_epilog, buffer);
packstr(conf->job_acct_gather_freq, buffer);
packstr(conf->job_acct_gather_type, buffer);
pack16(conf->propagate_prio, buffer);
pack32(conf->debug_flags, buffer);
pack32(conf->debug_level, buffer);
pack32(conf->daemonize, buffer);
pack32((uint32_t)conf->slurm_user_id, buffer);
pack16(conf->use_pam, buffer);
pack16(conf->task_plugin_param, buffer);
packstr(conf->node_topo_addr, buffer);
packstr(conf->node_topo_pattern, buffer);
pack32((uint32_t)conf->port, buffer);
pack16(conf->log_fmt, buffer);
pack16(conf->mem_limit_enforce, buffer);
}
static void _pack_cluster_tres_msg(dbd_cluster_tres_msg_t *msg,
uint16_t rpc_version, Buf buffer)
{
if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) {
packstr(msg->cluster_nodes, buffer);
pack_time(msg->event_time, buffer);
packstr(msg->tres_str, buffer);
}
}
/*
* _dump_front_end_state - dump state of a specific front_end node to a buffer
* IN front_end_ptr - pointer to node for which information is requested
* IN/OUT buffer - location to store data, pointers automatically advanced
*/
static void _dump_front_end_state(front_end_record_t *front_end_ptr,
Buf buffer)
{
packstr (front_end_ptr->name, buffer);
pack16 (front_end_ptr->node_state, buffer);
packstr (front_end_ptr->reason, buffer);
pack_time(front_end_ptr->reason_time, buffer);
pack32 (front_end_ptr->reason_uid, buffer);
}
static void _pack_alloc(struct bb_alloc *bb_alloc, Buf buffer,
uint16_t protocol_version)
{
if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
packstr(bb_alloc->account, buffer);
pack32(bb_alloc->array_job_id, buffer);
pack32(bb_alloc->array_task_id, buffer);
pack_time(bb_alloc->create_time, buffer);
pack32(bb_alloc->job_id, buffer);
packstr(bb_alloc->name, buffer);
packstr(bb_alloc->partition, buffer);
packstr(bb_alloc->pool, buffer);
packstr(bb_alloc->qos, buffer);
pack64(bb_alloc->size, buffer);
pack16(bb_alloc->state, buffer);
pack32(bb_alloc->user_id, buffer);
} else {
packstr(bb_alloc->account, buffer);
pack32(bb_alloc->array_job_id, buffer);
pack32(bb_alloc->array_task_id, buffer);
pack_time(bb_alloc->create_time, buffer);
pack32((uint32_t)0, buffer);
pack32(bb_alloc->job_id, buffer);
packstr(bb_alloc->name, buffer);
packstr(bb_alloc->partition, buffer);
packstr(bb_alloc->qos, buffer);
pack64(bb_alloc->size, buffer);
pack16(bb_alloc->state, buffer);
pack32(bb_alloc->user_id, buffer);
}
}
static void _pack_node_state_msg(dbd_node_state_msg_t *msg,
uint16_t rpc_version, Buf buffer)
{
if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) {
packstr(msg->hostlist, buffer);
packstr(msg->reason, buffer);
pack32(msg->reason_uid, buffer);
pack16(msg->new_state, buffer);
pack_time(msg->event_time, buffer);
pack32(msg->state, buffer);
packstr(msg->tres_str, buffer);
}
}
/*
* _pack_front_end - dump all configuration information about a specific
* front_end node in machine independent form (for network transmission)
* IN dump_front_end_ptr - pointer to front_end node for which information is
* requested
* IN/OUT buffer - buffer where data is placed, pointers automatically updated
* IN protocol_version - slurm protocol version of client
* NOTE: if you make any changes here be sure to make the corresponding
* changes to load_front_end_config in api/node_info.c
*/
static void _pack_front_end(struct front_end_record *dump_front_end_ptr,
Buf buffer, uint16_t protocol_version)
{
if (protocol_version >= SLURM_2_6_PROTOCOL_VERSION) {
packstr(dump_front_end_ptr->allow_groups, buffer);
packstr(dump_front_end_ptr->allow_users, buffer);
pack_time(dump_front_end_ptr->boot_time, buffer);
packstr(dump_front_end_ptr->deny_groups, buffer);
packstr(dump_front_end_ptr->deny_users, buffer);
packstr(dump_front_end_ptr->name, buffer);
pack16(dump_front_end_ptr->node_state, buffer);
packstr(dump_front_end_ptr->reason, buffer);
pack_time(dump_front_end_ptr->reason_time, buffer);
pack32(dump_front_end_ptr->reason_uid, buffer);
pack_time(dump_front_end_ptr->slurmd_start_time, buffer);
} else if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
pack_time(dump_front_end_ptr->boot_time, buffer);
packstr(dump_front_end_ptr->name, buffer);
pack16(dump_front_end_ptr->node_state, buffer);
packstr(dump_front_end_ptr->reason, buffer);
pack_time(dump_front_end_ptr->reason_time, buffer);
pack32(dump_front_end_ptr->reason_uid, buffer);
pack_time(dump_front_end_ptr->slurmd_start_time, buffer);
} else {
error("_pack_front_end: Unsupported slurm version %u",
protocol_version);
}
}
static void _save_dbd_state(void)
{
char *dbd_fname;
Buf buffer;
int fd, rc, wrote = 0;
uint16_t msg_type;
uint32_t offset;
dbd_fname = slurm_get_state_save_location();
xstrcat(dbd_fname, "/dbd.messages");
(void) unlink(dbd_fname); /* clear save state */
fd = open(dbd_fname, O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (fd < 0) {
error("slurmdbd: Creating state save file %s", dbd_fname);
} else if (agent_list && list_count(agent_list)) {
char curr_ver_str[10];
snprintf(curr_ver_str, sizeof(curr_ver_str),
"VER%d", SLURM_PROTOCOL_VERSION);
buffer = init_buf(strlen(curr_ver_str));
packstr(curr_ver_str, buffer);
rc = _save_dbd_rec(fd, buffer);
free_buf(buffer);
if (rc != SLURM_SUCCESS)
goto end_it;
while ((buffer = list_dequeue(agent_list))) {
/*
* We do not want to store registration messages. If an
* admin puts in an incorrect cluster name we can get a
* deadlock unless they add the bogus cluster name to
* the accounting system.
*/
offset = get_buf_offset(buffer);
if (offset < 2) {
free_buf(buffer);
continue;
}
set_buf_offset(buffer, 0);
(void) unpack16(&msg_type, buffer); /* checked by offset */
set_buf_offset(buffer, offset);
if (msg_type == DBD_REGISTER_CTLD) {
free_buf(buffer);
continue;
}
rc = _save_dbd_rec(fd, buffer);
free_buf(buffer);
if (rc != SLURM_SUCCESS)
break;
wrote++;
}
}
end_it:
if (fd >= 0) {
verbose("slurmdbd: saved %d pending RPCs", wrote);
(void) close(fd);
}
xfree(dbd_fname);
}
extern void slurm_persist_pack_rc_msg(
persist_rc_msg_t *msg, Buf buffer, uint16_t protocol_version)
{
packstr(msg->comment, buffer);
pack32(msg->rc, buffer);
pack16(msg->ret_info, buffer);
}
/*
* Pack all accumulated options into Buffer "buf"
*/
int job_options_pack (job_options_t opts, Buf buf)
{
uint32_t count = 0;
ListIterator i;
struct job_option_info *opt;
packstr (JOB_OPTIONS_PACK_TAG, buf);
if (opts == NULL) {
pack32 (0, buf);
return (0);
}
xassert (opts->magic == JOB_OPTIONS_MAGIC);
xassert (opts->options != NULL);
xassert (opts->iterator != NULL);
count = list_count (opts->options);
pack32 (count, buf);
i = list_iterator_create (opts->options);
while ((opt = list_next (i)))
job_option_info_pack (opt, buf);
list_iterator_destroy (i);
return (count);
}
extern int slurm_ckpt_pack_job(check_jobinfo_t jobinfo, Buf buffer,
uint16_t protocol_version)
{
struct check_job_info *check_ptr =
(struct check_job_info *)jobinfo;
if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
uint32_t x;
uint32_t y;
uint32_t z;
uint32_t size;
size = 0;
pack16(CHECK_POE, buffer);
x = get_buf_offset(buffer);
pack32(size, buffer);
y = get_buf_offset(buffer);
pack16(check_ptr->disabled, buffer);
pack16(check_ptr->node_cnt, buffer);
pack16(check_ptr->reply_cnt, buffer);
pack16(check_ptr->wait_time, buffer);
pack32(check_ptr->error_code, buffer);
packstr(check_ptr->error_msg, buffer);
pack_time(check_ptr->time_stamp, buffer);
z = get_buf_offset(buffer);
set_buf_offset(buffer, x);
pack32(z - y, buffer);
set_buf_offset(buffer, z);
}
return SLURM_SUCCESS;
}
/*
* long double has no standard format, so pass the data as a string
*/
void packlongdouble(long double val, Buf buffer)
{
char val_str[256];
snprintf(val_str, sizeof(val_str), "%Lf", val);
packstr(val_str, buffer);
}
/*
* Pack current burst buffer state information for network transmission to
* user (e.g. "scontrol show burst")
*
* Returns a SLURM errno.
*/
extern int bb_p_state_pack(uid_t uid, Buf buffer, uint16_t protocol_version)
{
uint32_t rec_count = 0;
int eof, offset;
pthread_mutex_lock(&bb_state.bb_mutex);
packstr(bb_state.name, buffer);
offset = get_buf_offset(buffer);
pack32(rec_count, buffer);
bb_pack_state(&bb_state, buffer, protocol_version);
if (bb_state.bb_config.private_data == 0)
uid = 0; /* User can see all data */
rec_count = bb_pack_bufs(uid, bb_state.bb_hash,buffer,protocol_version);
if (rec_count != 0) {
eof = get_buf_offset(buffer);
set_buf_offset(buffer, offset);
pack32(rec_count, buffer);
set_buf_offset(buffer, eof);
}
if (bb_state.bb_config.debug_flag) {
debug("%s: %s: record_count:%u",
plugin_type, __func__, rec_count);
}
pthread_mutex_unlock(&bb_state.bb_mutex);
return SLURM_SUCCESS;
}
/*
* Pack current burst buffer state information for network transmission to
* user (e.g. "scontrol show burst")
*
* Returns a SLURM errno.
*/
extern int bb_p_state_pack(Buf buffer, uint16_t protocol_version)
{
struct bb_alloc *bb_next;
uint32_t rec_count = 0;
int i, eof, offset;
pthread_mutex_lock(&bb_mutex);
if (debug_flag)
info("%s: %s", __func__, plugin_type);
packstr((char *)plugin_type, buffer); /* Remove "const" qualifier */
offset = get_buf_offset(buffer);
pack32(rec_count, buffer);
packstr(allow_users_str, buffer);
packstr(deny_users_str, buffer);
packstr(get_sys_state, buffer);
packstr(start_stage_in, buffer);
packstr(start_stage_out, buffer);
packstr(stop_stage_in, buffer);
packstr(stop_stage_out, buffer);
pack32(job_size_limit, buffer);
pack32(prio_boost, buffer);
pack32(total_space, buffer);
pack32(user_size_limit, buffer);
if (bb_hash) {
for (i = 0; i < BB_HASH_SIZE; i++) {
bb_next = bb_hash[i];
while (bb_next) {
pack32(bb_next->array_job_id, buffer);
pack32(bb_next->array_task_id, buffer);
pack32(bb_next->job_id, buffer);
packstr(bb_next->name, buffer);
pack32(bb_next->size, buffer);
pack16(bb_next->state, buffer);
pack32(bb_next->user_id, buffer);
rec_count++;
bb_next = bb_next->next;
}
}
if (rec_count != 0) {
eof = get_buf_offset(buffer);
set_buf_offset(buffer, offset);
pack32(rec_count, buffer);
set_buf_offset(buffer, eof);
}
}
info("%s: record_count:%u", __func__, rec_count);
pthread_mutex_unlock(&bb_mutex);
return SLURM_SUCCESS;
}
extern void slurm_persist_pack_init_req_msg(
persist_init_req_msg_t *msg, Buf buffer)
{
/* always send version field first for backwards compatibility */
pack16(msg->version, buffer);
if (msg->version >= SLURM_17_11_PROTOCOL_VERSION) {
packstr(msg->cluster_name, buffer);
pack16(msg->persist_type, buffer);
pack16(msg->port, buffer);
} else if (msg->version >= SLURM_MIN_PROTOCOL_VERSION) {
packstr(msg->cluster_name, buffer);
pack16(msg->port, buffer);
} else {
error("%s: invalid protocol version %u",
__func__, msg->version);
}
}
/**
* Pack filehandles
* @param buf Buffer
* @return If buf is NULL return needed size
*/
size_t _fs_pack_filehandles(pack_t buf) {
struct filelist_item *file;
struct fslist_item *fs;
size_t i;
if (buf==NULL) {
// Prepare filesystems
size_t size = sizeof(size_t)+llist_size(fslist)*sizeof(int)*2; // id, pid
for (i=0;(fs = llist_get(fslist,i));i++) size += strlen(fs->mountpoint_str)+1; // mountpoint
// Prepare files
size += sizeof(size_t)+llist_size(filelist)*sizeof(int)*8; // fh, fs_fh, stfl, fdfl, shmid, type, mode
for (i=0;(file = llist_get(filelist,i));i++) size += strlen(file->path)+1; // path
return size;
}
else {
// Pack filesystems
packi(buf,llist_size(fslist));
for (i=0;(fs = llist_get(fslist,i));i++) {
packi(buf,fs->id);
packi(buf,fs->pid);
packstr(buf,fs->mountpoint_str);
}
// Pack files
packi(buf,llist_size(filelist));
for (i=0;(file = llist_get(filelist,i));i++) {
if (file->type!=FL_DIR && !FLAG_ISSET(file->fdfl,FD_CLOEXEC)) {
packi(buf,file->fh);
packi(buf,file->fs_fh);
packi(buf,file->shmid);
packi(buf,file->type);
packi(buf,file->mode);
packi(buf,file->stfl);
packi(buf,file->fdfl);
packi(buf,file->fs->id);
packstr(buf,file->path);
}
}
return 0;
}
}
static void _pack_job_complete_msg(dbd_job_comp_msg_t *msg,
uint16_t rpc_version, Buf buffer)
{
if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) {
packstr(msg->admin_comment, buffer);
pack32(msg->assoc_id, buffer);
packstr(msg->comment, buffer);
pack64(msg->db_index, buffer);
pack32(msg->derived_ec, buffer);
pack_time(msg->end_time, buffer);
pack32(msg->exit_code, buffer);
pack32(msg->job_id, buffer);
pack32(msg->job_state, buffer);
packstr(msg->nodes, buffer);
pack32(msg->req_uid, buffer);
pack_time(msg->start_time, buffer);
pack_time(msg->submit_time, buffer);
packstr(msg->system_comment, buffer);
packstr(msg->tres_alloc_str, buffer);
}
}
extern int switch_p_pack_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;
int i;
if (debug_flags & DEBUG_FLAG_SWITCH)
info("switch_p_pack_node_info() starting");
xassert(gen_node_info);
xassert(gen_node_info->magic == SW_GEN_NODE_INFO_MAGIC);
pack16(gen_node_info->ifa_cnt, buffer);
packstr(gen_node_info->node_name, buffer);
for (i = 0; i < gen_node_info->ifa_cnt; i++) {
ifa_ptr = gen_node_info->ifa_array[i];
packstr(ifa_ptr->ifa_addr, buffer);
packstr(ifa_ptr->ifa_family, buffer);
packstr(ifa_ptr->ifa_name, buffer);
}
return SLURM_SUCCESS;
}
extern void
spawn_resp_pack(spawn_resp_t *resp, Buf buf)
{
int i;
pack32(resp->seq, buf);
pack32((uint32_t)resp->rc, buf);
packstr(resp->jobid, buf);
pack32(resp->error_cnt, buf);
for (i = 0; i < resp->error_cnt; i ++) {
pack32((uint32_t)resp->error_codes[i], buf);
}
}
extern void slurm_persist_pack_rc_msg(
persist_rc_msg_t *msg, Buf buffer, uint16_t protocol_version)
{
if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
packstr(msg->comment, buffer);
pack16(msg->flags, buffer);
pack32(msg->rc, buffer);
pack16(msg->ret_info, buffer);
} else {
error("%s: invalid protocol version %u",
__func__, protocol_version);
}
}
extern int select_nodeinfo_pack(select_nodeinfo_t *nodeinfo, Buf buffer,
uint16_t protocol_version)
{
ListIterator itr;
node_subgrp_t *subgrp = NULL;
uint16_t count = 0;
if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
pack16(nodeinfo->bitmap_size, buffer);
packstr(nodeinfo->extra_info, buffer);
packstr(nodeinfo->failed_cnodes, buffer);
if (nodeinfo->ba_mp)
packstr(nodeinfo->ba_mp->loc, buffer);
else
packstr(nodeinfo->rack_mp, buffer);
if (nodeinfo->subgrp_list)
count = list_count(nodeinfo->subgrp_list);
pack16(count, buffer);
if (count > 0) {
itr = list_iterator_create(nodeinfo->subgrp_list);
while ((subgrp = list_next(itr))) {
_pack_node_subgrp(subgrp, buffer,
protocol_version);
}
list_iterator_destroy(itr);
}
} else {
error("select_nodeinfo_pack: protocol_version "
"%hu not supported", protocol_version);
}
return SLURM_SUCCESS;
}
extern int
temp_kvs_add(char *key, char *val)
{
Buf buf;
uint32_t size;
if ( key == NULL || val == NULL )
return SLURM_SUCCESS;
buf = init_buf(PMI2_MAX_KEYLEN + PMI2_MAX_VALLEN + 2 * sizeof(uint32_t));
packstr(key, buf);
packstr(val, buf);
size = get_buf_offset(buf);
if (temp_kvs_cnt + size > temp_kvs_size) {
temp_kvs_size += TEMP_KVS_SIZE_INC;
xrealloc(temp_kvs_buf, temp_kvs_size);
}
memcpy(&temp_kvs_buf[temp_kvs_cnt], get_buf_data(buf), size);
temp_kvs_cnt += size;
free_buf(buf);
return SLURM_SUCCESS;
}
static void _pack_step_start_msg(dbd_step_start_msg_t *msg,
uint16_t rpc_version,
Buf buffer)
{
if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) {
pack32(msg->assoc_id, buffer);
pack64(msg->db_index, buffer);
pack32(msg->job_id, buffer);
packstr(msg->name, buffer);
packstr(msg->nodes, buffer);
packstr(msg->node_inx, buffer);
pack32(msg->node_cnt, buffer);
pack_time(msg->start_time, buffer);
pack_time(msg->job_submit_time, buffer);
pack32(msg->req_cpufreq_min, buffer);
pack32(msg->req_cpufreq_max, buffer);
pack32(msg->req_cpufreq_gov, buffer);
pack32(msg->step_id, buffer);
pack32(msg->task_dist, buffer);
pack32(msg->total_tasks, buffer);
packstr(msg->tres_alloc_str, buffer);
}
}
extern int slurm_ckpt_pack_job(check_jobinfo_t jobinfo, Buf buffer,
uint16_t protocol_version)
{
struct check_job_info *check_ptr =
(struct check_job_info *)jobinfo;
if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
pack16(check_ptr->disabled, buffer);
pack_time(check_ptr->time_stamp, buffer);
pack32(check_ptr->error_code, buffer);
packstr(check_ptr->error_msg, buffer);
}
return SLURM_SUCCESS;
}