/* * slurm_job_node_ready - report if nodes are ready for job to execute now * IN job_id - slurm job id * RET: READY_* values as defined in slurm.h */ extern int slurm_job_node_ready(uint32_t job_id) { slurm_msg_t req, resp; job_id_msg_t msg; int rc; slurm_msg_t_init(&req); slurm_msg_t_init(&resp); req.msg_type = REQUEST_JOB_READY; req.data = &msg; msg.job_id = job_id; if (slurm_send_recv_controller_msg(&req, &resp) < 0) return READY_JOB_ERROR; if (resp.msg_type == RESPONSE_JOB_READY) { rc = ((return_code_msg_t *) resp.data)->return_code; slurm_free_return_code_msg(resp.data); } else if (resp.msg_type == RESPONSE_SLURM_RC) { int job_rc = ((return_code_msg_t *) resp.data) -> return_code; if ((job_rc == ESLURM_INVALID_PARTITION_NAME) || (job_rc == ESLURM_INVALID_JOB_ID)) rc = READY_JOB_FATAL; else /* EAGAIN */ rc = READY_JOB_ERROR; slurm_free_return_code_msg(resp.data); } else rc = READY_JOB_ERROR; return rc; }
/* * slurm_get_triggers - Get all event trigger information * Use slurm_free_trigger() to free the memory allocated by this function * RET 0 or a slurm error code */ extern int slurm_get_triggers (trigger_info_msg_t ** trigger_get) { int rc; slurm_msg_t resp_msg; slurm_msg_t req_msg; trigger_info_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.record_count = 0; req.trigger_array = NULL; req_msg.msg_type = REQUEST_TRIGGER_GET; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_TRIGGER_GET: *trigger_get = (trigger_info_msg_t *)resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS ; }
/* * slurm_set_schedlog_level - issue RPC to set slurm scheduler log level * IN schedlog_level - requested scheduler log level * RET 0 on success, otherwise return -1 and set errno to indicate the error */ int slurm_set_schedlog_level (uint32_t schedlog_level) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; set_debug_level_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.debug_level = schedlog_level; req_msg.msg_type = REQUEST_SET_SCHEDLOG_LEVEL; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_load_ctl_conf - issue RPC to get slurm control configuration * information if changed since update_time * IN update_time - time of current configuration data * IN slurm_ctl_conf_ptr - place to store slurm control configuration * pointer * RET 0 on success, otherwise return -1 and set errno to indicate the error * NOTE: free the response using slurm_free_ctl_conf */ int slurm_load_ctl_conf (time_t update_time, slurm_ctl_conf_t **confp) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; last_update_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.last_update = update_time; req_msg.msg_type = REQUEST_BUILD_INFO; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_BUILD_INFO: *confp = (slurm_ctl_conf_info_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_load_burst_buffer_info - issue RPC to get slurm all burst buffer plugin * information * IN burst_buffer_info_msg_pptr - place to store a burst buffer configuration * pointer * RET 0 or a slurm error code * NOTE: free the response using slurm_free_burst_buffer_info_msg */ extern int slurm_load_burst_buffer_info(burst_buffer_info_msg_t ** burst_buffer_info_msg_pptr) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req_msg.msg_type = REQUEST_BURST_BUFFER_INFO; req_msg.data = NULL; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_BURST_BUFFER_INFO: *burst_buffer_info_msg_pptr = (burst_buffer_info_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *burst_buffer_info_msg_pptr = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_set_debugflags - issue RPC to set slurm controller debug flags * IN debug_flags_plus - debug flags to be added * IN debug_flags_minus - debug flags to be removed * IN debug_flags_set - new debug flags value * RET 0 on success, otherwise return -1 and set errno to indicate the error */ extern int slurm_set_debugflags (uint32_t debug_flags_plus, uint32_t debug_flags_minus) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; set_debug_flags_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.debug_flags_minus = debug_flags_minus; req.debug_flags_plus = debug_flags_plus; req_msg.msg_type = REQUEST_SET_DEBUG_FLAGS; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
extern slurm_step_layout_t * slurm_job_step_layout_get(uint32_t job_id, uint32_t step_id) { job_step_id_msg_t data; slurm_msg_t req, resp; int errnum; slurm_msg_t_init(&req); slurm_msg_t_init(&resp); req.msg_type = REQUEST_STEP_LAYOUT; req.data = &data; data.job_id = job_id; data.step_id = step_id; if (slurm_send_recv_controller_msg(&req, &resp) < 0) { return NULL; } switch (resp.msg_type) { case RESPONSE_STEP_LAYOUT: return (slurm_step_layout_t *)resp.data; case RESPONSE_SLURM_RC: errnum = ((return_code_msg_t *)resp.data)->return_code; slurm_free_return_code_msg(resp.data); errno = errnum; return NULL; default: errno = SLURM_UNEXPECTED_MSG_ERROR; return NULL; } }
/* * Log string at slurmctld daemon * IN level - message level, from src/common/log.h * IN string - the string to write * RET 0 on success, -1 on failure, see errno for details */ extern int log_ctld(uint16_t level, char *string) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; slurm_event_log_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.level = level; req.string = string; req_msg.msg_type = REQUEST_EVENT_LOG; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg, working_cluster_rec) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) { slurm_seterrno_ret(rc); return SLURM_ERROR; } break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); return SLURM_ERROR; } return SLURM_SUCCESS; }
static int _load_cluster_nodes(slurm_msg_t *req_msg, node_info_msg_t **node_info_msg_pptr, slurmdb_cluster_rec_t *cluster, uint16_t show_flags) { slurm_msg_t resp_msg; int rc; slurm_msg_t_init(&resp_msg); if (slurm_send_recv_controller_msg(req_msg, &resp_msg, cluster) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_NODE_INFO: *node_info_msg_pptr = (node_info_msg_t *) resp_msg.data; if (show_flags & SHOW_MIXED) _set_node_mixed(*node_info_msg_pptr); break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *node_info_msg_pptr = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_SUCCESS; }
/* * slurm_load_topo - issue RPC to get slurm all switch topology configuration * information * IN node_info_msg_pptr - place to store a node configuration pointer * RET 0 or a slurm error code * NOTE: free the response using slurm_free_topo_info_msg */ extern int slurm_load_topo(topo_info_response_msg_t **resp) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req_msg.msg_type = REQUEST_TOPO_INFO; req_msg.data = NULL; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_TOPO_INFO: *resp = (topo_info_response_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *resp = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* slurm_load_assoc_mgr_info() * * Load requested controller assoc_mgr state. * */ extern int slurm_load_assoc_mgr_info(assoc_mgr_info_request_msg_t *req, assoc_mgr_info_msg_t **resp) { int cc; slurm_msg_t msg_request; slurm_msg_t msg_reply; slurm_msg_t_init(&msg_request); slurm_msg_t_init(&msg_reply); msg_request.msg_type = REQUEST_ASSOC_MGR_INFO; msg_request.data = req; cc = slurm_send_recv_controller_msg(&msg_request, &msg_reply); if (cc < 0) return SLURM_ERROR; switch (msg_reply.msg_type) { case RESPONSE_ASSOC_MGR_INFO: *resp = msg_reply.data; break; case RESPONSE_SLURM_RC: cc = ((return_code_msg_t *)msg_reply.data)->return_code; slurm_free_return_code_msg(msg_reply.data); if (cc) /* slurm_seterrno_ret() is a macro ... sigh */ slurm_seterrno(cc); return -1; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
static int _get_info(shares_request_msg_t *shares_req, shares_response_msg_t **shares_resp) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req_msg.msg_type = REQUEST_SHARE_INFO; req_msg.data = shares_req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg, working_cluster_rec) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_SHARE_INFO: *shares_resp = (shares_response_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *shares_resp = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
static int _get_info(priority_factors_request_msg_t *factors_req, priority_factors_response_msg_t **factors_resp) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req_msg.msg_type = REQUEST_PRIORITY_FACTORS; req_msg.data = factors_req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_PRIORITY_FACTORS: *factors_resp = (priority_factors_response_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *factors_resp = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
static int _load_cluster_parts(slurm_msg_t *req_msg, partition_info_msg_t **resp, slurmdb_cluster_rec_t *cluster) { slurm_msg_t resp_msg; int rc; slurm_msg_t_init(&resp_msg); if (slurm_send_recv_controller_msg(req_msg, &resp_msg, cluster) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_PARTITION_INFO: *resp = (partition_info_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *resp = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_load_federation - issue RPC to get federation status from controller * IN/OUT fed_pptr - place to store returned federation information. * slurmdb_federation_rec_t treated as a void pointer to since * slurm.h doesn't have ties to slurmdb.h. * RET 0 or -1 on error */ extern int slurm_load_federation(void **fed_pptr) { int rc; slurm_msg_t resp_msg; slurm_msg_t req_msg; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req_msg.msg_type = REQUEST_FED_INFO; req_msg.data = NULL; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg, working_cluster_rec) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_FED_INFO: *fed_pptr = resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * Handle a return code message type. * Sets errno to return code and returns it */ static int _handle_rc_msg(slurm_msg_t *msg) { int rc = ((return_code_msg_t *) msg->data)->return_code; slurm_free_return_code_msg(msg->data); slurm_seterrno(rc); return rc; }
/* * Handle a return code message type. * if return code is nonzero, sets errno to return code and returns < 0. * Otherwise, returns 0 (SLURM_SUCCES) */ static int _handle_rc_msg(slurm_msg_t *msg) { int rc = ((return_code_msg_t *) msg->data)->return_code; slurm_free_return_code_msg(msg->data); if (rc) slurm_seterrno_ret(rc); else return SLURM_SUCCESS; }
/* slurm_load_licenses() * * Load requested licenses from the controller. * */ extern int slurm_load_licenses(time_t t, license_info_msg_t **lic_info, uint16_t show_flags) { int cc; slurm_msg_t msg_request; slurm_msg_t msg_reply; struct license_info_request_msg req; memset(&req, 0, sizeof(struct license_info_request_msg)); slurm_msg_t_init(&msg_request); slurm_msg_t_init(&msg_reply); msg_request.msg_type = REQUEST_LICENSE_INFO; req.last_update = t; req.show_flags = show_flags; msg_request.data = &req; cc = slurm_send_recv_controller_msg(&msg_request, &msg_reply, working_cluster_rec); if (cc < 0) return SLURM_ERROR; switch (msg_reply.msg_type) { case RESPONSE_LICENSE_INFO: *lic_info = msg_reply.data; break; case RESPONSE_SLURM_RC: cc = ((return_code_msg_t *)msg_reply.data)->return_code; slurm_free_return_code_msg(msg_reply.data); if (cc) /* slurm_seterrno_ret() is a macro ... sigh */ slurm_seterrno(cc); *lic_info = NULL; return -1; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_load_block_info - issue RPC to get slurm all node select plugin * information if changed since update_time * IN update_time - time of current configuration data * IN block_info_msg_pptr - place to store a node select configuration * pointer * IN show_flags - controls output form or filtering, see SHOW_FLAGS in slurm.h * RET 0 or a slurm error code * NOTE: free the response using slurm_free_block_info_msg */ extern int slurm_load_block_info (time_t update_time, block_info_msg_t **block_info_msg_pptr, uint16_t show_flags) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; block_info_request_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.last_update = update_time; req.show_flags = show_flags; req_msg.msg_type = REQUEST_BLOCK_INFO; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg, working_cluster_rec) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_BLOCK_INFO: *block_info_msg_pptr = (block_info_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *block_info_msg_pptr = NULL; break; default: *block_info_msg_pptr = NULL; slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_SUCCESS; }
/* * slurm_get_job_steps - issue RPC to get specific slurm job step * configuration information if changed since update_time. * a job_id value of NO_VAL implies all jobs, a step_id value of * NO_VAL implies all steps * IN update_time - time of current configuration data * IN job_id - get information for specific job id, NO_VAL for all jobs * IN step_id - get information for specific job step id, NO_VAL for all * job steps * IN job_info_msg_pptr - place to store a job configuration pointer * IN show_flags - job step filtering options * RET 0 on success, otherwise return -1 and set errno to indicate the error * NOTE: free the response using slurm_free_job_step_info_response_msg */ int slurm_get_job_steps (time_t update_time, uint32_t job_id, uint32_t step_id, job_step_info_response_msg_t **resp, uint16_t show_flags) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; job_step_info_request_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.last_update = update_time; req.job_id = job_id; req.step_id = step_id; req.show_flags = show_flags; req_msg.msg_type = REQUEST_JOB_STEP_INFO; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_JOB_STEP_INFO: *resp = (job_step_info_response_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *resp = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_load_node_single - issue RPC to get slurm configuration information * for a specific node * OUT resp - place to store a node configuration pointer * IN node_name - name of the node for which information is requested * IN show_flags - node filtering options * RET 0 or a slurm error code * NOTE: free the response using slurm_free_node_info_msg */ extern int slurm_load_node_single (node_info_msg_t **resp, char *node_name, uint16_t show_flags) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; node_info_single_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.node_name = node_name; req.show_flags = show_flags; req_msg.msg_type = REQUEST_NODE_INFO_SINGLE; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_NODE_INFO: *resp = (node_info_msg_t *) resp_msg.data; if (show_flags & SHOW_MIXED) _set_node_mixed(*resp); break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *resp = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_load_partitions - issue RPC to get slurm all partition configuration * information if changed since update_time * IN update_time - time of current configuration data * IN partition_info_msg_pptr - place to store a partition configuration * pointer * IN show_flags - partition filtering options * RET 0 or a slurm error code * NOTE: free the response using slurm_free_partition_info_msg */ extern int slurm_load_partitions (time_t update_time, partition_info_msg_t **resp, uint16_t show_flags) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; part_info_request_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.last_update = update_time; req.show_flags = show_flags; req_msg.msg_type = REQUEST_PARTITION_INFO; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_PARTITION_INFO: *resp = (partition_info_msg_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); *resp = NULL; break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_load_job_user - issue RPC to get slurm information about all jobs * to be run as the specified user * IN/OUT job_info_msg_pptr - place to store a job configuration pointer * IN user_id - ID of user we want information for * IN show_flags - job filtering options * RET 0 or -1 on error * NOTE: free the response using slurm_free_job_info_msg */ extern int slurm_load_job_user (job_info_msg_t **job_info_msg_pptr, uint32_t user_id, uint16_t show_flags) { int rc; slurm_msg_t resp_msg; slurm_msg_t req_msg; job_user_id_msg_t req; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); req.show_flags = show_flags; req.user_id = user_id; req_msg.msg_type = REQUEST_JOB_USER_INFO; req_msg.data = &req; if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case RESPONSE_JOB_INFO: *job_info_msg_pptr = (job_info_msg_t *)resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_get_end_time - get the expected end time for a given slurm job * IN jobid - slurm job id * end_time_ptr - location in which to store scheduled end time for job * RET 0 or -1 on error */ extern int slurm_get_end_time(uint32_t jobid, time_t *end_time_ptr) { int rc; slurm_msg_t resp_msg; slurm_msg_t req_msg; job_alloc_info_msg_t job_msg; srun_timeout_msg_t *timeout_msg; time_t now = time(NULL); static uint32_t jobid_cache = 0; static uint32_t jobid_env = 0; static time_t endtime_cache = 0; static time_t last_test_time = 0; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); if (!end_time_ptr) slurm_seterrno_ret(EINVAL); if (jobid == 0) { if (jobid_env) { jobid = jobid_env; } else { char *env = getenv("SLURM_JOB_ID"); if (env) { jobid = (uint32_t) atol(env); jobid_env = jobid; } } if (jobid == 0) { slurm_seterrno(ESLURM_INVALID_JOB_ID); return SLURM_ERROR; } } /* Just use cached data if data less than 60 seconds old */ if ((jobid == jobid_cache) && (difftime(now, last_test_time) < 60)) { *end_time_ptr = endtime_cache; return SLURM_SUCCESS; } job_msg.job_id = jobid; req_msg.msg_type = REQUEST_JOB_END_TIME; req_msg.data = &job_msg; if (slurm_send_recv_controller_msg( &req_msg, &resp_msg) < 0) return SLURM_ERROR; switch (resp_msg.msg_type) { case SRUN_TIMEOUT: timeout_msg = (srun_timeout_msg_t *) resp_msg.data; last_test_time = time(NULL); jobid_cache = jobid; endtime_cache = timeout_msg->timeout; *end_time_ptr = endtime_cache; slurm_free_srun_timeout_msg(resp_msg.data); break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (endtime_cache) *end_time_ptr = endtime_cache; else if (rc) slurm_seterrno_ret(rc); break; default: if (endtime_cache) *end_time_ptr = endtime_cache; else slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_SUCCESS; }
/* * slurm_load_slurmd_status - issue RPC to get the status of slurmd * daemon on this machine * IN slurmd_info_ptr - place to store slurmd status information * RET 0 or -1 on error * NOTE: free the response using slurm_free_slurmd_status() */ extern int slurm_load_slurmd_status(slurmd_status_t **slurmd_status_ptr) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); char *this_addr; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); if (cluster_flags & CLUSTER_FLAG_MULTSD) { if ((this_addr = getenv("SLURMD_NODENAME"))) { slurm_conf_get_addr(this_addr, &req_msg.address); } else { this_addr = "localhost"; slurm_set_addr(&req_msg.address, (uint16_t)slurm_get_slurmd_port(), this_addr); } } else { char this_host[256]; /* * Set request message address to slurmd on localhost */ gethostname_short(this_host, sizeof(this_host)); this_addr = slurm_conf_get_nodeaddr(this_host); if (this_addr == NULL) this_addr = xstrdup("localhost"); slurm_set_addr(&req_msg.address, (uint16_t)slurm_get_slurmd_port(), this_addr); xfree(this_addr); } req_msg.msg_type = REQUEST_DAEMON_STATUS; req_msg.data = NULL; rc = slurm_send_recv_node_msg(&req_msg, &resp_msg, 0); if ((rc != 0) || !resp_msg.auth_cred) { error("slurm_slurmd_info: %m"); if (resp_msg.auth_cred) g_slurm_auth_destroy(resp_msg.auth_cred); return SLURM_ERROR; } if (resp_msg.auth_cred) g_slurm_auth_destroy(resp_msg.auth_cred); switch (resp_msg.msg_type) { case RESPONSE_SLURMD_STATUS: *slurmd_status_ptr = (slurmd_status_t *) resp_msg.data; break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * slurm_get_node_energy_n - issue RPC to get the energy data of all * configured sensors on the target machine * IN host - name of node to query, NULL if localhost * IN delta - Use cache if data is newer than this in seconds * OUT sensors_cnt - number of sensors * OUT energy - array of acct_gather_energy_t structures on success or * NULL other wise * RET 0 on success or a slurm error code * NOTE: free the response using xfree */ extern int slurm_get_node_energy(char *host, uint16_t delta, uint16_t *sensor_cnt, acct_gather_energy_t **energy) { int rc; slurm_msg_t req_msg; slurm_msg_t resp_msg; acct_gather_energy_req_msg_t req; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); char *this_addr; xassert(sensor_cnt); xassert(energy); *sensor_cnt = 0; *energy = NULL; slurm_msg_t_init(&req_msg); slurm_msg_t_init(&resp_msg); if (host) slurm_conf_get_addr(host, &req_msg.address); else if (cluster_flags & CLUSTER_FLAG_MULTSD) { if ((this_addr = getenv("SLURMD_NODENAME"))) { slurm_conf_get_addr(this_addr, &req_msg.address); } else { this_addr = "localhost"; slurm_set_addr(&req_msg.address, (uint16_t)slurm_get_slurmd_port(), this_addr); } } else { char this_host[256]; /* * Set request message address to slurmd on localhost */ gethostname_short(this_host, sizeof(this_host)); this_addr = slurm_conf_get_nodeaddr(this_host); if (this_addr == NULL) this_addr = xstrdup("localhost"); slurm_set_addr(&req_msg.address, (uint16_t)slurm_get_slurmd_port(), this_addr); xfree(this_addr); } req.delta = delta; req_msg.msg_type = REQUEST_ACCT_GATHER_ENERGY; req_msg.data = &req; rc = slurm_send_recv_node_msg(&req_msg, &resp_msg, 0); if (rc != 0 || !resp_msg.auth_cred) { error("slurm_get_node_energy: %m"); if (resp_msg.auth_cred) g_slurm_auth_destroy(resp_msg.auth_cred); return SLURM_ERROR; } if (resp_msg.auth_cred) g_slurm_auth_destroy(resp_msg.auth_cred); switch (resp_msg.msg_type) { case RESPONSE_ACCT_GATHER_ENERGY: *sensor_cnt = ((acct_gather_node_resp_msg_t *) resp_msg.data)->sensor_cnt; *energy = ((acct_gather_node_resp_msg_t *) resp_msg.data)->energy; ((acct_gather_node_resp_msg_t *) resp_msg.data)->energy = NULL; slurm_free_acct_gather_node_resp_msg(resp_msg.data); break; case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno_ret(rc); break; default: slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR); break; } return SLURM_PROTOCOL_SUCCESS; }
/* * We don't use the api here because it does things we aren't needing * like printing out information and not returning times. */ local_cluster_rec_t *_job_will_run (job_desc_msg_t *req) { slurm_msg_t req_msg, resp_msg; will_run_response_msg_t *will_run_resp; int rc; char buf[64]; char *type = "processors"; local_cluster_rec_t *local_cluster = NULL; /* req.immediate = true; implicit */ slurm_msg_t_init(&req_msg); req_msg.msg_type = REQUEST_JOB_WILL_RUN; req_msg.data = req; rc = slurm_send_recv_controller_msg(&req_msg, &resp_msg); if (rc < 0) { slurm_seterrno(SLURM_SOCKET_ERROR); return NULL; } switch (resp_msg.msg_type) { case RESPONSE_SLURM_RC: rc = ((return_code_msg_t *) resp_msg.data)->return_code; slurm_free_return_code_msg(resp_msg.data); if (rc) slurm_seterrno(rc); break; case RESPONSE_JOB_WILL_RUN: if (working_cluster_rec->flags & CLUSTER_FLAG_BG) type = "cnodes"; will_run_resp = (will_run_response_msg_t *) resp_msg.data; slurm_make_time_str(&will_run_resp->start_time, buf, sizeof(buf)); debug("Job %u to start at %s on cluster %s using %u %s on %s", will_run_resp->job_id, buf, working_cluster_rec->name, will_run_resp->proc_cnt, type, will_run_resp->node_list); local_cluster = xmalloc(sizeof(local_cluster_rec_t)); local_cluster->cluster_rec = working_cluster_rec; local_cluster->start_time = will_run_resp->start_time; if (will_run_resp->preemptee_job_id) { local_cluster->preempt_cnt = list_count(will_run_resp->preemptee_job_id); if (opt.verbose >= LOG_LEVEL_DEBUG) { ListIterator itr; uint32_t *job_id_ptr; char *job_list = NULL, *sep = ""; itr = list_iterator_create(will_run_resp-> preemptee_job_id); while ((job_id_ptr = list_next(itr))) { if (job_list) sep = ","; xstrfmtcat(job_list, "%s%u", sep, *job_id_ptr); } debug(" Preempts: %s", job_list); xfree(job_list); } } slurm_free_will_run_response_msg(will_run_resp); break; default: slurm_seterrno(SLURM_UNEXPECTED_MSG_ERROR); return NULL; break; } return local_cluster; }