diff --git a/slurm/slurm.h.in b/slurm/slurm.h.in
index 6c68a2c013c7a3d759a0e129d04111eba2dd2be7..ab0236c263fbee3f32396c460d5d667d01cdf5cd 100644
--- a/slurm/slurm.h.in
+++ b/slurm/slurm.h.in
@@ -1388,6 +1388,7 @@ typedef struct job_descriptor {	/* For submit, allocate, and update requests */
 	char *gres;		/* comma separated list of required generic
 				 * resources, default NONE */
 	uint32_t group_id;	/* group to assume, if run as root. */
+	uint32_t group_number;  /* jobpack group number index */
 	uint16_t immediate;	/* 1 if allocate to run or fail immediately,
 				 * 0 if to be queued awaiting resources */
 	uint32_t job_id;	/* job ID, default set by SLURM */
@@ -1404,14 +1405,19 @@ typedef struct job_descriptor {	/* For submit, allocate, and update requests */
 	char *network;		/* network use spec */
 	uint32_t nice;		/* requested priority change,
 				 * NICE_OFFSET == no change */
+	uint32_t numpack;       /* number of jobpack jobs */
 	uint32_t num_tasks;	/* number of tasks to be started,
 				 * for batch only */
 	uint8_t open_mode;	/* out/err open mode truncate or append,
 				 * see OPEN_MODE_* */
 	uint16_t other_port;	/* port to send various notification msg to */
 	uint8_t overcommit;	/* over subscribe resources, for batch only */
+	uint32_t pack_leader;	/* job_id of pack_leader for job_pack or 0 */
 	char *partition;	/* name of requested partition,
 				 * default in SLURM config */
+	char **pelog_env;	/* other environment variables for job
+				   prolog/epilog */
+	uint32_t pelog_env_size;/* element count in pelog_env */
 	uint16_t plane_size;	/* plane size when task_dist =
 				   SLURM_DIST_PLANE */
 	uint8_t power_flags;	/* power management flags,
@@ -1423,6 +1429,7 @@ typedef struct job_descriptor {	/* For submit, allocate, and update requests */
 	char *qos;		/* Quality of Service */
 	uint16_t reboot;	/* force node reboot before startup */
 	char *resp_host;	/* NOTE: Set by slurmctld */
+	uint8_t resv_port;      /* jobpack resv-port for nodes flag */
 	char *req_nodes;	/* comma separated list of required nodes
 				 * default NONE */
 	uint16_t requeue;	/* enable or disable job requeue option */
@@ -1903,6 +1910,8 @@ typedef struct {
 	uint32_t cpu_freq_max;	/* Maximum cpu frequency  */
 	uint32_t cpu_freq_gov;	/* cpu frequency governor */
 	uint32_t num_tasks;	/* number of tasks */
+	uint32_t packjobid; 	 /* jobid of srun first step of the jobpack */
+	uint32_t packstepid; 	 /* stepid of jobpack member */
 	char *partition;	/* name of assigned partition */
 	char *resv_ports;	/* ports allocated for MPI */
 	time_t run_time;	/* net run time (factor out time suspended) */
diff --git a/slurm/slurmdb.h b/slurm/slurmdb.h
index 72360e047a8b442a63131f59e2ef0030239ba9fe..cb1ffb8179259c7c38bdc3767948636acac2873c 100644
--- a/slurm/slurmdb.h
+++ b/slurm/slurmdb.h
@@ -953,6 +953,8 @@ typedef struct {
 	uint32_t nnodes;
 	char *nodes;
 	uint32_t ntasks;
+	uint32_t packjobid;	/* jobid of srun first step of the jobpack */
+	uint32_t packstepid;	/* stepid of jobpack member */
 	char *pid_str;
 	uint32_t req_cpufreq_min;
 	uint32_t req_cpufreq_max;
diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h
index f61e6151d1ad46e88417d832bf8dedfa2c478fcb..e507fba8d43553b480af0868298ecf81a58e3381 100644
--- a/src/common/slurm_protocol_defs.h
+++ b/src/common/slurm_protocol_defs.h
@@ -731,6 +731,8 @@ typedef struct job_step_specs {
 	uint32_t num_tasks;	/* number of tasks required */
 	uint8_t overcommit;     /* flag, 1 to allow overcommit of processors,
 				   0 to disallow overcommit. default is 0 */
+	uint32_t packjobid;	/* jobid of srun first step */
+	uint32_t packstepid;	/* stepid of srun first step */
 	uint16_t plane_size;	/* plane size when task_dist =
 				   SLURM_DIST_PLANE */
 	uint16_t port;		/* port to contact initiating srun */
@@ -767,12 +769,20 @@ typedef struct job_step_create_response_msg {
 typedef struct launch_tasks_request_msg {
 	uint32_t  job_id;
 	uint32_t  job_step_id;
+	uint32_t  mpi_jobid;	/* MPI jobid (same for all steps) */
+	uint32_t  mpi_nnodes;	/* number of MPI nodes in all steps */
+	uint32_t  mpi_ntasks;	/* number of MPI tasks in all steps */
+	uint32_t  mpi_stepfnodeid; /* first MPI nodeid for this step */
+	uint32_t  mpi_stepftaskid; /* first MPI taskid for this step */
+	uint32_t  mpi_stepid;	/* MPI stepid (same for all steps) */
 	uint32_t  nnodes;	/* number of nodes in this job step       */
 	uint32_t  ntasks;	/* number of tasks in this job step   */
 	uint16_t  ntasks_per_board;/* number of tasks to invoke on each board */
 	uint16_t  ntasks_per_core; /* number of tasks to invoke on each core */
 	uint16_t  ntasks_per_socket;/* number of tasks to invoke on
 				     * each socket */
+	uint32_t  packjobid;	/* jobid of srun first step */
+	uint32_t  packstepid;	/* stepid of srun first step */
 	uint32_t  uid;
 	char     *user_name;
 	uint32_t  gid;
@@ -828,6 +838,8 @@ typedef struct launch_tasks_request_msg {
 	job_options_t options;  /* Arbitrary job options */
 	char *complete_nodelist;
 	char *ckpt_dir;		/* checkpoint path */
+	char **pelog_env;       /* prolog/epilog environment vars */
+	uint32_t pelog_env_size;
 	char *restart_dir;	/* restart from checkpoint if set */
 	char **spank_job_env;
 	uint32_t spank_job_env_size;
@@ -939,6 +951,8 @@ typedef struct prolog_launch_msg {
 	uint32_t nnodes;			/* count of nodes, passed via cred */
 	char *nodes;			/* list of nodes allocated to job_step */
 	char *partition;		/* partition the job is running in */
+	char **pelog_env;               /* prolog/epilog environment vars */
+	uint32_t pelog_env_size;
 	dynamic_plugin_data_t *select_jobinfo;	/* opaque data type */
 	char **spank_job_env;		/* SPANK job environment variables */
 	uint32_t spank_job_env_size;	/* size of spank_job_env */
@@ -1007,6 +1021,10 @@ typedef struct batch_job_launch_msg {
 	char **spank_job_env;	/* SPANK job environment variables */
 	uint32_t spank_job_env_size;	/* size of spank_job_env */
 	char *resv_name;        /* job's reservation */
+	char **pelog_env;       /* prolog/epilog environment vars */
+	uint32_t pelog_env_size;
+	char *resv_ports;       /* reserve ports for jobpack nodes */
+	uint32_t group_number;  /* jobpack group number index */
 } batch_job_launch_msg_t;
 
 typedef struct job_id_request_msg {
diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c
index 7beca0624b4093fc9b4a92a65879c04b32124994..c7a8f2b3e943a75743d7702bb6559e4f881ad602 100644
--- a/src/common/slurm_protocol_pack.c
+++ b/src/common/slurm_protocol_pack.c
@@ -4871,6 +4871,8 @@ pack_job_step_create_request_msg(job_step_create_request_msg_t * msg,
 
 		pack16(msg->relative, buffer);
 		pack32(msg->task_dist, buffer);
+		pack32(msg->packjobid, buffer);
+		pack32(msg->packstepid, buffer);
 		pack16(msg->plane_size, buffer);
 		pack16(msg->port, buffer);
 		pack16(msg->ckpt_interval, buffer);
@@ -4955,6 +4957,8 @@ unpack_job_step_create_request_msg(job_step_create_request_msg_t ** msg,
 
 		safe_unpack16(&tmp_ptr->relative, buffer);
 		safe_unpack32(&tmp_ptr->task_dist, buffer);
+		safe_unpack32(&tmp_ptr->packjobid, buffer);
+		safe_unpack32(&tmp_ptr->packstepid, buffer);
 		safe_unpack16(&tmp_ptr->plane_size, buffer);
 		safe_unpack16(&tmp_ptr->port, buffer);
 		safe_unpack16(&tmp_ptr->ckpt_interval, buffer);
@@ -5810,6 +5814,8 @@ _unpack_job_step_info_members(job_step_info_t * step, Buf buffer,
 		safe_unpackstr_xmalloc(&step->tres_alloc_str,
 				       &uint32_tmp, buffer);
 		safe_unpack16(&step->start_protocol_ver, buffer);
+		safe_unpack32(&step->packjobid, buffer);
+		safe_unpack32(&step->packstepid, buffer);
 	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		safe_unpack32(&step->array_job_id, buffer);
 		safe_unpack32(&step->array_task_id, buffer);
@@ -8802,6 +8808,12 @@ _pack_job_desc_msg(job_desc_msg_t * job_desc_ptr, Buf buffer,
 		pack16(job_desc_ptr->wait_all_nodes, buffer);
 		pack32(job_desc_ptr->bitflags, buffer);
 		pack32(job_desc_ptr->delay_boot, buffer);
+		packstr_array(job_desc_ptr->pelog_env,
+			      job_desc_ptr->pelog_env_size, buffer);
+		pack8(job_desc_ptr->resv_port, buffer);
+		pack32(job_desc_ptr->group_number, buffer);
+		pack32(job_desc_ptr->numpack, buffer);
+		pack32(job_desc_ptr->pack_leader, buffer);
 	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		packstr(job_desc_ptr->clusters, buffer);
 		pack16(job_desc_ptr->contiguous, buffer);
@@ -9306,6 +9318,13 @@ _unpack_job_desc_msg(job_desc_msg_t ** job_desc_buffer_ptr, Buf buffer,
 		safe_unpack16(&job_desc_ptr->wait_all_nodes, buffer);
 		safe_unpack32(&job_desc_ptr->bitflags, buffer);
 		safe_unpack32(&job_desc_ptr->delay_boot, buffer);
+		safe_unpackstr_array(&job_desc_ptr->pelog_env,
+				     &job_desc_ptr->pelog_env_size,
+				     buffer);
+		safe_unpack8(&job_desc_ptr->resv_port, buffer);
+		safe_unpack32(&job_desc_ptr->group_number, buffer);
+		safe_unpack32(&job_desc_ptr->numpack, buffer);
+		safe_unpack32(&job_desc_ptr->pack_leader, buffer);
 	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		uint32_t tmp_mem;
 		job_desc_ptr = xmalloc(sizeof(job_desc_msg_t));
@@ -10000,10 +10019,18 @@ _pack_launch_tasks_request_msg(launch_tasks_request_msg_t * msg, Buf buffer,
 	if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) {
 		pack32(msg->job_id, buffer);
 		pack32(msg->job_step_id, buffer);
+		pack32(msg->mpi_jobid, buffer);
+		pack32(msg->mpi_nnodes, buffer);
+		pack32(msg->mpi_ntasks, buffer);
+		pack32(msg->mpi_stepfnodeid, buffer);
+		pack32(msg->mpi_stepftaskid, buffer);
+		pack32(msg->mpi_stepid, buffer);
 		pack32(msg->ntasks, buffer);
 		pack16(msg->ntasks_per_board, buffer);
 		pack16(msg->ntasks_per_core, buffer);
 		pack16(msg->ntasks_per_socket, buffer);
+		pack32(msg->packjobid, buffer);
+		pack32(msg->packstepid, buffer);
 		pack32(msg->uid, buffer);
 		packstr(msg->partition, buffer);
 		packstr(msg->user_name, buffer);
@@ -10075,6 +10102,8 @@ _pack_launch_tasks_request_msg(launch_tasks_request_msg_t * msg, Buf buffer,
 						     buffer,
 						     protocol_version);
 		}
+		packstr_array(msg->pelog_env, msg->pelog_env_size,
+			      buffer);
 	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		uint16_t task_flags = 0, multi_prog = 0, user_managed_io = 0;
 		uint8_t pty = 0, buffered_stdio = 0, labelio = 0;
@@ -10289,10 +10318,19 @@ _unpack_launch_tasks_request_msg(launch_tasks_request_msg_t **
 	if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) {
 		safe_unpack32(&msg->job_id, buffer);
 		safe_unpack32(&msg->job_step_id, buffer);
+		safe_unpack32(&msg->mpi_jobid, buffer);
+		safe_unpack32(&msg->mpi_nnodes, buffer);
+		safe_unpack32(&msg->mpi_ntasks, buffer);
+		safe_unpack32(&msg->mpi_stepfnodeid, buffer);
+		safe_unpack32(&msg->mpi_stepftaskid, buffer);
+		safe_unpack32(&msg->mpi_stepid, buffer);
+
 		safe_unpack32(&msg->ntasks, buffer);
 		safe_unpack16(&msg->ntasks_per_board, buffer);
 		safe_unpack16(&msg->ntasks_per_core, buffer);
 		safe_unpack16(&msg->ntasks_per_socket, buffer);
+		safe_unpack32(&msg->packjobid, buffer);
+		safe_unpack32(&msg->packstepid, buffer);
 		safe_unpack32(&msg->uid, buffer);
 		safe_unpackstr_xmalloc(&msg->partition, &uint32_tmp, buffer);
 		safe_unpackstr_xmalloc(&msg->user_name, &uint32_tmp, buffer);
@@ -10386,6 +10424,8 @@ _unpack_launch_tasks_request_msg(launch_tasks_request_msg_t **
 						       buffer,
 						       protocol_version);
 		}
+		safe_unpackstr_array(&msg->pelog_env,
+				     &msg->pelog_env_size, buffer);
 	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		uint32_t tmp_mem = 0;
 		uint16_t task_flags = 0, multi_prog = 0, user_managed_io = 0;
@@ -11007,7 +11047,24 @@ _pack_prolog_launch_msg(
 {
 	xassert(msg != NULL);
 
-	if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
+	if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) {
+		pack32(msg->job_id, buffer);
+		pack32(msg->uid, buffer);
+		pack32(msg->gid, buffer);
+
+		packstr(msg->alias_list, buffer);
+		packstr(msg->nodes, buffer);
+		packstr(msg->partition, buffer);
+		packstr(msg->std_err, buffer);
+		packstr(msg->std_out, buffer);
+		packstr(msg->work_dir, buffer);
+		packstr_array(msg->spank_job_env, msg->spank_job_env_size,
+			      buffer);
+		slurm_cred_pack(msg->cred, buffer, protocol_version);
+		packstr(msg->user_name, buffer);
+		packstr_array(msg->pelog_env, msg->pelog_env_size,
+			      buffer);
+	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		pack32(msg->job_id, buffer);
 		pack32(msg->uid, buffer);
 		pack32(msg->gid, buffer);
@@ -11051,7 +11108,37 @@ _unpack_prolog_launch_msg(
 	launch_msg_ptr = xmalloc(sizeof(prolog_launch_msg_t));
 	*msg = launch_msg_ptr;
 
-	if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
+	if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) {
+		safe_unpack32(&launch_msg_ptr->job_id, buffer);
+		safe_unpack32(&launch_msg_ptr->uid, buffer);
+		safe_unpack32(&launch_msg_ptr->gid, buffer);
+
+		safe_unpackstr_xmalloc(&launch_msg_ptr->alias_list, &uint32_tmp,
+				       buffer);
+		safe_unpackstr_xmalloc(&launch_msg_ptr->nodes, &uint32_tmp,
+				       buffer);
+		safe_unpackstr_xmalloc(&launch_msg_ptr->partition, &uint32_tmp,
+				       buffer);
+		safe_unpackstr_xmalloc(&launch_msg_ptr->std_err, &uint32_tmp,
+				       buffer);
+		safe_unpackstr_xmalloc(&launch_msg_ptr->std_out, &uint32_tmp,
+				       buffer);
+		safe_unpackstr_xmalloc(&launch_msg_ptr->work_dir, &uint32_tmp,
+				       buffer);
+
+		safe_unpackstr_array(&launch_msg_ptr->spank_job_env,
+				     &launch_msg_ptr->spank_job_env_size,
+				     buffer);
+		if (!(launch_msg_ptr->cred = slurm_cred_unpack(buffer,
+							protocol_version)))
+			goto unpack_error;
+
+		safe_unpackstr_xmalloc(&launch_msg_ptr->user_name, &uint32_tmp,
+				       buffer);
+		safe_unpackstr_array(&launch_msg_ptr->pelog_env,
+				     &launch_msg_ptr->pelog_env_size,
+				     buffer);
+	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		safe_unpack32(&launch_msg_ptr->job_id, buffer);
 		safe_unpack32(&launch_msg_ptr->uid, buffer);
 		safe_unpack32(&launch_msg_ptr->gid, buffer);
@@ -12283,6 +12370,10 @@ _pack_batch_job_launch_msg(batch_job_launch_msg_t * msg, Buf buffer,
 		packstr(msg->qos, buffer);
 		packstr(msg->resv_name, buffer);
 		pack32(msg->profile, buffer);
+		packstr_array(msg->pelog_env, msg->pelog_env_size,
+			      buffer);
+		packstr(msg->resv_ports, buffer);
+		pack32(msg->group_number, buffer);
 	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		pack32(msg->job_id, buffer);
 		pack32(msg->step_id, buffer);
@@ -12513,6 +12604,12 @@ _unpack_batch_job_launch_msg(batch_job_launch_msg_t ** msg, Buf buffer,
 				       &uint32_tmp,
 				       buffer);
 		safe_unpack32(&launch_msg_ptr->profile, buffer);
+		safe_unpackstr_array(&launch_msg_ptr->pelog_env,
+				     &launch_msg_ptr->pelog_env_size, buffer);
+		safe_unpackstr_xmalloc(&launch_msg_ptr->resv_ports,
+				       &uint32_tmp,
+				       buffer);
+		safe_unpack32(&launch_msg_ptr->group_number, buffer);
 	} else if (protocol_version >=  SLURM_16_05_PROTOCOL_VERSION) {
 		uint32_t tmp_mem;
 		safe_unpack32(&launch_msg_ptr->job_id, buffer);
diff --git a/src/common/slurmdb_pack.c b/src/common/slurmdb_pack.c
index c5998663d34e5dc99d2707e4f74e47e4a1d9791d..2209c685e4d63409ba8d273326afd6e7d44cd758 100644
--- a/src/common/slurmdb_pack.c
+++ b/src/common/slurmdb_pack.c
@@ -4857,7 +4857,34 @@ unpack_error:
 extern void slurmdb_pack_step_rec(slurmdb_step_rec_t *step,
 				  uint16_t protocol_version, Buf buffer)
 {
-	if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+	if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) {
+		pack32(step->elapsed, buffer);
+		pack_time(step->end, buffer);
+		pack32((uint32_t)step->exitcode, buffer);
+		pack32(step->nnodes, buffer);
+		packstr(step->nodes, buffer);
+		pack32(step->ntasks, buffer);
+		pack32(step->packjobid, buffer);
+		pack32(step->packstepid, buffer);
+		pack32(step->req_cpufreq_min, buffer);
+		pack32(step->req_cpufreq_max, buffer);
+		pack32(step->req_cpufreq_gov, buffer);
+		pack32(step->requid, buffer);
+		_pack_slurmdb_stats(&step->stats, protocol_version, buffer);
+		pack_time(step->start, buffer);
+		pack16(step->state, buffer);
+		pack32(step->stepid, buffer);   /* job's step number */
+		packstr(step->stepname, buffer);
+		pack32(step->suspended, buffer);
+		pack32(step->sys_cpu_sec, buffer);
+		pack32(step->sys_cpu_usec, buffer);
+		pack32(step->task_dist, buffer);
+		pack32(step->tot_cpu_sec, buffer);
+		pack32(step->tot_cpu_usec, buffer);
+		packstr(step->tres_alloc_str, buffer);
+		pack32(step->user_cpu_sec, buffer);
+		pack32(step->user_cpu_usec, buffer);
+	} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
 		pack32(step->elapsed, buffer);
 		pack_time(step->end, buffer);
 		pack32((uint32_t)step->exitcode, buffer);
@@ -4897,7 +4924,41 @@ extern int slurmdb_unpack_step_rec(slurmdb_step_rec_t **step,
 
 	*step = step_ptr;
 
-	if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+	if (protocol_version >= SLURM_17_02_PROTOCOL_VERSION) {
+		safe_unpack32(&step_ptr->elapsed, buffer);
+		safe_unpack_time(&step_ptr->end, buffer);
+		safe_unpack32(&uint32_tmp, buffer);
+		step_ptr->exitcode = (int32_t)uint32_tmp;
+		safe_unpack32(&step_ptr->nnodes, buffer);
+		safe_unpackstr_xmalloc(&step_ptr->nodes, &uint32_tmp, buffer);
+		safe_unpack32(&step_ptr->ntasks, buffer);
+		safe_unpack32(&step_ptr->packjobid, buffer);
+		safe_unpack32(&step_ptr->packstepid, buffer);
+		safe_unpack32(&step_ptr->req_cpufreq_min, buffer);
+		safe_unpack32(&step_ptr->req_cpufreq_max, buffer);
+		safe_unpack32(&step_ptr->req_cpufreq_gov, buffer);
+		safe_unpack32(&step_ptr->requid, buffer);
+		if (_unpack_slurmdb_stats(&step_ptr->stats, protocol_version,
+					  buffer)
+		    != SLURM_SUCCESS)
+			goto unpack_error;
+		safe_unpack_time(&step_ptr->start, buffer);
+		safe_unpack16(&uint16_tmp, buffer);
+		step_ptr->state = uint16_tmp;
+		safe_unpack32(&step_ptr->stepid, buffer);
+		safe_unpackstr_xmalloc(&step_ptr->stepname,
+				       &uint32_tmp, buffer);
+		safe_unpack32(&step_ptr->suspended, buffer);
+		safe_unpack32(&step_ptr->sys_cpu_sec, buffer);
+		safe_unpack32(&step_ptr->sys_cpu_usec, buffer);
+		safe_unpack32(&step_ptr->task_dist, buffer);
+		safe_unpack32(&step_ptr->tot_cpu_sec, buffer);
+		safe_unpack32(&step_ptr->tot_cpu_usec, buffer);
+		safe_unpackstr_xmalloc(&step_ptr->tres_alloc_str,
+				       &uint32_tmp, buffer);
+		safe_unpack32(&step_ptr->user_cpu_sec, buffer);
+		safe_unpack32(&step_ptr->user_cpu_usec, buffer);
+	} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
 		safe_unpack32(&step_ptr->elapsed, buffer);
 		safe_unpack_time(&step_ptr->end, buffer);
 		safe_unpack32(&uint32_tmp, buffer);
diff --git a/src/common/slurmdbd_defs.c b/src/common/slurmdbd_defs.c
index 837b119e8cd8b1dd75f585576b219f3fa7bf9da2..dacf08c5e66083290e36b9e2fb074b9c5dcc19a3 100644
--- a/src/common/slurmdbd_defs.c
+++ b/src/common/slurmdbd_defs.c
@@ -4085,6 +4085,8 @@ slurmdbd_pack_step_start_msg(dbd_step_start_msg_t *msg, uint16_t rpc_version,
 		pack32(msg->node_cnt, buffer);
 		pack_time(msg->start_time, buffer);
 		pack_time(msg->job_submit_time, buffer);
+		pack32(msg->packjobid, buffer);
+		pack32(msg->packstepid, buffer);
 		pack32(msg->req_cpufreq_min, buffer);
 		pack32(msg->req_cpufreq_max, buffer);
 		pack32(msg->req_cpufreq_gov, buffer);
@@ -4130,6 +4132,8 @@ slurmdbd_unpack_step_start_msg(dbd_step_start_msg_t **msg,
 		safe_unpack32(&msg_ptr->node_cnt, buffer);
 		safe_unpack_time(&msg_ptr->start_time, buffer);
 		safe_unpack_time(&msg_ptr->job_submit_time, buffer);
+		safe_unpack32(&msg_ptr->packjobid, buffer);
+		safe_unpack32(&msg_ptr->packstepid, buffer);
 		safe_unpack32(&msg_ptr->req_cpufreq_min, buffer);
 		safe_unpack32(&msg_ptr->req_cpufreq_max, buffer);
 		safe_unpack32(&msg_ptr->req_cpufreq_gov, buffer);
diff --git a/src/common/slurmdbd_defs.h b/src/common/slurmdbd_defs.h
index d9e4a8901783788548ed18f1a5a1e9fbb1bf6edc..01209a518ebb374d85df75df513f91b547c7a7b0 100644
--- a/src/common/slurmdbd_defs.h
+++ b/src/common/slurmdbd_defs.h
@@ -370,6 +370,8 @@ typedef struct dbd_step_start_msg {
 	time_t   start_time;	/* step start time */
 	time_t   job_submit_time;/* job submit time needed to find job record
 				  * in db */
+	uint32_t packjobid;	/* jobid of srun first step of the jobpack */
+	uint32_t packstepid;	/* stepid of jobpack member */
 	uint32_t req_cpufreq_min; /* requested minimum CPU frequency  */
 	uint32_t req_cpufreq_max; /* requested maximum CPU frequency  */
 	uint32_t req_cpufreq_gov; /* requested CPU frequency governor */
diff --git a/src/plugins/accounting_storage/mysql/as_mysql_archive.c b/src/plugins/accounting_storage/mysql/as_mysql_archive.c
index c2bb124014e7677aaddd991729ec0fda189c43cb..70134149350eb4fcd68cf90e6ae264681045a231 100644
--- a/src/plugins/accounting_storage/mysql/as_mysql_archive.c
+++ b/src/plugins/accounting_storage/mysql/as_mysql_archive.c
@@ -160,6 +160,8 @@ typedef struct {
 	char *nodelist;
 	char *nodes;
 	char *node_inx;
+	char *packjobid;
+	char *packstepid;
 	char *period_end;
 	char *period_start;
 	char *period_suspended;
@@ -367,6 +369,8 @@ static char *step_req_inx[] = {
 	"max_disk_write_node",
 	"ave_disk_write",
 	"tres_alloc",
+	"packjobid",
+	"packstepid",
 };
 
 
@@ -419,6 +423,8 @@ enum {
 	STEP_REQ_MAX_DISK_WRITE_NODE,
 	STEP_REQ_AVE_DISK_WRITE,
 	STEP_REQ_TRES,
+	STEP_REQ_PACKJOBID,
+	STEP_REQ_PACKSTEPID,
 	STEP_REQ_COUNT,
 };
 
@@ -808,6 +814,8 @@ static void _pack_local_step(local_step_t *object,
 	packstr(object->nodelist, buffer);
 	packstr(object->nodes, buffer);
 	packstr(object->node_inx, buffer);
+	packstr(object->packjobid, buffer);
+	packstr(object->packstepid, buffer);
 	packstr(object->period_end, buffer);
 	packstr(object->period_start, buffer);
 	packstr(object->period_suspended, buffer);
@@ -833,7 +841,58 @@ static int _unpack_local_step(local_step_t *object,
 	uint32_t tmp32;
 	char *tmp_char;
 
-	if (rpc_version >= SLURM_15_08_PROTOCOL_VERSION) {
+	if (rpc_version >= SLURM_17_02_PROTOCOL_VERSION) {
+		unpackstr_ptr(&object->act_cpufreq, &tmp32, buffer);
+		unpackstr_ptr(&object->ave_cpu, &tmp32, buffer);
+		unpackstr_ptr(&object->ave_disk_read, &tmp32, buffer);
+		unpackstr_ptr(&object->ave_disk_write, &tmp32, buffer);
+		unpackstr_ptr(&object->ave_pages, &tmp32, buffer);
+		unpackstr_ptr(&object->ave_rss, &tmp32, buffer);
+		unpackstr_ptr(&object->ave_vsize, &tmp32, buffer);
+		unpackstr_ptr(&object->exit_code, &tmp32, buffer);
+		unpackstr_ptr(&object->consumed_energy, &tmp32, buffer);
+		unpackstr_ptr(&object->job_db_inx, &tmp32, buffer);
+		unpackstr_ptr(&object->kill_requid, &tmp32, buffer);
+		unpackstr_ptr(&object->max_disk_read, &tmp32, buffer);
+		unpackstr_ptr(&object->max_disk_read_node, &tmp32, buffer);
+		unpackstr_ptr(&object->max_disk_read_task, &tmp32, buffer);
+		unpackstr_ptr(&object->max_disk_write, &tmp32, buffer);
+		unpackstr_ptr(&object->max_disk_write_node, &tmp32, buffer);
+		unpackstr_ptr(&object->max_disk_write_task, &tmp32, buffer);
+		unpackstr_ptr(&object->max_pages, &tmp32, buffer);
+		unpackstr_ptr(&object->max_pages_node, &tmp32, buffer);
+		unpackstr_ptr(&object->max_pages_task, &tmp32, buffer);
+		unpackstr_ptr(&object->max_rss, &tmp32, buffer);
+		unpackstr_ptr(&object->max_rss_node, &tmp32, buffer);
+		unpackstr_ptr(&object->max_rss_task, &tmp32, buffer);
+		unpackstr_ptr(&object->max_vsize, &tmp32, buffer);
+		unpackstr_ptr(&object->max_vsize_node, &tmp32, buffer);
+		unpackstr_ptr(&object->max_vsize_task, &tmp32, buffer);
+		unpackstr_ptr(&object->min_cpu, &tmp32, buffer);
+		unpackstr_ptr(&object->min_cpu_node, &tmp32, buffer);
+		unpackstr_ptr(&object->min_cpu_task, &tmp32, buffer);
+		unpackstr_ptr(&object->name, &tmp32, buffer);
+		unpackstr_ptr(&object->nodelist, &tmp32, buffer);
+		unpackstr_ptr(&object->nodes, &tmp32, buffer);
+		unpackstr_ptr(&object->node_inx, &tmp32, buffer);
+		unpackstr_ptr(&object->packjobid, &tmp32, buffer);
+		unpackstr_ptr(&object->packstepid, &tmp32, buffer);
+		unpackstr_ptr(&object->period_end, &tmp32, buffer);
+		unpackstr_ptr(&object->period_start, &tmp32, buffer);
+		unpackstr_ptr(&object->period_suspended, &tmp32, buffer);
+		unpackstr_ptr(&object->req_cpufreq_min, &tmp32, buffer);
+		unpackstr_ptr(&object->req_cpufreq_max, &tmp32, buffer);
+		unpackstr_ptr(&object->req_cpufreq_gov, &tmp32, buffer);
+		unpackstr_ptr(&object->state, &tmp32, buffer);
+		unpackstr_ptr(&object->stepid, &tmp32, buffer);
+		unpackstr_ptr(&object->sys_sec, &tmp32, buffer);
+		unpackstr_ptr(&object->sys_usec, &tmp32, buffer);
+		unpackstr_ptr(&object->tasks, &tmp32, buffer);
+		unpackstr_ptr(&object->task_dist, &tmp32, buffer);
+		unpackstr_ptr(&object->tres_alloc_str, &tmp32, buffer);
+		unpackstr_ptr(&object->user_sec, &tmp32, buffer);
+		unpackstr_ptr(&object->user_usec, &tmp32, buffer);
+	} else if (rpc_version >= SLURM_15_08_PROTOCOL_VERSION) {
 		unpackstr_ptr(&object->act_cpufreq, &tmp32, buffer);
 		unpackstr_ptr(&object->ave_cpu, &tmp32, buffer);
 		unpackstr_ptr(&object->ave_disk_read, &tmp32, buffer);
diff --git a/src/slurmctld/slurmctld.h b/src/slurmctld/slurmctld.h
index 41e4176c3500777fae6754c3e768393f7ba6e572..535c97e099961f03d69d7243224fd7981b54f901 100644
--- a/src/slurmctld/slurmctld.h
+++ b/src/slurmctld/slurmctld.h
@@ -825,6 +825,8 @@ struct 	step_record {
 	char *name;			/* name of job step */
 	char *network;			/* step's network specification */
 	uint8_t no_kill;		/* 1 if no kill on node failure */
+	uint32_t packjobid;		/* jobid of srun first step */
+	uint32_t packstepid;		/* stepid of srun first step */
 	uint16_t port;			/* port for srun communications */
 	time_t pre_sus_time;		/* time step ran prior to last suspend */
 	uint16_t start_protocol_ver;	/* Slurm version step was
diff --git a/src/slurmctld/step_mgr.c b/src/slurmctld/step_mgr.c
index afd9c8987363c6d19ebd247e45f1878ac916df7c..929137664f41aae5217cd04294fb9c5d4c06c972 100644
--- a/src/slurmctld/step_mgr.c
+++ b/src/slurmctld/step_mgr.c
@@ -2890,6 +2890,8 @@ static void _pack_ctld_job_step_info(struct step_record *step_ptr, Buf buffer,
 					     protocol_version);
 		packstr(step_ptr->tres_fmt_alloc_str, buffer);
 		pack16(step_ptr->start_protocol_ver, buffer);
+		pack32(step_ptr->packjobid, buffer);
+		pack32(step_ptr->packstepid, buffer);
 	} else if (protocol_version >= SLURM_16_05_PROTOCOL_VERSION) {
 		pack32(step_ptr->job_ptr->array_job_id, buffer);
 		pack32(step_ptr->job_ptr->array_task_id, buffer);