Newer
Older
/****************************************************************************\
* slurm_protocol_pack.c - functions to pack and unpack structures for RPCs
*****************************************************************************
* Copyright (C) 2002 The Regents of the University of California.
* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
* Written by Kevin Tew <tew1@llnl.gov>, Moe Jette <jette1@llnl.gov>, et. al.
* UCRL-CODE-2002-040.
*
* This file is part of SLURM, a resource management program.
* For details, see <http://www.llnl.gov/linux/slurm/>.
*
* SLURM is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* SLURM is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along
* with SLURM; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
\*****************************************************************************/
#if HAVE_CONFIG_H
# include "config.h"
#endif
#include <errno.h>
#include <stdio.h>
#include "src/common/bitstring.h"
#include "src/common/log.h"
#include "src/common/pack.h"
#include "src/common/slurm_auth.h"
#include "src/common/slurm_cred.h"
#include "src/common/slurm_protocol_api.h"
#include "src/common/slurm_protocol_defs.h"
#include "src/common/slurm_protocol_pack.h"
#include "src/common/switch.h"
#include "src/common/xmalloc.h"
#define _pack_job_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
#define _pack_job_step_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
static void _pack_update_node_msg(update_node_msg_t * msg, Buf buffer);
static int _unpack_update_node_msg(update_node_msg_t ** msg, Buf buffer);
static void
_pack_node_registration_status_msg(slurm_node_registration_status_msg_t *
msg, Buf buffer);
static int
_unpack_node_registration_status_msg(slurm_node_registration_status_msg_t
** msg, Buf buffer);
static void
_pack_resource_allocation_response_msg(resource_allocation_response_msg_t *
msg, Buf buffer);
static int
_unpack_resource_allocation_response_msg(resource_allocation_response_msg_t
** msg, Buf buffer);
static void
_pack_resource_allocation_and_run_response_msg
(resource_allocation_and_run_response_msg_t * msg, Buf buffer);
static int
_unpack_resource_allocation_and_run_response_msg
(resource_allocation_and_run_response_msg_t ** msg, Buf buffer);
static void _pack_submit_response_msg(submit_response_msg_t * msg,
Buf buffer);
static int _unpack_submit_response_msg(submit_response_msg_t ** msg,
Buf buffer);
static void _pack_node_info_msg(slurm_msg_t * msg, Buf buffer);
static int _unpack_node_info_msg(node_info_msg_t ** msg, Buf buffer);
static int _unpack_node_info_members(node_info_t * node, Buf buffer);
static void _pack_update_partition_msg(update_part_msg_t * msg, Buf buffer);
static int _unpack_update_partition_msg(update_part_msg_t ** msg, Buf buffer);
static void _pack_delete_partition_msg(delete_part_msg_t * msg, Buf buffer);
static int _unpack_delete_partition_msg(delete_part_msg_t ** msg, Buf buffer);
static void _pack_job_step_create_request_msg(job_step_create_request_msg_t
* msg, Buf buffer);
static int
_unpack_job_step_create_request_msg(job_step_create_request_msg_t ** msg,
Buf buffer);
Moe Jette
committed
static void _pack_kill_job_msg(kill_job_msg_t * msg, Buf buffer);
static int _unpack_kill_job_msg(kill_job_msg_t ** msg, Buf buffer);
static void _pack_epilog_comp_msg(epilog_complete_msg_t * msg, Buf buffer);
static int _unpack_epilog_comp_msg(epilog_complete_msg_t ** msg, Buf buffer);
static void _pack_update_job_time_msg(job_time_msg_t * msg, Buf buffer);
static int _unpack_update_job_time_msg(job_time_msg_t ** msg, Buf buffer);
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
static void
_pack_job_step_create_response_msg(job_step_create_response_msg_t * msg,
Buf buffer);
static int
_unpack_job_step_create_response_msg(job_step_create_response_msg_t ** msg,
Buf buffer);
static void _pack_partition_info_msg(slurm_msg_t * msg, Buf buffer);
static int _unpack_partition_info_msg(partition_info_msg_t ** msg,
Buf buffer);
static int _unpack_partition_info_members(partition_info_t * part,
Buf buffer);
static void _pack_launch_tasks_request_msg(launch_tasks_request_msg_t *
msg, Buf buffer);
static int _unpack_launch_tasks_request_msg(launch_tasks_request_msg_t **
msg_ptr, Buf buffer);
static void _pack_cancel_tasks_msg(kill_tasks_msg_t * msg, Buf buffer);
static int _unpack_cancel_tasks_msg(kill_tasks_msg_t ** msg_ptr, Buf buffer);
static void _pack_launch_tasks_response_msg(launch_tasks_response_msg_t *
msg, Buf buffer);
static int _unpack_launch_tasks_response_msg(launch_tasks_response_msg_t **
msg_ptr, Buf buffer);
static void _pack_shutdown_msg(shutdown_msg_t * msg, Buf buffer);
static int _unpack_shutdown_msg(shutdown_msg_t ** msg_ptr, Buf buffer);
static void _pack_reattach_tasks_request_msg(reattach_tasks_request_msg_t *,
Buf);
static int _unpack_reattach_tasks_request_msg(reattach_tasks_request_msg_t **,
Buf);
static void
_pack_reattach_tasks_response_msg(reattach_tasks_response_msg_t *, Buf);
static int
_unpack_reattach_tasks_response_msg(reattach_tasks_response_msg_t **, Buf);
static void _pack_task_exit_msg(task_exit_msg_t * msg, Buf buffer);
static int _unpack_task_exit_msg(task_exit_msg_t ** msg_ptr, Buf buffer);
static void _pack_old_job_desc_msg(old_job_alloc_msg_t * job_desc_ptr,
Buf buffer);
static int _unpack_old_job_desc_msg(old_job_alloc_msg_t **
job_desc_buffer_ptr, Buf buffer);
static void _pack_return_code_msg(return_code_msg_t * msg, Buf buffer);
static int _unpack_return_code_msg(return_code_msg_t ** msg, Buf buffer);
static void _pack_slurm_ctl_conf_msg(slurm_ctl_conf_info_msg_t * build_ptr,
Buf buffer);
static int _unpack_slurm_ctl_conf_msg(slurm_ctl_conf_info_msg_t **
build_buffer_ptr, Buf buffer);
static void _pack_job_step_id_msg(job_step_id_t * msg, Buf buffer);
static int _unpack_job_step_id_msg(job_step_id_t ** msg_ptr, Buf buffer);
static void _pack_get_job_step_info_msg(job_step_info_request_msg_t * msg,
Buf buffer);
static int _unpack_get_job_step_info_msg(job_step_info_request_msg_t **
msg, Buf buffer);
static int _unpack_job_step_info_response_msg(job_step_info_response_msg_t
** msg, Buf buffer);
static int _unpack_job_step_info_members(job_step_info_t * step, Buf buffer);
static void _pack_complete_job_step_msg(complete_job_step_msg_t * msg,
Buf buffer);
static int _unpack_complete_job_step_msg(complete_job_step_msg_t **
msg_ptr, Buf buffer);
static int _unpack_job_info_members(job_info_t * job, Buf buffer);
static void _pack_batch_job_launch_msg(batch_job_launch_msg_t * msg,
Buf buffer);
static int _unpack_batch_job_launch_msg(batch_job_launch_msg_t ** msg,
Buf buffer);
static void _pack_job_desc_msg(job_desc_msg_t * job_desc_ptr, Buf buffer);
static int _unpack_job_desc_msg(job_desc_msg_t ** job_desc_buffer_ptr,
Buf buffer);
static int _unpack_job_info_msg(job_info_msg_t ** msg, Buf buffer);
static void _pack_last_update_msg(last_update_msg_t * msg, Buf buffer);
static int _unpack_last_update_msg(last_update_msg_t ** msg, Buf buffer);
static void _pack_slurm_addr_array(slurm_addr * slurm_address,
uint16_t size_val, Buf buffer);
static int _unpack_slurm_addr_array(slurm_addr ** slurm_address,
uint16_t * size_val, Buf buffer);
static void _pack_job_id_request_msg(job_id_request_msg_t * msg, Buf buffer);
static int _unpack_job_id_request_msg(job_id_request_msg_t ** msg, Buf buffer);
static void _pack_job_id_response_msg(job_id_response_msg_t * msg, Buf buffer);
static int _unpack_job_id_response_msg(job_id_response_msg_t ** msg,
Buf buffer);
static void _pack_job_step_kill_msg(job_step_kill_msg_t * msg, Buf buffer);
static int _unpack_job_step_kill_msg(job_step_kill_msg_t ** msg_ptr,
Buf buffer);
static void _pack_srun_ping_msg(srun_ping_msg_t * msg, Buf buffer);
static int _unpack_srun_ping_msg(srun_ping_msg_t ** msg_ptr, Buf buffer);
static void _pack_srun_node_fail_msg(srun_node_fail_msg_t * msg, Buf buffer);
static int _unpack_srun_node_fail_msg(srun_node_fail_msg_t ** msg_ptr,
Buf buffer);
static void _pack_srun_timeout_msg(srun_timeout_msg_t * msg, Buf buffer);
static int _unpack_srun_timeout_msg(srun_timeout_msg_t ** msg_ptr, Buf buffer);
static void _pack_buffer_msg(slurm_msg_t * msg, Buf buffer);
/* pack_header
* packs a slurm protocol header that proceeds every slurm message
* IN header - the header structure to pack
* IN/OUT buffer - destination of the pack, contains pointers that are
void
pack_header(header_t * header, Buf buffer)
pack16(header->version, buffer);
pack16(header->flags, buffer);
pack16((uint16_t) header->msg_type, buffer);
pack32(header->body_length, buffer);
/* unpack_header
* unpacks a slurm protocol header that proceeds every slurm message
* OUT header - the header structure to unpack
* IN/OUT buffer - source of the unpack data, contains pointers that are
int
unpack_header(header_t * header, Buf buffer)
safe_unpack16(&header->version, buffer);
safe_unpack16(&header->flags, buffer);
safe_unpack16(&tmp, buffer);
header->msg_type = (slurm_msg_type_t) tmp;
safe_unpack32(&header->body_length, buffer);
return SLURM_SUCCESS;
return SLURM_ERROR;
* packs a generic slurm protocol message body
* IN msg - the body structure to pack (note: includes message type)
* IN/OUT buffer - destination of the pack, contains pointers that are
int
pack_msg(slurm_msg_t const *msg, Buf buffer)
{
switch (msg->msg_type) {
case REQUEST_BUILD_INFO:
case REQUEST_NODE_INFO:
case REQUEST_PARTITION_INFO:
case REQUEST_ACCTING_INFO:
_pack_last_update_msg((last_update_msg_t *)
msg->data, buffer);
break;
case RESPONSE_BUILD_INFO:
_pack_slurm_ctl_conf_msg((slurm_ctl_conf_info_msg_t *)
msg->data, buffer);
break;
case RESPONSE_JOB_INFO:
_pack_job_info_msg((slurm_msg_t *) msg, buffer);
break;
case RESPONSE_PARTITION_INFO:
_pack_partition_info_msg((slurm_msg_t *) msg, buffer);
break;
case RESPONSE_NODE_INFO:
_pack_node_info_msg((slurm_msg_t *) msg, buffer);
break;
case MESSAGE_NODE_REGISTRATION_STATUS:
_pack_node_registration_status_msg(
(slurm_node_registration_status_msg_t *) msg->data,
buffer);
break;
case REQUEST_RESOURCE_ALLOCATION:
case REQUEST_SUBMIT_BATCH_JOB:
case REQUEST_JOB_WILL_RUN:
case REQUEST_ALLOCATION_AND_RUN_JOB_STEP:
case REQUEST_UPDATE_JOB:
_pack_job_desc_msg((job_desc_msg_t *)
msg->data, buffer);
break;
case REQUEST_OLD_JOB_RESOURCE_ALLOCATION:
_pack_old_job_desc_msg((old_job_alloc_msg_t *) msg->data,
buffer);
break;
case REQUEST_NODE_REGISTRATION_STATUS:
case REQUEST_RECONFIGURE:
case REQUEST_SHUTDOWN_IMMEDIATE:
case REQUEST_PING:
case REQUEST_CONTROL:
/* Message contains no body/information */
break;
case REQUEST_SHUTDOWN:
_pack_shutdown_msg((shutdown_msg_t *) msg->data, buffer);
break;
case RESPONSE_SUBMIT_BATCH_JOB:
_pack_submit_response_msg((submit_response_msg_t *)
msg->data, buffer);
break;
case RESPONSE_RESOURCE_ALLOCATION:
case RESPONSE_JOB_WILL_RUN:
_pack_resource_allocation_response_msg
((resource_allocation_response_msg_t *) msg->data,
buffer);
break;
case RESPONSE_ALLOCATION_AND_RUN_JOB_STEP:
_pack_resource_allocation_and_run_response_msg(
(resource_allocation_and_run_response_msg_t *)
msg->data, buffer);
break;
case REQUEST_UPDATE_NODE:
_pack_update_node_msg((update_node_msg_t *) msg->data,
buffer);
break;
case REQUEST_UPDATE_PARTITION:
_pack_update_partition_msg((update_part_msg_t *) msg->
data, buffer);
break;
case REQUEST_DELETE_PARTITION:
_pack_delete_partition_msg((delete_part_msg_t *) msg->
data, buffer);
break;
_pack_reattach_tasks_request_msg(
(reattach_tasks_request_msg_t *) msg->data, buffer);
break;
case RESPONSE_REATTACH_TASKS:
_pack_reattach_tasks_response_msg(
(reattach_tasks_response_msg_t *) msg->data, buffer);
break;
case REQUEST_LAUNCH_TASKS:
_pack_launch_tasks_request_msg(
(launch_tasks_request_msg_t *) msg->data,
buffer);
break;
case RESPONSE_LAUNCH_TASKS:
_pack_launch_tasks_response_msg((launch_tasks_response_msg_t
*) msg->data, buffer);
break;
case REQUEST_KILL_TASKS:
_pack_cancel_tasks_msg((kill_tasks_msg_t *) msg->data,
buffer);
break;
case REQUEST_JOB_STEP_INFO:
_pack_get_job_step_info_msg((job_step_info_request_msg_t
*) msg->data, buffer);
break;
case REQUEST_JOB_INFO:
_pack_job_step_id_msg((job_step_id_t *) msg->data, buffer);
break;
case REQUEST_CANCEL_JOB_STEP:
_pack_job_step_kill_msg((job_step_kill_msg_t *)
msg->data, buffer);
break;
case REQUEST_COMPLETE_JOB_STEP:
_pack_complete_job_step_msg((complete_job_step_msg_t *)
msg->data, buffer);
break;
Moe Jette
committed
case REQUEST_KILL_TIMELIMIT:
Moe Jette
committed
case REQUEST_KILL_JOB:
_pack_kill_job_msg((kill_job_msg_t *) msg->data, buffer);
case MESSAGE_EPILOG_COMPLETE:
_pack_epilog_comp_msg((epilog_complete_msg_t *) msg->data, buffer);
break;
case REQUEST_UPDATE_JOB_TIME:
_pack_update_job_time_msg((job_time_msg_t *)
msg->data, buffer);
break;
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
case REQUEST_SIGNAL_JOB:
break;
case REQUEST_SIGNAL_JOB_STEP:
break;
case RESPONSE_RECONFIGURE:
case RESPONSE_SHUTDOWN:
case RESPONSE_CANCEL_JOB_STEP:
case RESPONSE_COMPLETE_JOB_STEP:
case RESPONSE_SIGNAL_JOB:
case RESPONSE_SIGNAL_JOB_STEP:
break;
case REQUEST_JOB_ATTACH:
break;
case RESPONSE_JOB_ATTACH:
break;
case RESPONSE_JOB_STEP_INFO:
_pack_job_step_info_msg((slurm_msg_t *) msg, buffer);
break;
case REQUEST_JOB_RESOURCE:
break;
case RESPONSE_JOB_RESOURCE:
break;
case REQUEST_RUN_JOB_STEP:
break;
case RESPONSE_RUN_JOB_STEP:
break;
case MESSAGE_TASK_EXIT:
_pack_task_exit_msg((task_exit_msg_t *) msg->data, buffer);
break;
case REQUEST_BATCH_JOB_LAUNCH:
_pack_batch_job_launch_msg((batch_job_launch_msg_t *)
msg->data, buffer);
break;
case MESSAGE_UPLOAD_ACCOUNTING_INFO:
break;
case RESPONSE_SLURM_RC:
_pack_return_code_msg((return_code_msg_t *) msg->data,
buffer);
break;
case RESPONSE_JOB_STEP_CREATE:
_pack_job_step_create_response_msg(
(job_step_create_response_msg_t *)
msg->data, buffer);
break;
case REQUEST_JOB_STEP_CREATE:
_pack_job_step_create_request_msg(
(job_step_create_request_msg_t *)
msg->data, buffer);
case REQUEST_JOB_ID:
_pack_job_id_request_msg(
(job_id_request_msg_t *)msg->data,
buffer);
break;
case RESPONSE_JOB_ID:
_pack_job_id_response_msg(
(job_id_response_msg_t *)msg->data,
buffer);
break;
case SRUN_PING:
_pack_srun_ping_msg((srun_ping_msg_t *)msg->data, buffer);
break;
case SRUN_NODE_FAIL:
_pack_srun_node_fail_msg((srun_node_fail_msg_t *)msg->data,
buffer);
break;
case SRUN_TIMEOUT:
_pack_srun_timeout_msg((srun_timeout_msg_t *)msg->data, buffer);
break;
default:
debug("No pack method for msg type %i", msg->msg_type);
return EINVAL;
break;
* unpacks a generic slurm protocol message body
* OUT msg - the body structure to unpack (note: includes message type)
* IN/OUT buffer - source of the unpack, contains pointers that are
int
unpack_msg(slurm_msg_t * msg, Buf buffer)
int rc = SLURM_SUCCESS;
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
msg->data = NULL; /* Initialize to no data for now */
switch (msg->msg_type) {
case REQUEST_BUILD_INFO:
case REQUEST_NODE_INFO:
case REQUEST_PARTITION_INFO:
case REQUEST_ACCTING_INFO:
rc = _unpack_last_update_msg((last_update_msg_t **) &
(msg->data), buffer);
break;
case RESPONSE_BUILD_INFO:
rc = _unpack_slurm_ctl_conf_msg((slurm_ctl_conf_info_msg_t
**)
& (msg->data), buffer);
break;
case RESPONSE_JOB_INFO:
rc = _unpack_job_info_msg((job_info_msg_t **) & (msg->data),
buffer);
break;
case RESPONSE_PARTITION_INFO:
rc = _unpack_partition_info_msg((partition_info_msg_t **) &
(msg->data), buffer);
break;
case RESPONSE_NODE_INFO:
rc = _unpack_node_info_msg((node_info_msg_t **) &
(msg->data), buffer);
break;
case MESSAGE_NODE_REGISTRATION_STATUS:
rc = _unpack_node_registration_status_msg(
(slurm_node_registration_status_msg_t **)
& (msg->data), buffer);
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
break;
case REQUEST_RESOURCE_ALLOCATION:
case REQUEST_SUBMIT_BATCH_JOB:
case REQUEST_JOB_WILL_RUN:
case REQUEST_ALLOCATION_AND_RUN_JOB_STEP:
case REQUEST_UPDATE_JOB:
rc = _unpack_job_desc_msg((job_desc_msg_t **) & (msg->data),
buffer);
break;
case REQUEST_OLD_JOB_RESOURCE_ALLOCATION:
rc = _unpack_old_job_desc_msg((old_job_alloc_msg_t **) &
(msg->data), buffer);
break;
case REQUEST_NODE_REGISTRATION_STATUS:
case REQUEST_RECONFIGURE:
case REQUEST_SHUTDOWN_IMMEDIATE:
case REQUEST_PING:
case REQUEST_CONTROL:
/* Message contains no body/information */
break;
case REQUEST_SHUTDOWN:
rc = _unpack_shutdown_msg((shutdown_msg_t **) & (msg->data),
buffer);
break;
case RESPONSE_SUBMIT_BATCH_JOB:
rc = _unpack_submit_response_msg((submit_response_msg_t **)
& (msg->data), buffer);
break;
case RESPONSE_RESOURCE_ALLOCATION:
case RESPONSE_JOB_WILL_RUN:
rc = _unpack_resource_allocation_response_msg(
(resource_allocation_response_msg_t **)
& (msg->data), buffer);
break;
case RESPONSE_ALLOCATION_AND_RUN_JOB_STEP:
rc = _unpack_resource_allocation_and_run_response_msg(
(resource_allocation_and_run_response_msg_t **)
&(msg->data), buffer);
break;
case REQUEST_UPDATE_NODE:
rc = _unpack_update_node_msg((update_node_msg_t **) &
(msg->data), buffer);
break;
case REQUEST_UPDATE_PARTITION:
rc = _unpack_update_partition_msg((update_part_msg_t **) &
(msg->data), buffer);
break;
case REQUEST_DELETE_PARTITION:
rc = _unpack_delete_partition_msg((delete_part_msg_t **) &
(msg->data), buffer);
break;
rc = _unpack_launch_tasks_request_msg(
(launch_tasks_request_msg_t **)
& (msg->data), buffer);
break;
case RESPONSE_LAUNCH_TASKS:
rc = _unpack_launch_tasks_response_msg(
(launch_tasks_response_msg_t **)
& (msg->data), buffer);
break;
case REQUEST_REATTACH_TASKS:
rc = _unpack_reattach_tasks_request_msg(
(reattach_tasks_request_msg_t **) & msg->data,
buffer);
break;
case RESPONSE_REATTACH_TASKS:
rc = _unpack_reattach_tasks_response_msg(
(reattach_tasks_response_msg_t **)
& msg->data, buffer);
break;
case REQUEST_KILL_TASKS:
rc = _unpack_cancel_tasks_msg((kill_tasks_msg_t **) &
(msg->data), buffer);
break;
case REQUEST_JOB_STEP_INFO:
rc = _unpack_get_job_step_info_msg(
(job_step_info_request_msg_t **)
& (msg->data), buffer);
case REQUEST_JOB_INFO:
rc = _unpack_job_step_id_msg((job_step_id_t **)
& (msg->data), buffer);
break;
case REQUEST_CANCEL_JOB_STEP:
rc = _unpack_job_step_kill_msg((job_step_kill_msg_t **)
& (msg->data), buffer);
break;
case REQUEST_COMPLETE_JOB_STEP:
rc = _unpack_complete_job_step_msg((complete_job_step_msg_t
**) & (msg->data),
buffer);
break;
Moe Jette
committed
case REQUEST_KILL_TIMELIMIT:
Moe Jette
committed
case REQUEST_KILL_JOB:
rc = _unpack_kill_job_msg((kill_job_msg_t **) & (msg->data),
buffer);
case MESSAGE_EPILOG_COMPLETE:
rc = _unpack_epilog_comp_msg((epilog_complete_msg_t **)
& (msg->data), buffer);
break;
case REQUEST_UPDATE_JOB_TIME:
rc = _unpack_update_job_time_msg(
(job_time_msg_t **)
& (msg->data), buffer);
break;
case REQUEST_SIGNAL_JOB:
break;
case REQUEST_SIGNAL_JOB_STEP:
break;
case RESPONSE_RECONFIGURE:
case RESPONSE_SHUTDOWN:
case RESPONSE_CANCEL_JOB_STEP:
case RESPONSE_COMPLETE_JOB_STEP:
case RESPONSE_SIGNAL_JOB:
case RESPONSE_SIGNAL_JOB_STEP:
break;
case REQUEST_JOB_ATTACH:
break;
case RESPONSE_JOB_ATTACH:
break;
case RESPONSE_JOB_STEP_INFO:
rc = _unpack_job_step_info_response_msg(
(job_step_info_response_msg_t **)
& (msg->data), buffer);
break;
case REQUEST_JOB_RESOURCE:
break;
case RESPONSE_JOB_RESOURCE:
break;
case REQUEST_RUN_JOB_STEP:
break;
case RESPONSE_RUN_JOB_STEP:
break;
case MESSAGE_TASK_EXIT:
rc = _unpack_task_exit_msg((task_exit_msg_t **)
& (msg->data), buffer);
break;
case REQUEST_BATCH_JOB_LAUNCH:
rc = _unpack_batch_job_launch_msg((batch_job_launch_msg_t **)
& (msg->data), buffer);
break;
case MESSAGE_UPLOAD_ACCOUNTING_INFO:
break;
case RESPONSE_SLURM_RC:
rc = _unpack_return_code_msg((return_code_msg_t **)
& (msg->data), buffer);
break;
case RESPONSE_JOB_STEP_CREATE:
rc = _unpack_job_step_create_response_msg(
(job_step_create_response_msg_t **)
& msg->data, buffer);
break;
case REQUEST_JOB_STEP_CREATE:
rc = _unpack_job_step_create_request_msg(
(job_step_create_request_msg_t **)
& msg->data, buffer);
case REQUEST_JOB_ID:
rc = _unpack_job_id_request_msg(
(job_id_request_msg_t **) & msg->data,
buffer);
break;
case RESPONSE_JOB_ID:
rc = _unpack_job_id_response_msg(
(job_id_response_msg_t **) & msg->data,
buffer);
break;
case SRUN_PING:
rc = _unpack_srun_ping_msg((srun_ping_msg_t **) & msg->data,
buffer);
break;
case SRUN_NODE_FAIL:
rc = _unpack_srun_node_fail_msg((srun_node_fail_msg_t **)
& msg->data, buffer);
break;
case SRUN_TIMEOUT:
rc = _unpack_srun_timeout_msg((srun_timeout_msg_t **)
& msg->data, buffer);
break;
default:
debug("No unpack method for msg type %i", msg->msg_type);
return EINVAL;
break;
if (rc)
error("Malformed RPC of type %u received", msg->msg_type);
return rc;
static void
_pack_update_node_msg(update_node_msg_t * msg, Buf buffer)
packstr(msg->node_names, buffer);
pack16(msg->node_state, buffer);
packstr(msg->reason, buffer);
static int
_unpack_update_node_msg(update_node_msg_t ** msg, Buf buffer)
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(update_node_msg_t));
*msg = tmp_ptr;
safe_unpackstr_xmalloc(&tmp_ptr->node_names, &uint16_tmp, buffer);
safe_unpack16(&tmp_ptr->node_state, buffer);
safe_unpackstr_xmalloc(&tmp_ptr->reason, &uint16_tmp, buffer);
xfree(tmp_ptr->node_names);
xfree(tmp_ptr->reason);
*msg = NULL;
return SLURM_ERROR;
static void
_pack_node_registration_status_msg(slurm_node_registration_status_msg_t *
msg, Buf buffer)
int i;
pack_time(msg->timestamp, buffer);
pack32(msg->status, buffer);
packstr(msg->node_name, buffer);
pack32(msg->cpus, buffer);
pack32(msg->real_memory_size, buffer);
pack32(msg->temporary_disk_space, buffer);
pack32(msg->job_count, buffer);
for (i = 0; i < msg->job_count; i++) {
pack32(msg->job_id[i], buffer);
for (i = 0; i < msg->job_count; i++) {
pack16(msg->step_id[i], buffer);
static int
_unpack_node_registration_status_msg(slurm_node_registration_status_msg_t
** msg, Buf buffer)
uint16_t uint16_tmp;
int i;
slurm_node_registration_status_msg_t *node_reg_ptr;
/* alloc memory for structure */
assert(msg != NULL);
node_reg_ptr = xmalloc(sizeof(slurm_node_registration_status_msg_t));
*msg = node_reg_ptr;
/* unpack timestamp of snapshot */
safe_unpack_time(&node_reg_ptr->timestamp, buffer);
/* load the data values */
safe_unpack32(&node_reg_ptr->status, buffer);
safe_unpackstr_xmalloc(&node_reg_ptr->node_name, &uint16_tmp, buffer);
safe_unpack32(&node_reg_ptr->cpus, buffer);
safe_unpack32(&node_reg_ptr->real_memory_size, buffer);
safe_unpack32(&node_reg_ptr->temporary_disk_space, buffer);
safe_unpack32(&node_reg_ptr->job_count, buffer);
node_reg_ptr->job_id =
xmalloc(sizeof(uint32_t) * node_reg_ptr->job_count);
for (i = 0; i < node_reg_ptr->job_count; i++) {
safe_unpack32(&node_reg_ptr->job_id[i], buffer);
node_reg_ptr->step_id =
xmalloc(sizeof(uint16_t) * node_reg_ptr->job_count);
for (i = 0; i < node_reg_ptr->job_count; i++) {
safe_unpack16(&node_reg_ptr->step_id[i], buffer);
xfree(node_reg_ptr->node_name);
xfree(node_reg_ptr->job_id);
xfree(node_reg_ptr->step_id);
xfree(node_reg_ptr);
*msg = NULL;
return SLURM_ERROR;
static void
_pack_resource_allocation_response_msg(resource_allocation_response_msg_t *
msg, Buf buffer)
pack32(msg->error_code, buffer);
pack32(msg->job_id, buffer);
packstr(msg->node_list, buffer);
pack16(msg->num_cpu_groups, buffer);
pack32_array(msg->cpus_per_node, msg->num_cpu_groups, buffer);
pack32_array(msg->cpu_count_reps, msg->num_cpu_groups, buffer);
pack16(msg->node_cnt, buffer);
_pack_slurm_addr_array(msg->node_addr, msg->node_cnt, buffer);
static int
_unpack_resource_allocation_response_msg(resource_allocation_response_msg_t
** msg, Buf buffer)
uint32_t uint32_tmp;
resource_allocation_response_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(resource_allocation_response_msg_t));
*msg = tmp_ptr;
safe_unpack32(&tmp_ptr->error_code, buffer);
safe_unpack32(&tmp_ptr->job_id, buffer);
safe_unpackstr_xmalloc(&tmp_ptr->node_list, &uint16_tmp, buffer);
safe_unpack16(&tmp_ptr->num_cpu_groups, buffer);
if (tmp_ptr->num_cpu_groups > 0) {
safe_unpack32_array((uint32_t **) &
(tmp_ptr->cpus_per_node), &uint32_tmp,
if (tmp_ptr->num_cpu_groups != uint32_tmp)
goto unpack_error;
safe_unpack32_array((uint32_t **) &
(tmp_ptr->cpu_count_reps), &uint32_tmp,
if (tmp_ptr->num_cpu_groups != uint32_tmp)
goto unpack_error;
tmp_ptr->cpus_per_node = NULL;
tmp_ptr->cpu_count_reps = NULL;
}
safe_unpack16(&tmp_ptr->node_cnt, buffer);
if (tmp_ptr->node_cnt > 0) {
if (_unpack_slurm_addr_array(&(tmp_ptr->node_addr),
&(tmp_ptr->node_cnt), buffer))
goto unpack_error;
} else
tmp_ptr->node_addr = NULL;
debug("job id is %u", tmp_ptr->job_id);
xfree(tmp_ptr->node_list);
xfree(tmp_ptr->cpus_per_node);
xfree(tmp_ptr->cpu_count_reps);
xfree(tmp_ptr);
*msg = NULL;
return SLURM_ERROR;
static void
_pack_resource_allocation_and_run_response_msg
(resource_allocation_and_run_response_msg_t * msg, Buf buffer) {
assert(msg != NULL);
pack32(msg->job_id, buffer);
packstr(msg->node_list, buffer);
pack16(msg->num_cpu_groups, buffer);
pack32_array(msg->cpus_per_node, msg->num_cpu_groups, buffer);
pack32_array(msg->cpu_count_reps, msg->num_cpu_groups, buffer);
pack32(msg->job_step_id, buffer);
pack16(msg->node_cnt, buffer);
_pack_slurm_addr_array(msg->node_addr, msg->node_cnt, buffer);
slurm_cred_pack(msg->cred, buffer);
switch_pack_jobinfo(msg->switch_job, buffer);
static int
_unpack_resource_allocation_and_run_response_msg
(resource_allocation_and_run_response_msg_t ** msg, Buf buffer) {
uint16_t uint16_tmp;
uint32_t uint32_tmp;
resource_allocation_and_run_response_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(resource_allocation_and_run_response_msg_t));
*msg = tmp_ptr;
/* load the data values */
safe_unpack32(&tmp_ptr->job_id, buffer);
safe_unpackstr_xmalloc(&tmp_ptr->node_list, &uint16_tmp, buffer);
safe_unpack16(&tmp_ptr->num_cpu_groups, buffer);
if (tmp_ptr->num_cpu_groups > 0) {
tmp_ptr->cpus_per_node = (uint32_t *)
xmalloc(sizeof(uint32_t) * tmp_ptr->num_cpu_groups);
tmp_ptr->cpu_count_reps = (uint32_t *)
xmalloc(sizeof(uint32_t) * tmp_ptr->num_cpu_groups);
safe_unpack32_array((uint32_t **) &
(tmp_ptr->cpus_per_node),
&uint32_tmp, buffer);
if (tmp_ptr->num_cpu_groups != uint32_tmp)
goto unpack_error;
safe_unpack32_array((uint32_t **) &
(tmp_ptr->cpu_count_reps),
&uint32_tmp, buffer);
if (tmp_ptr->num_cpu_groups != uint32_tmp)
goto unpack_error;
safe_unpack32(&tmp_ptr->job_step_id, buffer);
safe_unpack16(&tmp_ptr->node_cnt, buffer);
if (tmp_ptr->node_cnt > 0) {
if (_unpack_slurm_addr_array(&(tmp_ptr->node_addr),
&(tmp_ptr->node_cnt), buffer))
goto unpack_error;
} else
tmp_ptr->node_addr = NULL;
if (!(tmp_ptr->cred = slurm_cred_unpack(buffer)))
goto unpack_error;
Moe Jette
committed
switch_alloc_jobinfo(&tmp_ptr->switch_job);
if (switch_unpack_jobinfo(tmp_ptr->switch_job, buffer) < 0) {
error("switch_unpack_jobinfo: %m");
switch_free_jobinfo(tmp_ptr->switch_job);
goto unpack_error;
xfree(tmp_ptr->node_list);
xfree(tmp_ptr->cpus_per_node);
xfree(tmp_ptr->cpu_count_reps);
xfree(tmp_ptr);
*msg = NULL;
return SLURM_ERROR;
static void
_pack_submit_response_msg(submit_response_msg_t * msg, Buf buffer)
assert(msg != NULL);
pack32(msg->job_id, buffer);
pack32(msg->error_code, buffer);
}
static int
_unpack_submit_response_msg(submit_response_msg_t ** msg, Buf buffer)
submit_response_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(submit_response_msg_t));
*msg = tmp_ptr;
/* load the data values */
safe_unpack32(&tmp_ptr->job_id, buffer);
safe_unpack32(&tmp_ptr->error_code, buffer);
*msg = NULL;
return SLURM_ERROR;
static void
_pack_node_info_msg(slurm_msg_t * msg, Buf buffer)
packmem_array(msg->data, msg->data_size, buffer);
tewk
committed
}
static int
_unpack_node_info_msg(node_info_msg_t ** msg, Buf buffer)
tewk
committed
{
int i;
node_info_t *node = NULL;
assert(msg != NULL);
*msg = xmalloc(sizeof(node_info_msg_t));
tewk
committed
/* load buffer's header (data structure version and time) */
safe_unpack32(&((*msg)->record_count), buffer);
safe_unpack_time(&((*msg)->last_update), buffer);
tewk
committed
node = (*msg)->node_array =
xmalloc(sizeof(node_info_t) * (*msg)->record_count);
tewk
committed
/* load individual job info */
for (i = 0; i < (*msg)->record_count; i++) {
if (_unpack_node_info_members(&node[i], buffer))
goto unpack_error;
tewk
committed
}
return SLURM_SUCCESS;
xfree(node);
xfree(*msg);
*msg = NULL;
return SLURM_ERROR;
tewk
committed
}
static int
_unpack_node_info_members(node_info_t * node, Buf buffer)
safe_unpackstr_xmalloc(&node->name, &uint16_tmp, buffer);
safe_unpack16(&node->node_state, buffer);
safe_unpack32(&node->cpus, buffer);
safe_unpack32(&node->real_memory, buffer);
safe_unpack32(&node->tmp_disk, buffer);
safe_unpack32(&node->weight, buffer);
safe_unpackstr_xmalloc(&node->features, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&node->partition, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&node->reason, &uint16_tmp, buffer);
return SLURM_SUCCESS;
xfree(node->name);
xfree(node->features);
xfree(node->partition);
xfree(node->reason);
return SLURM_ERROR;
static void
_pack_update_partition_msg(update_part_msg_t * msg, Buf buffer)
packstr(msg->allow_groups, buffer);
pack16(msg-> default_part, buffer);
pack32(msg-> max_time, buffer);
pack32(msg-> max_nodes, buffer);
pack32(msg-> min_nodes, buffer);
packstr(msg->name, buffer);
packstr(msg->nodes, buffer);
pack16(msg-> root_only, buffer);
pack16(msg-> shared, buffer);
pack16(msg-> state_up, buffer);
static int
_unpack_update_partition_msg(update_part_msg_t ** msg, Buf buffer)
{
uint16_t uint16_tmp;
update_part_msg_t *tmp_ptr;
assert(msg != NULL);
/* alloc memory for structure */
tmp_ptr = xmalloc(sizeof(update_part_msg_t));
safe_unpackstr_xmalloc(&tmp_ptr->allow_groups, &uint16_tmp, buffer);
safe_unpack16(&tmp_ptr->default_part, buffer);
safe_unpack32(&tmp_ptr->max_time, buffer);
safe_unpack32(&tmp_ptr->max_nodes, buffer);
safe_unpack32(&tmp_ptr->min_nodes, buffer);
safe_unpackstr_xmalloc(&tmp_ptr->name, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&tmp_ptr->nodes, &uint16_tmp, buffer);
safe_unpack16(&tmp_ptr->root_only, buffer);
safe_unpack16(&tmp_ptr->shared, buffer);
safe_unpack16(&tmp_ptr->state_up, buffer);
return SLURM_SUCCESS;
xfree(tmp_ptr->name);
xfree(tmp_ptr->nodes);
xfree(tmp_ptr->allow_groups);
xfree(tmp_ptr);
*msg = NULL;
return SLURM_ERROR;
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
static void
_pack_delete_partition_msg(delete_part_msg_t * msg, Buf buffer)
{
assert(msg != NULL);
packstr(msg->name, buffer);
}
static int
_unpack_delete_partition_msg(delete_part_msg_t ** msg, Buf buffer)
{
uint16_t uint16_tmp;
delete_part_msg_t *tmp_ptr;
assert(msg != NULL);
/* alloc memory for structure */
tmp_ptr = xmalloc(sizeof(delete_part_msg_t));
*msg = tmp_ptr;
safe_unpackstr_xmalloc(&tmp_ptr->name, &uint16_tmp, buffer);
return SLURM_SUCCESS;
unpack_error:
xfree(tmp_ptr->name);
xfree(tmp_ptr);
*msg = NULL;
return SLURM_ERROR;
}
static void
_pack_job_step_create_request_msg(job_step_create_request_msg_t
* msg, Buf buffer)
pack32(msg->job_id, buffer);
pack32(msg->user_id, buffer);
pack32(msg->node_count, buffer);
pack32(msg->cpu_count, buffer);
pack32(msg->num_tasks, buffer);
pack16(msg->relative, buffer);
pack16(msg->task_dist, buffer);
pack16(msg->port, buffer);
packstr(msg->host, buffer);
packstr(msg->node_list, buffer);
static int
_unpack_job_step_create_request_msg(job_step_create_request_msg_t ** msg,
Buf buffer)
{
uint16_t uint16_tmp;
job_step_create_request_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(job_step_create_request_msg_t));
*msg = tmp_ptr;
safe_unpack32(&(tmp_ptr->job_id), buffer);
safe_unpack32(&(tmp_ptr->user_id), buffer);
safe_unpack32(&(tmp_ptr->node_count), buffer);
safe_unpack32(&(tmp_ptr->cpu_count), buffer);
safe_unpack32(&(tmp_ptr->num_tasks), buffer);
safe_unpack16(&(tmp_ptr->relative), buffer);
safe_unpack16(&(tmp_ptr->task_dist), buffer);
safe_unpack16(&(tmp_ptr->port), buffer);
safe_unpackstr_xmalloc(&(tmp_ptr->host), &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&(tmp_ptr->node_list), &uint16_tmp, buffer);
return SLURM_SUCCESS;
xfree(tmp_ptr->host);
xfree(tmp_ptr->node_list);
xfree(tmp_ptr);
*msg = NULL;
return SLURM_ERROR;
Moe Jette
committed
_pack_kill_job_msg(kill_job_msg_t * msg, Buf buffer)
pack32(msg->job_id, buffer);
pack32(msg->job_uid, buffer);
Moe Jette
committed
_unpack_kill_job_msg(kill_job_msg_t ** msg, Buf buffer)
Moe Jette
committed
kill_job_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg);
Moe Jette
committed
tmp_ptr = xmalloc(sizeof(kill_job_msg_t));
*msg = tmp_ptr;
safe_unpack32(&(tmp_ptr->job_id), buffer);
safe_unpack32(&(tmp_ptr->job_uid), buffer);
return SLURM_SUCCESS;
*msg = NULL;
return SLURM_ERROR;
static void
_pack_epilog_comp_msg(epilog_complete_msg_t * msg, Buf buffer)
{
assert(msg != NULL);
pack32(msg->job_id, buffer);
pack32(msg->return_code, buffer);
packstr(msg->node_name, buffer);
}
static int
_unpack_epilog_comp_msg(epilog_complete_msg_t ** msg, Buf buffer)
{
epilog_complete_msg_t *tmp_ptr;
uint16_t uint16_tmp;
/* alloc memory for structure */
assert(msg);
tmp_ptr = xmalloc(sizeof(epilog_complete_msg_t));
*msg = tmp_ptr;
safe_unpack32(&(tmp_ptr->job_id), buffer);
safe_unpack32(&(tmp_ptr->return_code), buffer);
safe_unpackstr_xmalloc(& (tmp_ptr->node_name), &uint16_tmp, buffer);
return SLURM_SUCCESS;
unpack_error:
xfree(tmp_ptr);
*msg = NULL;
return SLURM_ERROR;
}
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
static void
_pack_update_job_time_msg(job_time_msg_t * msg, Buf buffer)
{
assert(msg != NULL);
pack32(msg->job_id, buffer);
pack_time((uint32_t) msg->expiration_time, buffer);
}
static int
_unpack_update_job_time_msg(job_time_msg_t ** msg, Buf buffer)
{
job_time_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg);
tmp_ptr = xmalloc(sizeof(job_time_msg_t));
*msg = tmp_ptr;
safe_unpack32(&(tmp_ptr->job_id), buffer);
safe_unpack_time(& (tmp_ptr->expiration_time), buffer);
return SLURM_SUCCESS;
unpack_error:
*msg = NULL;
return SLURM_ERROR;
}
static void
_pack_job_step_create_response_msg(job_step_create_response_msg_t * msg,
Buf buffer)
pack32(msg->job_step_id, buffer);
packstr(msg->node_list, buffer);
slurm_cred_pack(msg->cred, buffer);
switch_pack_jobinfo(msg->switch_job, buffer);
static int
_unpack_job_step_create_response_msg(job_step_create_response_msg_t ** msg,
Buf buffer)
{
uint16_t uint16_tmp;
job_step_create_response_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(job_step_create_response_msg_t));
*msg = tmp_ptr;
safe_unpack32(&tmp_ptr->job_step_id, buffer);
safe_unpackstr_xmalloc(&tmp_ptr->node_list, &uint16_tmp, buffer);
if (!(tmp_ptr->cred = slurm_cred_unpack(buffer)))
goto unpack_error;
switch_alloc_jobinfo(&tmp_ptr->switch_job);
if (switch_unpack_jobinfo(tmp_ptr->switch_job, buffer)) {
error("switch_unpack_jobinfo: %m");
switch_free_jobinfo(tmp_ptr->switch_job);
goto unpack_error;
}
return SLURM_SUCCESS;
xfree(tmp_ptr->node_list);
xfree(tmp_ptr);
*msg = NULL;
return SLURM_ERROR;
static void
_pack_partition_info_msg(slurm_msg_t * msg, Buf buffer)
{
packmem_array(msg->data, msg->data_size, buffer);
static int
_unpack_partition_info_msg(partition_info_msg_t ** msg, Buf buffer)
int i;
partition_info_t *partition = NULL;
*msg = xmalloc(sizeof(partition_info_msg_t));
/* load buffer's header (data structure version and time) */
safe_unpack32(&((*msg)->record_count), buffer);
safe_unpack_time(&((*msg)->last_update), buffer);
partition = (*msg)->partition_array =
xmalloc(sizeof(partition_info_t) * (*msg)->record_count);
/* load individual job info */
for (i = 0; i < (*msg)->record_count; i++) {
if (_unpack_partition_info_members(&partition[i], buffer))
goto unpack_error;
xfree(partition);
xfree(*msg);
*msg = NULL;
return SLURM_ERROR;
static int
_unpack_partition_info_members(partition_info_t * part, Buf buffer)
tewk
committed
{
uint16_t uint16_tmp;
tewk
committed
safe_unpackstr_xmalloc(&part->name, &uint16_tmp, buffer);
tewk
committed
if (part->name == NULL)
part->name = xmalloc(1); /* part->name = "" implicit */
safe_unpack32(&part->max_time, buffer);
safe_unpack32(&part->max_nodes, buffer);
safe_unpack32(&part->min_nodes, buffer);
safe_unpack32(&part->total_nodes, buffer);
safe_unpack32(&part->total_cpus, buffer);
safe_unpack16(&part->default_part, buffer);
safe_unpack16(&part->root_only, buffer);
safe_unpack16(&part->shared, buffer);
safe_unpack16(&part->state_up, buffer);
safe_unpackstr_xmalloc(&part->allow_groups, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&part->nodes, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&node_inx_str, &uint16_tmp, buffer);
tewk
committed
if (node_inx_str == NULL)
part->node_inx = bitfmt2int("");
else {
part->node_inx = bitfmt2int(node_inx_str);
node_inx_str = NULL;
return SLURM_SUCCESS;
xfree(part->name);
xfree(part->allow_groups);
xfree(part->nodes);
xfree(node_inx_str);
return SLURM_ERROR;
tewk
committed
}
/* pack_job_step_info_members
* pack selected fields of the description of a job into a buffer
* IN job_id, step_id, user_id, start_time, partition, nodes - job info
* IN/OUT buffer - destination of the pack, contains pointers that are
* automatically updated
*/
void
pack_job_step_info_members(uint32_t job_id, uint16_t step_id,
uint32_t user_id, uint32_t num_tasks,
time_t start_time, char *partition,
char *nodes, Buf buffer)
pack32(job_id, buffer);
pack16(step_id, buffer);
pack32(user_id, buffer);
pack32(num_tasks, buffer);
pack_time(start_time, buffer);
packstr(partition, buffer);
packstr(nodes, buffer);
/* pack_job_step_info
* packs a slurm job steps info
* IN step - pointer to the job step info
* IN/OUT buffer - destination of the pack, contains pointers that are
* automatically updated
*/
void
pack_job_step_info(job_step_info_t * step, Buf buffer)
pack_job_step_info_members(step->job_id,
step->step_id,
step->user_id,
step->num_tasks,
step->start_time,
step->partition, step->nodes, buffer);
/* _unpack_job_step_info_members
* unpacks a set of slurm job step info for one job step
* OUT step - pointer to the job step info buffer
* IN/OUT buffer - source of the unpack, contains pointers that are
* automatically updated
*/
static int
_unpack_job_step_info_members(job_step_info_t * step, Buf buffer)
{
uint16_t uint16_tmp = 0;
safe_unpack32(&step->job_id, buffer);
safe_unpack16(&step->step_id, buffer);
safe_unpack32(&step->user_id, buffer);
safe_unpack32(&step->num_tasks, buffer);
safe_unpack_time(&step->start_time, buffer);
safe_unpackstr_xmalloc(&step->partition, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&step->nodes, &uint16_tmp, buffer);
return SLURM_SUCCESS;
xfree(step->partition);
xfree(step->nodes);
return SLURM_ERROR;
static int
_unpack_job_step_info_response_msg(job_step_info_response_msg_t
** msg, Buf buffer)
int i = 0;
job_step_info_t *step;
*msg = xmalloc(sizeof(job_step_info_response_msg_t));
safe_unpack_time(&(*msg)->last_update, buffer);
safe_unpack32(&(*msg)->job_step_count, buffer);
step = (*msg)->job_steps =
xmalloc(sizeof(job_step_info_t) * (*msg)->job_step_count);
for (i = 0; i < (*msg)->job_step_count; i++)
if (_unpack_job_step_info_members(&step[i], buffer))
goto unpack_error;
return SLURM_SUCCESS;
xfree(step);
xfree(*msg);
*msg = NULL;
return SLURM_ERROR;
static void
_pack_buffer_msg(slurm_msg_t * msg, Buf buffer)
packmem_array(msg->data, msg->data_size, buffer);
static int
_unpack_job_info_msg(job_info_msg_t ** msg, Buf buffer)
job_info_t *job = NULL;
*msg = xmalloc(sizeof(job_info_msg_t));
/* load buffer's header (data structure version and time) */
safe_unpack32(&((*msg)->record_count), buffer);
safe_unpack_time(&((*msg)->last_update), buffer);
job = (*msg)->job_array =
xmalloc(sizeof(job_info_t) * (*msg)->record_count);
for (i = 0; i < (*msg)->record_count; i++) {
if (_unpack_job_info_members(&job[i], buffer))
goto unpack_error;
return SLURM_SUCCESS;
xfree(job);
xfree(*msg);
*msg = NULL;
/* _unpack_job_info_members
* unpacks a set of slurm job info for one job
* OUT job - pointer to the job info buffer
* IN/OUT buffer - source of the unpack, contains pointers that are
* automatically updated
*/
static int
_unpack_job_info_members(job_info_t * job, Buf buffer)
safe_unpack32(&job->job_id, buffer);
safe_unpack32(&job->user_id, buffer);
safe_unpack16(&job->job_state, buffer);
safe_unpack16(&job->batch_flag, buffer);
safe_unpack32(&job->alloc_sid, buffer);
safe_unpack32(&job->time_limit, buffer);
safe_unpack_time(&job->start_time, buffer);
safe_unpack_time(&job->end_time, buffer);
safe_unpack32(&job->priority, buffer);
safe_unpackstr_xmalloc(&job->nodes, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job->partition, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job->name, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job->alloc_node, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&node_inx_str, &uint16_tmp, buffer);
job->node_inx = bitfmt2int("");
else {
job->node_inx = bitfmt2int(node_inx_str);
safe_unpack32(&job->num_procs, buffer);
safe_unpack32(&job->num_nodes, buffer);
safe_unpack16(&job->shared, buffer);
safe_unpack16(&job->contiguous, buffer);
safe_unpack32(&job->min_procs, buffer);
safe_unpack32(&job->min_memory, buffer);
safe_unpack32(&job->min_tmp_disk, buffer);
safe_unpackstr_xmalloc(&job->req_nodes, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&node_inx_str, &uint16_tmp, buffer);
job->req_node_inx = bitfmt2int("");
else {
safe_unpackstr_xmalloc(&job->exc_nodes, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&node_inx_str, &uint16_tmp, buffer);
if (node_inx_str == NULL)
job->exc_node_inx = bitfmt2int("");
else {
job->exc_node_inx = bitfmt2int(node_inx_str);
xfree(node_inx_str);
}
safe_unpackstr_xmalloc(&job->features, &uint16_tmp, buffer);
return SLURM_SUCCESS;
xfree(job->nodes);
xfree(job->partition);
xfree(job->name);
xfree(job->req_nodes);
xfree(job->exc_nodes);
}
static void
_pack_slurm_ctl_conf_msg(slurm_ctl_conf_info_msg_t * build_ptr, Buf buffer)
{
pack_time(build_ptr->last_update, buffer);
packstr(build_ptr->authtype, buffer);
packstr(build_ptr->backup_addr, buffer);
packstr(build_ptr->backup_controller, buffer);
packstr(build_ptr->control_addr, buffer);
packstr(build_ptr->control_machine, buffer);
packstr(build_ptr->epilog, buffer);
pack16(build_ptr->fast_schedule, buffer);
pack32(build_ptr->first_job_id, buffer);
pack16(build_ptr->hash_base, buffer);
pack16(build_ptr->heartbeat_interval, buffer);
pack16(build_ptr->inactive_limit, buffer);
packstr(build_ptr->job_comp_loc, buffer);
packstr(build_ptr->job_comp_type, buffer);
pack16(build_ptr->kill_wait, buffer);
pack16(build_ptr->max_job_cnt, buffer);
pack16(build_ptr->min_job_age, buffer);
packstr(build_ptr->plugindir, buffer);
packstr(build_ptr->prolog, buffer);
pack16(build_ptr->ret2service, buffer);
packstr(build_ptr->schedauth, buffer);
pack16(build_ptr->schedport, buffer);
packstr(build_ptr->schedtype, buffer);
pack16(build_ptr->slurm_user_id, buffer);
packstr(build_ptr->slurm_user_name, buffer);
pack16(build_ptr->slurmctld_debug, buffer);
packstr(build_ptr->slurmctld_logfile, buffer);
packstr(build_ptr->slurmctld_pidfile, buffer);
pack32(build_ptr->slurmctld_port, buffer);
pack16(build_ptr->slurmctld_timeout, buffer);
pack16(build_ptr->slurmd_debug, buffer);
packstr(build_ptr->slurmd_logfile, buffer);
packstr(build_ptr->slurmd_pidfile, buffer);
pack32(build_ptr->slurmd_port, buffer);
packstr(build_ptr->slurmd_spooldir, buffer);
pack16(build_ptr->slurmd_timeout, buffer);
packstr(build_ptr->slurm_conf, buffer);
packstr(build_ptr->state_save_location, buffer);
packstr(build_ptr->switch_type, buffer);
packstr(build_ptr->tmp_fs, buffer);
pack16(build_ptr->wait_time, buffer);
packstr(build_ptr->job_credential_private_key, buffer);
packstr(build_ptr->job_credential_public_certificate, buffer);
}
static int
_unpack_slurm_ctl_conf_msg(slurm_ctl_conf_info_msg_t **
build_buffer_ptr, Buf buffer)
{
uint16_t uint16_tmp;
slurm_ctl_conf_info_msg_t *build_ptr;
/* alloc memory for structure */
build_ptr = xmalloc(sizeof(slurm_ctl_conf_t));
*build_buffer_ptr = build_ptr;
/* load the data values */
/* unpack timestamp of snapshot */
safe_unpack_time(&build_ptr->last_update, buffer);
safe_unpackstr_xmalloc(&build_ptr->authtype, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->backup_addr, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->backup_controller, &uint16_tmp,
buffer);
safe_unpackstr_xmalloc(&build_ptr->control_addr, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->control_machine, &uint16_tmp,
buffer);
safe_unpackstr_xmalloc(&build_ptr->epilog, &uint16_tmp, buffer);
safe_unpack16(&build_ptr->fast_schedule, buffer);
safe_unpack32(&build_ptr->first_job_id, buffer);
safe_unpack16(&build_ptr->hash_base, buffer);
safe_unpack16(&build_ptr->heartbeat_interval, buffer);
safe_unpack16(&build_ptr->inactive_limit, buffer);
safe_unpackstr_xmalloc(&build_ptr->job_comp_loc, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->job_comp_type, &uint16_tmp, buffer);
safe_unpack16(&build_ptr->kill_wait, buffer);
safe_unpack16(&build_ptr->max_job_cnt, buffer);
safe_unpack16(&build_ptr->min_job_age, buffer);
safe_unpackstr_xmalloc(&build_ptr->plugindir, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->prolog, &uint16_tmp, buffer);
safe_unpack16(&build_ptr->ret2service, buffer);
safe_unpackstr_xmalloc(&build_ptr->schedauth, &uint16_tmp, buffer);
safe_unpack16(&build_ptr->schedport, buffer);
safe_unpackstr_xmalloc(&build_ptr->schedtype, &uint16_tmp, buffer);
safe_unpack16(&build_ptr->slurm_user_id, buffer);
safe_unpackstr_xmalloc(&build_ptr->slurm_user_name,
&uint16_tmp, buffer);
safe_unpack16(&build_ptr->slurmctld_debug, buffer);
safe_unpackstr_xmalloc(&build_ptr->slurmctld_logfile,
&uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->slurmctld_pidfile,
&uint16_tmp, buffer);
safe_unpack32(&build_ptr->slurmctld_port, buffer);
safe_unpack16(&build_ptr->slurmctld_timeout, buffer);
safe_unpack16(&build_ptr->slurmd_debug, buffer);
safe_unpackstr_xmalloc(&build_ptr->slurmd_logfile, &uint16_tmp,
buffer);
safe_unpackstr_xmalloc(&build_ptr->slurmd_pidfile, &uint16_tmp,
buffer);
safe_unpack32(&build_ptr->slurmd_port, buffer);
safe_unpackstr_xmalloc(&build_ptr->slurmd_spooldir, &uint16_tmp,
buffer);
safe_unpack16(&build_ptr->slurmd_timeout, buffer);
safe_unpackstr_xmalloc(&build_ptr->slurm_conf, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->state_save_location,
&uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->switch_type, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->tmp_fs, &uint16_tmp, buffer);
safe_unpack16(&build_ptr->wait_time, buffer);
safe_unpackstr_xmalloc(&build_ptr->job_credential_private_key,
&uint16_tmp, buffer);
safe_unpackstr_xmalloc(&build_ptr->
job_credential_public_certificate,
&uint16_tmp, buffer);
return SLURM_SUCCESS;
xfree(build_ptr->authtype);
xfree(build_ptr->backup_addr);
xfree(build_ptr->backup_controller);
xfree(build_ptr->control_addr);
xfree(build_ptr->control_machine);
xfree(build_ptr->epilog);
xfree(build_ptr->job_comp_loc);
xfree(build_ptr->job_comp_type);
xfree(build_ptr->plugindir);
xfree(build_ptr->prolog);
xfree(build_ptr->slurmctld_logfile);
xfree(build_ptr->slurmctld_pidfile);
xfree(build_ptr->slurmd_logfile);
xfree(build_ptr->slurmd_pidfile);
xfree(build_ptr->slurmd_spooldir);
xfree(build_ptr->slurm_conf);
xfree(build_ptr->state_save_location);
xfree(build_ptr->tmp_fs);
xfree(build_ptr->job_credential_private_key);
xfree(build_ptr->job_credential_public_certificate);
xfree(build_ptr);
*build_buffer_ptr = NULL;
return SLURM_ERROR;
/* _pack_job_desc_msg
* IN job_desc_ptr - pointer to the job descriptor to pack
* IN/OUT buffer - destination of the pack, contains pointers that are
static void
_pack_job_desc_msg(job_desc_msg_t * job_desc_ptr, Buf buffer)
{
/* load the data values */
pack16(job_desc_ptr->contiguous, buffer);
pack16(job_desc_ptr->kill_on_node_fail, buffer);
packstr(job_desc_ptr->features, buffer);
pack32(job_desc_ptr->job_id, buffer);
packstr(job_desc_ptr->name, buffer);
packstr(job_desc_ptr->alloc_node, buffer);
pack32(job_desc_ptr->alloc_sid, buffer);
pack32(job_desc_ptr->min_procs, buffer);
pack32(job_desc_ptr->min_memory, buffer);
pack32(job_desc_ptr->min_tmp_disk, buffer);
packstr(job_desc_ptr->partition, buffer);
pack32(job_desc_ptr->priority, buffer);
packstr(job_desc_ptr->req_nodes, buffer);
packstr(job_desc_ptr->exc_nodes, buffer);
packstr_array(job_desc_ptr->environment, job_desc_ptr->env_size,
buffer);
packstr(job_desc_ptr->script, buffer);
packstr_array(job_desc_ptr->argv, job_desc_ptr->argc, buffer);
packstr(job_desc_ptr->err, buffer);
packstr(job_desc_ptr->in, buffer);
packstr(job_desc_ptr->out, buffer);
packstr(job_desc_ptr->work_dir, buffer);
pack16(job_desc_ptr->immediate, buffer);
pack16(job_desc_ptr->shared, buffer);
pack16(job_desc_ptr->task_dist, buffer);
pack32(job_desc_ptr->time_limit, buffer);
pack32(job_desc_ptr->num_procs, buffer);
pack32(job_desc_ptr->min_nodes, buffer);
pack32(job_desc_ptr->max_nodes, buffer);
pack32(job_desc_ptr->num_tasks, buffer);
pack32(job_desc_ptr->user_id, buffer);
pack16(job_desc_ptr->port, buffer);
packstr(job_desc_ptr->host, buffer);
/* _unpack_job_desc_msg
* OUT job_desc_buffer_ptr - place to put pointer to allocated job desc struct
* IN/OUT buffer - source of the unpack, contains pointers that are
static int
_unpack_job_desc_msg(job_desc_msg_t ** job_desc_buffer_ptr, Buf buffer)
{
job_desc_msg_t *job_desc_ptr;
/* alloc memory for structure */
job_desc_ptr = xmalloc(sizeof(job_desc_msg_t));
*job_desc_buffer_ptr = job_desc_ptr;
/* load the data values */
safe_unpack16(&job_desc_ptr->contiguous, buffer);
safe_unpack16(&job_desc_ptr->kill_on_node_fail, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->features, &uint16_tmp, buffer);
safe_unpack32(&job_desc_ptr->job_id, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->name, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->alloc_node, &uint16_tmp, buffer);
safe_unpack32(&job_desc_ptr->alloc_sid, buffer);
safe_unpack32(&job_desc_ptr->min_procs, buffer);
safe_unpack32(&job_desc_ptr->min_memory, buffer);
safe_unpack32(&job_desc_ptr->min_tmp_disk, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->partition, &uint16_tmp, buffer);
safe_unpack32(&job_desc_ptr->priority, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->req_nodes, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->exc_nodes, &uint16_tmp, buffer);
safe_unpackstr_array(&job_desc_ptr->environment,
&job_desc_ptr->env_size, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->script, &uint16_tmp, buffer);
safe_unpackstr_array(&job_desc_ptr->argv, &job_desc_ptr->argc, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->err, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->in, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->out, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->work_dir, &uint16_tmp, buffer);
safe_unpack16(&job_desc_ptr->immediate, buffer);
safe_unpack16(&job_desc_ptr->shared, buffer);
safe_unpack16(&job_desc_ptr->task_dist, buffer);
safe_unpack32(&job_desc_ptr->time_limit, buffer);
safe_unpack32(&job_desc_ptr->num_procs, buffer);
safe_unpack32(&job_desc_ptr->min_nodes, buffer);
safe_unpack32(&job_desc_ptr->max_nodes, buffer);
safe_unpack32(&job_desc_ptr->num_tasks, buffer);
safe_unpack32(&job_desc_ptr->user_id, buffer);
safe_unpack32(&job_desc_ptr->group_id, buffer);
safe_unpack16(&job_desc_ptr->port, buffer);
safe_unpackstr_xmalloc(&job_desc_ptr->host, &uint16_tmp, buffer);
return SLURM_SUCCESS;
unpack_error:
xfree(job_desc_ptr->features);
xfree(job_desc_ptr->name);
xfree(job_desc_ptr->partition);
xfree(job_desc_ptr->req_nodes);
xfree(job_desc_ptr->environment);
xfree(job_desc_ptr->script);
xfree(job_desc_ptr->argv);
xfree(job_desc_ptr->err);
xfree(job_desc_ptr->in);
xfree(job_desc_ptr->out);
xfree(job_desc_ptr->work_dir);
xfree(job_desc_ptr->host);
*job_desc_buffer_ptr = NULL;
return SLURM_ERROR;
}
static void
_pack_old_job_desc_msg(old_job_alloc_msg_t * job_desc_ptr, Buf buffer)
{
/* load the data values */
pack32(job_desc_ptr->job_id, buffer);
pack32(job_desc_ptr->uid, buffer);
static int
_unpack_old_job_desc_msg(old_job_alloc_msg_t **
job_desc_buffer_ptr, Buf buffer)
{
old_job_alloc_msg_t *job_desc_ptr;
/* alloc memory for structure */
assert(job_desc_buffer_ptr != NULL);
job_desc_ptr = xmalloc(sizeof(old_job_alloc_msg_t));
*job_desc_buffer_ptr = job_desc_ptr;
/* load the data values */
safe_unpack32(&job_desc_ptr->job_id, buffer);
safe_unpack32(&job_desc_ptr->uid, buffer);
return SLURM_SUCCESS;
*job_desc_buffer_ptr = NULL;
return SLURM_ERROR;
static void
_pack_last_update_msg(last_update_msg_t * msg, Buf buffer)
{
pack_time(msg->last_update, buffer);
}
static int
_unpack_last_update_msg(last_update_msg_t ** msg, Buf buffer)
{
last_update_msg_t *last_update_msg;
last_update_msg = xmalloc(sizeof(last_update_msg_t));
*msg = last_update_msg;
safe_unpack_time(&last_update_msg->last_update, buffer);
return SLURM_SUCCESS;
*msg = NULL;
return SLURM_ERROR;
static void
_pack_return_code_msg(return_code_msg_t * msg, Buf buffer)
pack32(msg->return_code, buffer);
static int
_unpack_return_code_msg(return_code_msg_t ** msg, Buf buffer)
return_code_msg_t *return_code_msg;
return_code_msg = xmalloc(sizeof(return_code_msg_t));
*msg = return_code_msg;
safe_unpack32(&return_code_msg->return_code, buffer);
return SLURM_SUCCESS;
*msg = NULL;
return SLURM_ERROR;
static void
_pack_reattach_tasks_request_msg(reattach_tasks_request_msg_t * msg,
Buf buffer)
pack32(msg->job_id, buffer);
pack32(msg->job_step_id, buffer);
pack32(msg->srun_node_id, buffer);
pack16(msg->resp_port, buffer);
pack16(msg->io_port, buffer);
packstr(msg->ofname, buffer);
packstr(msg->efname, buffer);
packstr(msg->ifname, buffer);
slurm_cred_pack(msg->cred, buffer);
static int
_unpack_reattach_tasks_request_msg(reattach_tasks_request_msg_t ** msg_ptr,
Buf buffer)
reattach_tasks_request_msg_t *msg;
msg = xmalloc(sizeof(*msg));
*msg_ptr = msg;
safe_unpack32(&msg->job_id, buffer);
safe_unpack32(&msg->job_step_id, buffer);
safe_unpack32(&msg->srun_node_id, buffer);
safe_unpack16(&msg->resp_port, buffer);
safe_unpack16(&msg->io_port, buffer);
safe_unpackstr_xmalloc(&msg->ofname, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&msg->efname, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&msg->ifname, &uint16_tmp, buffer);
if (!(msg->cred = slurm_cred_unpack(buffer)))
goto unpack_error;
return SLURM_SUCCESS;
unpack_error:
slurm_free_reattach_tasks_request_msg(msg);
*msg_ptr = NULL;
return SLURM_ERROR;
static void
_pack_reattach_tasks_response_msg(reattach_tasks_response_msg_t * msg,
Buf buffer)
packstr(msg->node_name, buffer);
packstr(msg->executable_name, buffer);
pack32(msg->return_code, buffer);
pack32(msg->srun_node_id, buffer);
pack32(msg->ntasks, buffer);
pack32_array(msg->gids, msg->ntasks, buffer);
pack32_array(msg->local_pids, msg->ntasks, buffer);
static int
_unpack_reattach_tasks_response_msg(reattach_tasks_response_msg_t ** msg_ptr,
Buf buffer)
uint32_t ntasks;
uint16_t uint16_tmp;
reattach_tasks_response_msg_t *msg = xmalloc(sizeof(*msg));
*msg_ptr = msg;
safe_unpackstr_xmalloc(&msg->node_name, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&msg->executable_name, &uint16_tmp, buffer);
safe_unpack32(&msg->return_code, buffer);
safe_unpack32(&msg->srun_node_id, buffer);
safe_unpack32(&msg->ntasks, buffer);
safe_unpack32_array(&msg->gids, &ntasks, buffer);
safe_unpack32_array(&msg->local_pids, &ntasks, buffer);
if (msg->ntasks != ntasks)
goto unpack_error;
unpack_error:
slurm_free_reattach_tasks_response_msg(msg);
*msg_ptr = NULL;
return SLURM_ERROR;
}
static void
_pack_task_exit_msg(task_exit_msg_t * msg, Buf buffer)
{
pack32(msg->return_code, buffer);
pack32(msg->num_tasks, buffer);
pack32_array(msg->task_id_list,
msg->num_tasks, buffer);
static int
_unpack_task_exit_msg(task_exit_msg_t ** msg_ptr, Buf buffer)
{
task_exit_msg_t *msg;
uint32_t uint32_tmp;
msg = xmalloc(sizeof(task_exit_msg_t));
*msg_ptr = msg;
safe_unpack32(&msg->return_code, buffer);
safe_unpack32(&msg->num_tasks, buffer);
safe_unpack32_array(&msg->task_id_list, &uint32_tmp, buffer);
if (msg->num_tasks != uint32_tmp)
goto unpack_error;
*msg_ptr = NULL;
return SLURM_ERROR;
}
static void
_pack_launch_tasks_response_msg(launch_tasks_response_msg_t * msg, Buf buffer)
pack32(msg->return_code, buffer);
packstr(msg->node_name, buffer);
pack32(msg->srun_node_id, buffer);
pack32(msg->count_of_pids, buffer);
pack32_array(msg->local_pids,
msg->count_of_pids, buffer);
static int
_unpack_launch_tasks_response_msg(launch_tasks_response_msg_t **
msg_ptr, Buf buffer)
{
uint16_t uint16_tmp;
uint32_t uint32_tmp;
launch_tasks_response_msg_t *msg;
msg = xmalloc(sizeof(launch_tasks_response_msg_t));
*msg_ptr = msg;
safe_unpack32(&msg->return_code, buffer);
safe_unpackstr_xmalloc(&msg->node_name, &uint16_tmp, buffer);
safe_unpack32(&msg->srun_node_id, buffer);
safe_unpack32(&msg->count_of_pids, buffer);
safe_unpack32_array(&msg->local_pids, &uint32_tmp, buffer);
if (msg->count_of_pids != uint32_tmp)
goto unpack_error;
xfree(msg->node_name);
xfree(msg);
*msg_ptr = NULL;
return SLURM_ERROR;
}
static void
_pack_launch_tasks_request_msg(launch_tasks_request_msg_t * msg, Buf buffer)
{
pack32(msg->job_id, buffer);
pack32(msg->job_step_id, buffer);
pack32(msg->nnodes, buffer);
pack32(msg->nprocs, buffer);
pack32(msg->uid, buffer);
pack32(msg->srun_node_id, buffer);
slurm_cred_pack(msg->cred, buffer);
pack32(msg->tasks_to_launch, buffer);
packstr_array(msg->env, msg->envc, buffer);
packstr(msg->cwd, buffer);
packstr_array(msg->argv, msg->argc, buffer);
pack16(msg->resp_port, buffer);
pack16(msg->io_port, buffer);
pack16(msg->task_flags, buffer);
pack16(msg->cpus_allocated, buffer);
packstr(msg->ofname, buffer);
packstr(msg->efname, buffer);
packstr(msg->ifname, buffer);
pack32(msg->slurmd_debug, buffer);
pack32_array(msg->global_task_ids,
msg->tasks_to_launch, buffer);
switch_pack_jobinfo(msg->switch_job, buffer);
static int
_unpack_launch_tasks_request_msg(launch_tasks_request_msg_t **
msg_ptr, Buf buffer)
uint32_t uint32_tmp;
launch_tasks_request_msg_t *msg;
msg = xmalloc(sizeof(launch_tasks_request_msg_t));
*msg_ptr = msg;
safe_unpack32(&msg->job_id, buffer);
safe_unpack32(&msg->job_step_id, buffer);
safe_unpack32(&msg->nnodes, buffer);
safe_unpack32(&msg->nprocs, buffer);
safe_unpack32(&msg->uid, buffer);
safe_unpack32(&msg->srun_node_id, buffer);
if (!(msg->cred = slurm_cred_unpack(buffer)))
goto unpack_error;
safe_unpack32(&msg->tasks_to_launch, buffer);
safe_unpackstr_array(&msg->env, &msg->envc, buffer);
safe_unpackstr_xmalloc(&msg->cwd, &uint16_tmp, buffer);
safe_unpackstr_array(&msg->argv, &msg->argc, buffer);
safe_unpack16(&msg->resp_port, buffer);
safe_unpack16(&msg->io_port, buffer);
safe_unpack16(&msg->task_flags, buffer);
safe_unpack16(&msg->cpus_allocated, buffer);
safe_unpackstr_xmalloc(&msg->ofname, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&msg->efname, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&msg->ifname, &uint16_tmp, buffer);
safe_unpack32(&msg->slurmd_debug, buffer);
safe_unpack32_array(&msg->global_task_ids, &uint32_tmp, buffer);
if (msg->tasks_to_launch != uint32_tmp)
goto unpack_error;
switch_alloc_jobinfo(&msg->switch_job);
if (switch_unpack_jobinfo(msg->switch_job, buffer) < 0) {
error("switch_unpack_jobinfo: %m");
switch_free_jobinfo(msg->switch_job);
goto unpack_error;
slurm_free_launch_tasks_request_msg(msg);
*msg_ptr = NULL;
return SLURM_ERROR;
static void
_pack_cancel_tasks_msg(kill_tasks_msg_t * msg, Buf buffer)
pack32(msg->job_id, buffer);
pack32(msg->job_step_id, buffer);
pack32(msg->signal, buffer);
static int
_unpack_cancel_tasks_msg(kill_tasks_msg_t ** msg_ptr, Buf buffer)
msg = xmalloc(sizeof(kill_tasks_msg_t));
*msg_ptr = msg;
safe_unpack32(&msg->job_id, buffer);
safe_unpack32(&msg->job_step_id, buffer);
safe_unpack32(&msg->signal, buffer);
return SLURM_SUCCESS;
*msg_ptr = NULL;
return SLURM_ERROR;
static void
_pack_shutdown_msg(shutdown_msg_t * msg, Buf buffer)
Moe Jette
committed
{
Moe Jette
committed
}
static int
_unpack_shutdown_msg(shutdown_msg_t ** msg_ptr, Buf buffer)
Moe Jette
committed
{
Moe Jette
committed
msg = xmalloc(sizeof(shutdown_msg_t));
*msg_ptr = msg;
safe_unpack16(&msg->core, buffer);
return SLURM_SUCCESS;
*msg_ptr = NULL;
return SLURM_ERROR;
Moe Jette
committed
}
/* _pack_job_step_id_msg
* packs a slurm job step id
* IN msg - pointer to the job step id (contains job_id and job_step_id)
* IN/OUT buffer - destination of the pack, contains pointers that are
* automatically updated
*/
static void
_pack_job_step_id_msg(job_step_id_t * msg, Buf buffer)
pack_time(msg->last_update, buffer);
pack32(msg->job_id, buffer);
pack32(msg->job_step_id, buffer);
/* _unpack_job_step_id_msg
* unpacks a slurm job step id
* OUT msg_ptr - pointer to the job step id buffer (contains job_id and
* job_step_id)
* IN/OUT buffer - source of the unpack, contains pointers that are
* automatically updated
*/
static int
_unpack_job_step_id_msg(job_step_id_t ** msg_ptr, Buf buffer)
msg = xmalloc(sizeof(job_step_id_msg_t));
*msg_ptr = msg;
safe_unpack_time(&msg->last_update, buffer);
safe_unpack32(&msg->job_id, buffer);
safe_unpack32(&msg->job_step_id, buffer);
return SLURM_SUCCESS;
*msg_ptr = NULL;
return SLURM_ERROR;
/* _pack_job_step_kill_msg
* packs a slurm job step signal message
* IN msg - pointer to the job step signal message
* IN/OUT buffer - destination of the pack, contains pointers that are
* automatically updated
*/
static void
_pack_job_step_kill_msg(job_step_kill_msg_t * msg, Buf buffer)
{
pack32(msg->job_id, buffer);
pack32(msg->job_step_id, buffer);
pack16(msg->signal, buffer);
pack16(msg->batch_flag, buffer);
}
/* _unpack_job_step_kill_msg
* unpacks a slurm job step signal message
* OUT msg_ptr - pointer to the job step signal message buffer
* IN/OUT buffer - source of the unpack, contains pointers that are
* automatically updated
*/
static int
_unpack_job_step_kill_msg(job_step_kill_msg_t ** msg_ptr, Buf buffer)
{
job_step_kill_msg_t *msg;
msg = xmalloc(sizeof(job_step_kill_msg_t));
*msg_ptr = msg;
safe_unpack32(&msg->job_id, buffer);
safe_unpack32(&msg->job_step_id, buffer);
safe_unpack16(&msg->signal, buffer);
safe_unpack16(&msg->batch_flag, buffer);
return SLURM_SUCCESS;
unpack_error:
*msg_ptr = NULL;
return SLURM_ERROR;
}
static void
_pack_complete_job_step_msg(complete_job_step_msg_t * msg, Buf buffer)
pack32(msg->job_id, buffer);
pack32(msg->job_step_id, buffer);
pack32(msg->job_rc, buffer);
pack32(msg->slurm_rc, buffer);
packstr(msg->node_name, buffer);
static int
_unpack_complete_job_step_msg(complete_job_step_msg_t ** msg_ptr, Buf buffer)
complete_job_step_msg_t *msg;
uint16_t uint16_tmp;
msg = xmalloc(sizeof(complete_job_step_msg_t));
*msg_ptr = msg;
safe_unpack32(&msg->job_id, buffer);
safe_unpack32(&msg->job_step_id, buffer);
safe_unpack32(&msg->job_rc, buffer);
safe_unpack32(&msg->slurm_rc, buffer);
safe_unpackstr_xmalloc(&msg->node_name, &uint16_tmp, buffer);
return SLURM_SUCCESS;
*msg_ptr = NULL;
return SLURM_ERROR;
}
static void
_pack_get_job_step_info_msg(job_step_info_request_msg_t * msg, Buf buffer)
pack_time(msg->last_update, buffer);
pack32(msg->job_id, buffer);
pack32(msg->step_id, buffer);
static int
_unpack_get_job_step_info_msg(job_step_info_request_msg_t ** msg, Buf buffer)
job_step_info_request_msg_t *job_step_info;
job_step_info = xmalloc(sizeof(job_step_info_request_msg_t));
*msg = job_step_info;
safe_unpack_time(&job_step_info->last_update, buffer);
safe_unpack32(&job_step_info->job_id, buffer);
safe_unpack32(&job_step_info->step_id, buffer);
return SLURM_SUCCESS;
unpack_error:
*msg = NULL;
return SLURM_ERROR;
static void
_pack_slurm_addr_array(slurm_addr * slurm_address,
uint16_t size_val, Buf buffer)
uint16_t nl = htons(size_val);
for (i = 0; i < size_val; i++) {
slurm_pack_slurm_addr(slurm_address + i, buffer);
static int
_unpack_slurm_addr_array(slurm_addr ** slurm_address,
uint16_t * size_val, Buf buffer)
*slurm_address = NULL;
safe_unpack16(&nl, buffer);
*size_val = ntohs(nl);
*slurm_address = xmalloc((*size_val) * sizeof(slurm_addr));
for (i = 0; i < *size_val; i++) {
if (slurm_unpack_slurm_addr_no_alloc((*slurm_address) + i,
buffer))
goto unpack_error;
return SLURM_SUCCESS;
*slurm_address = NULL;
return SLURM_ERROR;
static void
_pack_batch_job_launch_msg(batch_job_launch_msg_t * msg, Buf buffer)
pack32(msg->job_id, buffer);
pack32(msg->uid, buffer);
packstr(msg->nodes, buffer);
packstr(msg->script, buffer);
packstr(msg->work_dir, buffer);
packstr(msg->err, buffer);
packstr(msg->in, buffer);
packstr(msg->out, buffer);
pack16(msg->argc, buffer);
packstr_array(msg->argv, msg->argc, buffer);
pack16(msg->envc, buffer);
packstr_array(msg->environment, msg->envc, buffer);
static int
_unpack_batch_job_launch_msg(batch_job_launch_msg_t ** msg, Buf buffer)
{
uint16_t uint16_tmp;
batch_job_launch_msg_t *launch_msg_ptr;
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
assert(msg != NULL);
launch_msg_ptr = xmalloc(sizeof(batch_job_launch_msg_t));
*msg = launch_msg_ptr;
safe_unpack32(&launch_msg_ptr->job_id, buffer);
safe_unpack32(&launch_msg_ptr->uid, buffer);
safe_unpackstr_xmalloc(&launch_msg_ptr->nodes, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&launch_msg_ptr->script, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&launch_msg_ptr->work_dir, &uint16_tmp,
buffer);
safe_unpackstr_xmalloc(&launch_msg_ptr->err, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&launch_msg_ptr->in, &uint16_tmp, buffer);
safe_unpackstr_xmalloc(&launch_msg_ptr->out, &uint16_tmp, buffer);
safe_unpack16(&launch_msg_ptr->argc, buffer);
safe_unpackstr_array(&launch_msg_ptr->argv,
&launch_msg_ptr->argc, buffer);
safe_unpack16(&launch_msg_ptr->envc, buffer);
safe_unpackstr_array(&launch_msg_ptr->environment,
&launch_msg_ptr->envc, buffer);
return SLURM_SUCCESS;
xfree(launch_msg_ptr->nodes);
xfree(launch_msg_ptr->script);
xfree(launch_msg_ptr->work_dir);
xfree(launch_msg_ptr->err);
xfree(launch_msg_ptr->in);
xfree(launch_msg_ptr->out);
xfree(launch_msg_ptr->argv);
xfree(launch_msg_ptr->environment);
xfree(launch_msg_ptr);
*msg = NULL;
return SLURM_ERROR;
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
static void
_pack_job_id_request_msg(job_id_request_msg_t * msg, Buf buffer)
{
assert(msg != NULL);
pack32(msg->job_pid, buffer);
}
static int
_unpack_job_id_request_msg(job_id_request_msg_t ** msg, Buf buffer)
{
job_id_request_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(job_id_request_msg_t));
*msg = tmp_ptr;
/* load the data values */
safe_unpack32(&tmp_ptr->job_pid, buffer);
return SLURM_SUCCESS;
unpack_error:
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
*msg = NULL;
return SLURM_ERROR;
}
static void
_pack_job_id_response_msg(job_id_response_msg_t * msg, Buf buffer)
{
assert(msg != NULL);
pack32(msg->job_id, buffer);
}
static int
_unpack_job_id_response_msg(job_id_response_msg_t ** msg, Buf buffer)
{
job_id_response_msg_t *tmp_ptr;
/* alloc memory for structure */
assert(msg != NULL);
tmp_ptr = xmalloc(sizeof(job_id_response_msg_t));
*msg = tmp_ptr;
/* load the data values */
safe_unpack32(&tmp_ptr->job_id, buffer);
return SLURM_SUCCESS;
unpack_error:
*msg = NULL;
return SLURM_ERROR;
}
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
static void
_pack_srun_ping_msg(srun_ping_msg_t * msg, Buf buffer)
{
assert ( msg != NULL );
pack32 ( msg ->job_id , buffer ) ;
pack32 ( msg ->step_id , buffer ) ;
}
static int
_unpack_srun_ping_msg(srun_ping_msg_t ** msg_ptr, Buf buffer)
{
srun_ping_msg_t * msg;
assert ( msg_ptr != NULL );
msg = xmalloc ( sizeof (srun_ping_msg_t) ) ;
*msg_ptr = msg;
safe_unpack32 ( & msg->job_id , buffer ) ;
safe_unpack32 ( & msg->step_id , buffer ) ;
return SLURM_SUCCESS;
unpack_error:
*msg_ptr = NULL;
xfree(msg);
return SLURM_ERROR;
}
static void
_pack_srun_node_fail_msg(srun_node_fail_msg_t * msg, Buf buffer)
{
assert ( msg != NULL );
pack32 ( msg ->job_id , buffer ) ;
pack32 ( msg ->step_id , buffer ) ;
packstr ( msg ->nodelist, buffer ) ;
}
static int
_unpack_srun_node_fail_msg(srun_node_fail_msg_t ** msg_ptr, Buf buffer)
{
uint16_t uint16_tmp;
srun_node_fail_msg_t * msg;
assert ( msg_ptr != NULL );
msg = xmalloc ( sizeof (srun_node_fail_msg_t) ) ;
*msg_ptr = msg;
safe_unpack32 ( & msg->job_id , buffer ) ;
safe_unpack32 ( & msg->step_id , buffer ) ;
safe_unpackstr_xmalloc ( & msg->nodelist, &uint16_tmp, buffer);
return SLURM_SUCCESS;
unpack_error:
*msg_ptr = NULL;
xfree( msg->nodelist );
xfree( msg );
return SLURM_ERROR;
}
static void
_pack_srun_timeout_msg(srun_timeout_msg_t * msg, Buf buffer)
{
assert ( msg != NULL );
pack32 ( msg -> job_id , buffer ) ;
pack32 ( msg -> step_id , buffer ) ;
pack_time ( msg -> timeout, buffer );
}
static int
_unpack_srun_timeout_msg(srun_timeout_msg_t ** msg_ptr, Buf buffer)
{
srun_timeout_msg_t * msg;
assert ( msg_ptr != NULL );
msg = xmalloc ( sizeof (srun_timeout_msg_t) ) ;
*msg_ptr = msg ;
safe_unpack32 ( & msg -> job_id , buffer ) ;
safe_unpack32 ( & msg -> step_id , buffer ) ;
safe_unpack_time ( & msg -> timeout , buffer );
return SLURM_SUCCESS;
unpack_error:
*msg_ptr = NULL;
xfree(msg);
return SLURM_ERROR;
}
void pack_ ( * msg , Buf buffer )
assert ( msg != NULL );
pack16 ( msg -> , buffer ) ;
pack32 ( msg -> , buffer ) ;
packstr ( msg -> , buffer ) ;
int unpack_ ( ** msg_ptr , Buf buffer )
uint16_t uint16_tmp;
assert ( msg_ptr != NULL );
msg = xmalloc ( sizeof ( ) ) ;
*msg_ptr = msg;
safe_unpack16 ( & msg -> , buffer ) ;
safe_unpack32 ( & msg -> , buffer ) ;
safe_unpackstr_xmalloc ( & msg -> x, & uint16_tmp , buffer ) ;
return SLURM_SUCCESS;
unpack_error:
xfree(msg -> x);
xfree(msg);
*msg_ptr = NULL;
return SLURM_ERROR;