/* * * Returns SLURM_SUCCESS if successful. On error returns SLURM_ERROR * and sets errno. */ int stepd_completion(int fd, uint16_t protocol_version, step_complete_msg_t *sent) { int req = REQUEST_STEP_COMPLETION_V2; int rc; int errnum = 0; Buf buffer; int len = 0; buffer = init_buf(0); debug("Entering stepd_completion for %u.%u, range_first = %d, range_last = %d", sent->job_id, sent->job_step_id, sent->range_first, sent->range_last); if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { safe_write(fd, &req, sizeof(int)); safe_write(fd, &sent->range_first, sizeof(int)); safe_write(fd, &sent->range_last, sizeof(int)); safe_write(fd, &sent->step_rc, sizeof(int)); /* * We must not use setinfo over a pipe with slurmstepd here * Indeed, slurmd does a large use of getinfo over a pipe * with slurmstepd and doing the reverse can result in * a deadlock scenario with slurmstepd : * slurmd(lockforread,write)/slurmstepd(write,lockforread) * Do pack/unpack instead to be sure of independances of * slurmd and slurmstepd */ jobacctinfo_pack(sent->jobacct, protocol_version, PROTOCOL_TYPE_SLURM, buffer); len = get_buf_offset(buffer); safe_write(fd, &len, sizeof(int)); safe_write(fd, get_buf_data(buffer), len); free_buf(buffer); /* Receive the return code and errno */ safe_read(fd, &rc, sizeof(int)); safe_read(fd, &errnum, sizeof(int)); } else { error("%s: bad protocol version %hu", __func__, protocol_version); rc = SLURM_ERROR; } errno = errnum; return rc; rwfail: FREE_NULL_BUFFER(buffer); return -1; }
/* * * Returns SLURM_SUCCESS if successful. On error returns SLURM_ERROR * and sets errno. */ int stepd_completion(int fd, step_complete_msg_t *sent) { int req = REQUEST_STEP_COMPLETION_V2; int rc; int errnum = 0; Buf buffer; int len = 0; int version = SLURM_PROTOCOL_VERSION; buffer = init_buf(0); debug("Entering stepd_completion, range_first = %d, range_last = %d", sent->range_first, sent->range_last); safe_write(fd, &req, sizeof(int)); safe_write(fd, &version, sizeof(int)); safe_write(fd, &sent->range_first, sizeof(int)); safe_write(fd, &sent->range_last, sizeof(int)); safe_write(fd, &sent->step_rc, sizeof(int)); /* * We must not use setinfo over a pipe with slurmstepd here * Indeed, slurmd does a large use of getinfo over a pipe * with slurmstepd and doing the reverse can result in a deadlock * scenario with slurmstepd : * slurmd(lockforread,write)/slurmstepd(write,lockforread) * Do pack/unpack instead to be sure of independances of * slurmd and slurmstepd */ jobacctinfo_pack(sent->jobacct, SLURM_PROTOCOL_VERSION, PROTOCOL_TYPE_SLURM, buffer); len = get_buf_offset(buffer); safe_write(fd, &len, sizeof(int)); safe_write(fd, get_buf_data(buffer), len); free_buf(buffer); /* Receive the return code and errno */ safe_read(fd, &rc, sizeof(int)); safe_read(fd, &errnum, sizeof(int)); errno = errnum; return rc; rwfail: return -1; }
static void _pack_step_complete_msg(dbd_step_comp_msg_t *msg, uint16_t rpc_version, Buf buffer) { if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) { pack32(msg->assoc_id, buffer); pack64(msg->db_index, buffer); pack_time(msg->end_time, buffer); pack32(msg->exit_code, buffer); jobacctinfo_pack((struct jobacctinfo *)msg->jobacct, rpc_version, PROTOCOL_TYPE_DBD, buffer); pack32(msg->job_id, buffer); pack_time(msg->job_submit_time, buffer); packstr(msg->job_tres_alloc_str, buffer); pack32(msg->req_uid, buffer); pack_time(msg->start_time, buffer); pack16(msg->state, buffer); pack32(msg->step_id, buffer); pack32(msg->total_tasks, buffer); } }
extern int jobacctinfo_setinfo(jobacctinfo_t *jobacct, enum jobacct_data_type type, void *data, uint16_t protocol_version) { int rc = SLURM_SUCCESS; int *fd = (int *)data; struct rusage *rusage = (struct rusage *)data; uint32_t *uint32 = (uint32_t *) data; uint64_t *uint64 = (uint64_t *) data; double *dub = (double *) data; jobacct_id_t *jobacct_id = (jobacct_id_t *) data; struct jobacctinfo *send = (struct jobacctinfo *) data; Buf buffer = NULL; if (!plugin_polling) return SLURM_SUCCESS; switch (type) { case JOBACCT_DATA_TOTAL: memcpy(jobacct, send, sizeof(struct jobacctinfo)); break; case JOBACCT_DATA_PIPE: if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) { int len; buffer = init_buf(0); jobacctinfo_pack(jobacct, protocol_version, PROTOCOL_TYPE_SLURM, buffer); len = get_buf_offset(buffer); safe_write(*fd, &len, sizeof(int)); safe_write(*fd, get_buf_data(buffer), len); FREE_NULL_BUFFER(buffer); } break; case JOBACCT_DATA_RUSAGE: if (rusage->ru_utime.tv_sec > jobacct->user_cpu_sec) jobacct->user_cpu_sec = rusage->ru_utime.tv_sec; jobacct->user_cpu_usec = rusage->ru_utime.tv_usec; if (rusage->ru_stime.tv_sec > jobacct->sys_cpu_sec) jobacct->sys_cpu_sec = rusage->ru_stime.tv_sec; jobacct->sys_cpu_usec = rusage->ru_stime.tv_usec; break; case JOBACCT_DATA_MAX_RSS: jobacct->max_rss = *uint64; break; case JOBACCT_DATA_MAX_RSS_ID: jobacct->max_rss_id = *jobacct_id; break; case JOBACCT_DATA_TOT_RSS: jobacct->tot_rss = *uint64; break; case JOBACCT_DATA_MAX_VSIZE: jobacct->max_vsize = *uint64; break; case JOBACCT_DATA_MAX_VSIZE_ID: jobacct->max_vsize_id = *jobacct_id; break; case JOBACCT_DATA_TOT_VSIZE: jobacct->tot_vsize = *uint64; break; case JOBACCT_DATA_MAX_PAGES: jobacct->max_pages = *uint64; break; case JOBACCT_DATA_MAX_PAGES_ID: jobacct->max_pages_id = *jobacct_id; break; case JOBACCT_DATA_TOT_PAGES: jobacct->tot_pages = *uint64; break; case JOBACCT_DATA_MIN_CPU: jobacct->min_cpu = *uint32; break; case JOBACCT_DATA_MIN_CPU_ID: jobacct->min_cpu_id = *jobacct_id; break; case JOBACCT_DATA_TOT_CPU: jobacct->tot_cpu = *dub; break; case JOBACCT_DATA_ACT_CPUFREQ: jobacct->act_cpufreq = *uint32; break; case JOBACCT_DATA_CONSUMED_ENERGY: jobacct->energy.consumed_energy = *uint64; break; case JOBACCT_DATA_MAX_DISK_READ: jobacct->max_disk_read = *dub; break; case JOBACCT_DATA_MAX_DISK_READ_ID: jobacct->max_disk_read_id = *jobacct_id; break; case JOBACCT_DATA_TOT_DISK_READ: jobacct->tot_disk_read = *dub; break; case JOBACCT_DATA_MAX_DISK_WRITE: jobacct->max_disk_write = *dub; break; case JOBACCT_DATA_MAX_DISK_WRITE_ID: jobacct->max_disk_write_id = *jobacct_id; break; case JOBACCT_DATA_TOT_DISK_WRITE: jobacct->tot_disk_write = *dub; break; default: debug("jobacct_g_set_setinfo data_type %d invalid", type); } return rc; rwfail: FREE_NULL_BUFFER(buffer); return SLURM_ERROR; }