/*
* slurm_create_reservation - create a new reservation, only usable by user root
* IN resv_msg - description of reservation
* RET name of reservation on success (caller must free the memory),
* otherwise return NULL and set errno to indicate the error
*/
char *
slurm_create_reservation (resv_desc_msg_t * resv_msg)
{
int rc;
char *resv_name = NULL;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
reservation_name_msg_t *resp;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req_msg.msg_type = REQUEST_CREATE_RESERVATION;
req_msg.data = resv_msg;
rc = slurm_send_recv_controller_msg(&req_msg, &resp_msg);
switch (resp_msg.msg_type) {
case RESPONSE_CREATE_RESERVATION:
resp = (reservation_name_msg_t *) resp_msg.data;
resv_name = strdup(resp->name);
break;
case RESPONSE_SLURM_RC:
rc = ((return_code_msg_t *) resp_msg.data)->return_code;
if (rc)
slurm_seterrno(rc);
break;
default:
slurm_seterrno(SLURM_UNEXPECTED_MSG_ERROR);
}
slurm_free_msg_data(resp_msg.msg_type, resp_msg.data);
return resv_name;
}
static void _persist_free_msg_members(slurm_persist_conn_t *persist_conn,
persist_msg_t *persist_msg)
{
if (persist_conn->flags & PERSIST_FLAG_DBD)
slurmdbd_free_msg((slurmdbd_msg_t *)persist_msg);
else
slurm_free_msg_data(persist_msg->msg_type, persist_msg->data);
}
void destroy_data_info(void *object)
{
ret_data_info_t *ret_data_info = (ret_data_info_t *)object;
if (ret_data_info) {
slurm_free_msg_data(ret_data_info->type,
ret_data_info->data);
xfree(ret_data_info->node_name);
xfree(ret_data_info);
}
}
/* _background_rpc_mgr - Read and process incoming RPCs to the background
* controller (that's us) */
static void *_background_rpc_mgr(void *no_data)
{
slurm_fd_t newsockfd;
slurm_fd_t sockfd;
slurm_addr_t cli_addr;
slurm_msg_t *msg = NULL;
int error_code;
char* node_addr = NULL;
/* Read configuration only */
slurmctld_lock_t config_read_lock = {
READ_LOCK, NO_LOCK, NO_LOCK, NO_LOCK };
int sigarray[] = {SIGUSR1, 0};
(void) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
(void) pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
debug3("_background_rpc_mgr pid = %lu", (unsigned long) getpid());
/* initialize port for RPCs */
lock_slurmctld(config_read_lock);
/* set node_addr to bind to (NULL means any) */
if ((strcmp(slurmctld_conf.backup_controller,
slurmctld_conf.backup_addr) != 0)) {
node_addr = slurmctld_conf.backup_addr ;
}
if ((sockfd =
slurm_init_msg_engine_addrname_port(node_addr,
slurmctld_conf.
slurmctld_port))
== SLURM_SOCKET_ERROR)
fatal("slurm_init_msg_engine_addrname_port error %m");
unlock_slurmctld(config_read_lock);
/* Prepare to catch SIGUSR1 to interrupt accept().
* This signal is generated by the slurmctld signal
* handler thread upon receipt of SIGABRT, SIGINT,
* or SIGTERM. That thread does all processing of
* all signals. */
xsignal(SIGUSR1, _sig_handler);
xsignal_unblock(sigarray);
/*
* Process incoming RPCs indefinitely
*/
while (slurmctld_config.shutdown_time == 0) {
/* accept needed for stream implementation
* is a no-op in message implementation that just passes
* sockfd to newsockfd */
if ((newsockfd = slurm_accept_msg_conn(sockfd, &cli_addr))
== SLURM_SOCKET_ERROR) {
if (errno != EINTR)
error("slurm_accept_msg_conn: %m");
continue;
}
msg = xmalloc(sizeof(slurm_msg_t));
slurm_msg_t_init(msg);
if (slurm_receive_msg(newsockfd, msg, 0) != 0)
error("slurm_receive_msg: %m");
error_code = _background_process_msg(msg);
if ((error_code == SLURM_SUCCESS) &&
(msg->msg_type == REQUEST_SHUTDOWN_IMMEDIATE) &&
(slurmctld_config.shutdown_time == 0))
slurmctld_config.shutdown_time = time(NULL);
slurm_free_msg_data(msg->msg_type, msg->data);
slurm_free_msg(msg);
slurm_close(newsockfd); /* close new socket */
}
debug3("_background_rpc_mgr shutting down");
slurm_close(sockfd); /* close the main socket */
pthread_exit((void *) 0);
return NULL;
}
