/*
* load_all_front_end_state - Load the front_end node state from file, recover
* on slurmctld restart. Execute this after loading the configuration
* file data. Data goes into common storage.
* IN state_only - if true, overwrite only front_end node state and reason
* Use this to overwrite the "UNKNOWN state typically used in slurm.conf
* RET 0 or error code
* NOTE: READ lock_slurmctld config before entry
*/
extern int load_all_front_end_state(bool state_only)
{
#ifdef HAVE_FRONT_END
char *node_name = NULL, *reason = NULL, *data = NULL, *state_file;
int data_allocated, data_read = 0, error_code = 0, node_cnt = 0;
uint16_t node_state;
uint32_t data_size = 0, name_len;
uint32_t reason_uid = NO_VAL;
time_t reason_time = 0;
front_end_record_t *front_end_ptr;
int state_fd;
time_t time_stamp;
Buf buffer;
char *ver_str = NULL;
uint16_t protocol_version = (uint16_t) NO_VAL;
/* read the file */
lock_state_files ();
state_fd = _open_front_end_state_file(&state_file);
if (state_fd < 0) {
info ("No node state file (%s) to recover", state_file);
error_code = ENOENT;
} else {
data_allocated = BUF_SIZE;
data = xmalloc(data_allocated);
while (1) {
data_read = read(state_fd, &data[data_size], BUF_SIZE);
if (data_read < 0) {
if (errno == EINTR)
continue;
else {
error ("Read error on %s: %m",
state_file);
break;
}
} else if (data_read == 0) /* eof */
break;
data_size += data_read;
data_allocated += data_read;
xrealloc(data, data_allocated);
}
close (state_fd);
}
xfree (state_file);
unlock_state_files ();
buffer = create_buf (data, data_size);
safe_unpackstr_xmalloc( &ver_str, &name_len, buffer);
debug3("Version string in front_end_state header is %s", ver_str);
if (ver_str) {
if (!strcmp(ver_str, FRONT_END_STATE_VERSION)) {
protocol_version = SLURM_PROTOCOL_VERSION;
}
}
if (protocol_version == (uint16_t) NO_VAL) {
error("*****************************************************");
error("Can not recover front_end state, version incompatible");
error("*****************************************************");
xfree(ver_str);
free_buf(buffer);
return EFAULT;
}
xfree(ver_str);
safe_unpack_time(&time_stamp, buffer);
while (remaining_buf (buffer) > 0) {
uint16_t base_state;
if (protocol_version >= SLURM_2_3_PROTOCOL_VERSION) {
safe_unpackstr_xmalloc (&node_name, &name_len, buffer);
safe_unpack16 (&node_state, buffer);
safe_unpackstr_xmalloc (&reason, &name_len, buffer);
safe_unpack_time (&reason_time, buffer);
safe_unpack32 (&reason_uid, buffer);
base_state = node_state & NODE_STATE_BASE;
} else
goto unpack_error;
/* validity test as possible */
/* find record and perform update */
front_end_ptr = find_front_end_record(node_name);
if (front_end_ptr == NULL) {
error("Front_end node %s has vanished from "
"configuration", node_name);
} else if (state_only) {
uint16_t orig_flags;
orig_flags = front_end_ptr->node_state &
NODE_STATE_FLAGS;
node_cnt++;
if (IS_NODE_UNKNOWN(front_end_ptr)) {
if (base_state == NODE_STATE_DOWN) {
orig_flags &= (~NODE_STATE_COMPLETING);
front_end_ptr->node_state =
NODE_STATE_DOWN | orig_flags;
}
if (node_state & NODE_STATE_DRAIN) {
front_end_ptr->node_state |=
NODE_STATE_DRAIN;
}
if (node_state & NODE_STATE_FAIL) {
front_end_ptr->node_state |=
NODE_STATE_FAIL;
}
}
if (front_end_ptr->reason == NULL) {
front_end_ptr->reason = reason;
reason = NULL; /* Nothing to free */
front_end_ptr->reason_time = reason_time;
front_end_ptr->reason_uid = reason_uid;
}
} else {
node_cnt++;
front_end_ptr->node_state = node_state;
xfree(front_end_ptr->reason);
front_end_ptr->reason = reason;
reason = NULL; /* Nothing to free */
front_end_ptr->reason_time = reason_time;
front_end_ptr->reason_uid = reason_uid;
front_end_ptr->last_response = (time_t) 0;
}
xfree(node_name);
xfree(reason);
}
fini: info("Recovered state of %d front_end nodes", node_cnt);
free_buf (buffer);
return error_code;
unpack_error:
error("Incomplete front_end node data checkpoint file");
error_code = EFAULT;
xfree (node_name);
xfree(reason);
goto fini;
#else
return 0;
#endif
}
static int
_handle_completion(int fd, stepd_step_rec_t *job, uid_t uid)
{
int rc = SLURM_SUCCESS;
int errnum = 0;
int first;
int last;
jobacctinfo_t *jobacct = NULL;
int step_rc;
char* buf;
int len;
Buf buffer;
bool lock_set = false;
debug("_handle_completion for job %u.%u",
job->jobid, job->stepid);
debug3(" uid = %d", uid);
if (!_slurm_authorized_user(uid)) {
debug("step completion message from uid %ld for job %u.%u ",
(long)uid, job->jobid, job->stepid);
rc = -1;
errnum = EPERM;
/* Send the return code and errno */
safe_write(fd, &rc, sizeof(int));
safe_write(fd, &errnum, sizeof(int));
return SLURM_SUCCESS;
}
safe_read(fd, &first, sizeof(int));
safe_read(fd, &last, sizeof(int));
safe_read(fd, &step_rc, sizeof(int));
/*
* We must not use getinfo over a pipe with slurmd here
* Indeed, slurmstepd does a large use of setinfo over a pipe
* with slurmd and doing the reverse can result in a deadlock
* scenario with slurmd :
* slurmd(lockforread,write)/slurmstepd(write,lockforread)
* Do pack/unpack instead to be sure of independances of
* slurmd and slurmstepd
*/
safe_read(fd, &len, sizeof(int));
buf = xmalloc(len);
safe_read(fd, buf, len);
buffer = create_buf(buf, len);
jobacctinfo_unpack(&jobacct, SLURM_PROTOCOL_VERSION,
PROTOCOL_TYPE_SLURM, buffer, 1);
free_buf(buffer);
/*
* Record the completed nodes
*/
pthread_mutex_lock(&step_complete.lock);
lock_set = true;
if (! step_complete.wait_children) {
rc = -1;
errnum = ETIMEDOUT; /* not used anyway */
goto timeout;
}
/* SlurmUser or root can craft a launch without a valid credential
* ("srun --no-alloc ...") and no tree information can be built
* without the hostlist from the credential. */
if (step_complete.rank >= 0) {
#if 0
char bits_string[128];
debug2("Setting range %d (bit %d) through %d(bit %d)",
first, first-(step_complete.rank+1),
last, last-(step_complete.rank+1));
bit_fmt(bits_string, sizeof(bits_string), step_complete.bits);
debug2(" before bits: %s", bits_string);
#endif
bit_nset(step_complete.bits,
first - (step_complete.rank+1),
last - (step_complete.rank+1));
#if 0
bit_fmt(bits_string, sizeof(bits_string), step_complete.bits);
debug2(" after bits: %s", bits_string);
#endif
}
step_complete.step_rc = MAX(step_complete.step_rc, step_rc);
/************* acct stuff ********************/
jobacctinfo_aggregate(step_complete.jobacct, jobacct);
timeout:
jobacctinfo_destroy(jobacct);
/*********************************************/
/* Send the return code and errno, we do this within the locked
* region to ensure that the stepd doesn't exit before we can
* perform this send. */
safe_write(fd, &rc, sizeof(int));
safe_write(fd, &errnum, sizeof(int));
pthread_cond_signal(&step_complete.cond);
pthread_mutex_unlock(&step_complete.lock);
return SLURM_SUCCESS;
rwfail: if (lock_set) {
pthread_cond_signal(&step_complete.cond);
pthread_mutex_unlock(&step_complete.lock);
}
return SLURM_FAILURE;
}
void *_forward_thread(void *arg)
{
forward_msg_t *fwd_msg = (forward_msg_t *)arg;
Buf buffer = init_buf(fwd_msg->buf_len);
List ret_list = NULL;
slurm_fd_t fd = -1;
ret_data_info_t *ret_data_info = NULL;
char *name = NULL;
hostlist_t hl = hostlist_create(fwd_msg->header.forward.nodelist);
slurm_addr_t addr;
char *buf = NULL;
int steps = 0;
int start_timeout = fwd_msg->timeout;
/* repeat until we are sure the message was sent */
while ((name = hostlist_shift(hl))) {
if (slurm_conf_get_addr(name, &addr) == SLURM_ERROR) {
error("forward_thread: can't find address for host "
"%s, check slurm.conf", name);
slurm_mutex_lock(fwd_msg->forward_mutex);
mark_as_failed_forward(&fwd_msg->ret_list, name,
SLURM_UNKNOWN_FORWARD_ADDR);
free(name);
if (hostlist_count(hl) > 0) {
slurm_mutex_unlock(fwd_msg->forward_mutex);
continue;
}
goto cleanup;
}
if ((fd = slurm_open_msg_conn(&addr)) < 0) {
error("forward_thread to %s: %m", name);
slurm_mutex_lock(fwd_msg->forward_mutex);
mark_as_failed_forward(
&fwd_msg->ret_list, name,
SLURM_COMMUNICATIONS_CONNECTION_ERROR);
free(name);
if (hostlist_count(hl) > 0) {
slurm_mutex_unlock(fwd_msg->forward_mutex);
continue;
}
goto cleanup;
}
buf = hostlist_ranged_string_xmalloc(hl);
xfree(fwd_msg->header.forward.nodelist);
fwd_msg->header.forward.nodelist = buf;
fwd_msg->header.forward.cnt = hostlist_count(hl);
/* info("sending %d forwards (%s) to %s", */
/* fwd_msg->header.forward.cnt, */
/* fwd_msg->header.forward.nodelist, name); */
if (fwd_msg->header.forward.nodelist[0]) {
debug3("forward: send to %s along with %s",
name, fwd_msg->header.forward.nodelist);
} else
debug3("forward: send to %s ", name);
pack_header(&fwd_msg->header, buffer);
/* add forward data to buffer */
if (remaining_buf(buffer) < fwd_msg->buf_len) {
buffer->size += (fwd_msg->buf_len + BUF_SIZE);
xrealloc(buffer->head, buffer->size);
}
if (fwd_msg->buf_len) {
memcpy(&buffer->head[buffer->processed],
fwd_msg->buf, fwd_msg->buf_len);
buffer->processed += fwd_msg->buf_len;
}
/*
* forward message
*/
if (_slurm_msg_sendto(fd,
get_buf_data(buffer),
get_buf_offset(buffer),
SLURM_PROTOCOL_NO_SEND_RECV_FLAGS ) < 0) {
error("forward_thread: slurm_msg_sendto: %m");
slurm_mutex_lock(fwd_msg->forward_mutex);
mark_as_failed_forward(&fwd_msg->ret_list, name,
errno);
free(name);
if (hostlist_count(hl) > 0) {
free_buf(buffer);
buffer = init_buf(fwd_msg->buf_len);
slurm_mutex_unlock(fwd_msg->forward_mutex);
slurm_close_accepted_conn(fd);
fd = -1;
continue;
}
goto cleanup;
}
if ((fwd_msg->header.msg_type == REQUEST_SHUTDOWN) ||
(fwd_msg->header.msg_type == REQUEST_RECONFIGURE) ||
(fwd_msg->header.msg_type == REQUEST_REBOOT_NODES)) {
slurm_mutex_lock(fwd_msg->forward_mutex);
ret_data_info = xmalloc(sizeof(ret_data_info_t));
list_push(fwd_msg->ret_list, ret_data_info);
ret_data_info->node_name = xstrdup(name);
free(name);
while ((name = hostlist_shift(hl))) {
ret_data_info =
xmalloc(sizeof(ret_data_info_t));
list_push(fwd_msg->ret_list, ret_data_info);
ret_data_info->node_name = xstrdup(name);
free(name);
}
goto cleanup;
}
if (fwd_msg->header.forward.cnt > 0) {
static int message_timeout = -1;
if (message_timeout < 0)
message_timeout =
slurm_get_msg_timeout() * 1000;
steps = (fwd_msg->header.forward.cnt+1) /
slurm_get_tree_width();
fwd_msg->timeout = (message_timeout*steps);
/* info("got %d * %d = %d", message_timeout, steps, fwd_msg->timeout); */
steps++;
fwd_msg->timeout += (start_timeout*steps);
/* info("now + %d*%d = %d", start_timeout, steps, fwd_msg->timeout); */
}
ret_list = slurm_receive_msgs(fd, steps, fwd_msg->timeout);
/* info("sent %d forwards got %d back", */
/* fwd_msg->header.forward.cnt, list_count(ret_list)); */
if (!ret_list || (fwd_msg->header.forward.cnt != 0
&& list_count(ret_list) <= 1)) {
slurm_mutex_lock(fwd_msg->forward_mutex);
mark_as_failed_forward(&fwd_msg->ret_list, name,
errno);
free(name);
if (ret_list)
list_destroy(ret_list);
if (hostlist_count(hl) > 0) {
free_buf(buffer);
buffer = init_buf(fwd_msg->buf_len);
slurm_mutex_unlock(fwd_msg->forward_mutex);
slurm_close_accepted_conn(fd);
fd = -1;
continue;
}
goto cleanup;
} else if ((fwd_msg->header.forward.cnt+1)
!= list_count(ret_list)) {
/* this should never be called since the above
should catch the failed forwards and pipe
them back down, but this is here so we
never have to worry about a locked
mutex */
ListIterator itr = NULL;
char *tmp = NULL;
int first_node_found = 0;
hostlist_iterator_t host_itr
= hostlist_iterator_create(hl);
error("We shouldn't be here. We forwarded to %d "
"but only got %d back",
(fwd_msg->header.forward.cnt+1),
list_count(ret_list));
while ((tmp = hostlist_next(host_itr))) {
int node_found = 0;
itr = list_iterator_create(ret_list);
while ((ret_data_info = list_next(itr))) {
if (!ret_data_info->node_name) {
first_node_found = 1;
ret_data_info->node_name =
xstrdup(name);
}
if (!strcmp(tmp,
ret_data_info->node_name)) {
node_found = 1;
break;
}
}
list_iterator_destroy(itr);
if (!node_found) {
mark_as_failed_forward(
&fwd_msg->ret_list,
tmp,
SLURM_COMMUNICATIONS_CONNECTION_ERROR);
}
free(tmp);
}
hostlist_iterator_destroy(host_itr);
if (!first_node_found) {
mark_as_failed_forward(&fwd_msg->ret_list,
name,
SLURM_COMMUNICATIONS_CONNECTION_ERROR);
}
}
break;
}
slurm_mutex_lock(fwd_msg->forward_mutex);
if (ret_list) {
while ((ret_data_info = list_pop(ret_list)) != NULL) {
if (!ret_data_info->node_name) {
ret_data_info->node_name = xstrdup(name);
}
list_push(fwd_msg->ret_list, ret_data_info);
debug3("got response from %s",
ret_data_info->node_name);
}
list_destroy(ret_list);
}
free(name);
cleanup:
if ((fd >= 0) && slurm_close_accepted_conn(fd) < 0)
error ("close(%d): %m", fd);
hostlist_destroy(hl);
destroy_forward(&fwd_msg->header.forward);
free_buf(buffer);
pthread_cond_signal(fwd_msg->notify);
slurm_mutex_unlock(fwd_msg->forward_mutex);
return (NULL);
}
static int _handle_mult_rc_ret(void)
{
Buf buffer;
uint16_t msg_type;
persist_rc_msg_t *msg = NULL;
dbd_list_msg_t *list_msg = NULL;
int rc = SLURM_ERROR;
Buf out_buf = NULL;
buffer = slurm_persist_recv_msg(slurmdbd_conn);
if (buffer == NULL)
return rc;
safe_unpack16(&msg_type, buffer);
switch (msg_type) {
case DBD_GOT_MULT_MSG:
if (slurmdbd_unpack_list_msg(
&list_msg, slurmdbd_conn->version,
DBD_GOT_MULT_MSG, buffer)
!= SLURM_SUCCESS) {
error("slurmdbd: unpack message error");
break;
}
slurm_mutex_lock(&agent_lock);
if (agent_list) {
ListIterator itr =
list_iterator_create(list_msg->my_list);
while ((out_buf = list_next(itr))) {
Buf b;
if ((rc = _unpack_return_code(
slurmdbd_conn->version, out_buf))
!= SLURM_SUCCESS)
break;
if ((b = list_dequeue(agent_list))) {
free_buf(b);
} else {
error("slurmdbd: DBD_GOT_MULT_MSG "
"unpack message error");
}
}
list_iterator_destroy(itr);
}
slurm_mutex_unlock(&agent_lock);
slurmdbd_free_list_msg(list_msg);
break;
case PERSIST_RC:
if (slurm_persist_unpack_rc_msg(
&msg, buffer, slurmdbd_conn->version)
== SLURM_SUCCESS) {
rc = msg->rc;
if (rc != SLURM_SUCCESS) {
if (msg->ret_info == DBD_REGISTER_CTLD &&
slurm_get_accounting_storage_enforce()) {
error("slurmdbd: PERSIST_RC is %d from "
"%s(%u): %s",
rc,
slurmdbd_msg_type_2_str(
msg->ret_info, 1),
msg->ret_info,
msg->comment);
fatal("You need to add this cluster "
"to accounting if you want to "
"enforce associations, or no "
"jobs will ever run.");
} else
debug("slurmdbd: PERSIST_RC is %d from "
"%s(%u): %s",
rc,
slurmdbd_msg_type_2_str(
msg->ret_info, 1),
msg->ret_info,
msg->comment);
}
slurm_persist_free_rc_msg(msg);
} else
error("slurmdbd: unpack message error");
break;
default:
error("slurmdbd: bad message type %d != PERSIST_RC", msg_type);
}
unpack_error:
free_buf(buffer);
return rc;
}
static void *_agent(void *x)
{
int cnt, rc;
Buf buffer;
struct timespec abs_time;
static time_t fail_time = 0;
int sigarray[] = {SIGUSR1, 0};
slurmdbd_msg_t list_req;
dbd_list_msg_t list_msg;
list_req.msg_type = DBD_SEND_MULT_MSG;
list_req.data = &list_msg;
memset(&list_msg, 0, sizeof(dbd_list_msg_t));
/* DEF_TIMERS; */
/* Prepare to catch SIGUSR1 to interrupt pending
* I/O and terminate in a timely fashion. */
xsignal(SIGUSR1, _sig_handler);
xsignal_unblock(sigarray);
while (*slurmdbd_conn->shutdown == 0) {
/* START_TIMER; */
slurm_mutex_lock(&slurmdbd_lock);
if (halt_agent)
slurm_cond_wait(&slurmdbd_cond, &slurmdbd_lock);
if ((slurmdbd_conn->fd < 0) &&
(difftime(time(NULL), fail_time) >= 10)) {
/* The connection to Slurm DBD is not open */
_open_slurmdbd_conn(1);
if (slurmdbd_conn->fd < 0)
fail_time = time(NULL);
}
slurm_mutex_lock(&agent_lock);
if (agent_list && slurmdbd_conn->fd)
cnt = list_count(agent_list);
else
cnt = 0;
if ((cnt == 0) || (slurmdbd_conn->fd < 0) ||
(fail_time && (difftime(time(NULL), fail_time) < 10))) {
slurm_mutex_unlock(&slurmdbd_lock);
abs_time.tv_sec = time(NULL) + 10;
abs_time.tv_nsec = 0;
slurm_cond_timedwait(&agent_cond, &agent_lock,
&abs_time);
slurm_mutex_unlock(&agent_lock);
continue;
} else if ((cnt > 0) && ((cnt % 100) == 0))
info("slurmdbd: agent queue size %u", cnt);
/* Leave item on the queue until processing complete */
if (agent_list) {
int handle_agent_count = 1000;
if (cnt > handle_agent_count) {
int agent_count = 0;
ListIterator agent_itr =
list_iterator_create(agent_list);
list_msg.my_list = list_create(NULL);
while ((buffer = list_next(agent_itr))) {
list_enqueue(list_msg.my_list, buffer);
agent_count++;
if (agent_count > handle_agent_count)
break;
}
list_iterator_destroy(agent_itr);
buffer = pack_slurmdbd_msg(
&list_req, SLURM_PROTOCOL_VERSION);
} else if (cnt > 1) {
list_msg.my_list = agent_list;
buffer = pack_slurmdbd_msg(
&list_req, SLURM_PROTOCOL_VERSION);
} else
buffer = (Buf) list_peek(agent_list);
} else
buffer = NULL;
slurm_mutex_unlock(&agent_lock);
if (buffer == NULL) {
slurm_mutex_unlock(&slurmdbd_lock);
slurm_mutex_lock(&assoc_cache_mutex);
if (slurmdbd_conn->fd >= 0 && running_cache)
slurm_cond_signal(&assoc_cache_cond);
slurm_mutex_unlock(&assoc_cache_mutex);
continue;
}
/* NOTE: agent_lock is clear here, so we can add more
* requests to the queue while waiting for this RPC to
* complete. */
rc = slurm_persist_send_msg(slurmdbd_conn, buffer);
if (rc != SLURM_SUCCESS) {
if (*slurmdbd_conn->shutdown) {
slurm_mutex_unlock(&slurmdbd_lock);
break;
}
error("slurmdbd: Failure sending message: %d: %m", rc);
} else if (list_msg.my_list) {
rc = _handle_mult_rc_ret();
} else {
rc = _get_return_code();
if (rc == EAGAIN) {
if (*slurmdbd_conn->shutdown) {
slurm_mutex_unlock(&slurmdbd_lock);
break;
}
error("slurmdbd: Failure with "
"message need to resend: %d: %m", rc);
}
}
slurm_mutex_unlock(&slurmdbd_lock);
slurm_mutex_lock(&assoc_cache_mutex);
if (slurmdbd_conn->fd >= 0 && running_cache)
slurm_cond_signal(&assoc_cache_cond);
slurm_mutex_unlock(&assoc_cache_mutex);
slurm_mutex_lock(&agent_lock);
if (agent_list && (rc == SLURM_SUCCESS)) {
/*
* If we sent a mult_msg we just need to free buffer,
* we don't need to requeue, just mark list_msg.my_list
* as NULL as that is the sign we sent a mult_msg.
*/
if (list_msg.my_list) {
if (list_msg.my_list != agent_list)
FREE_NULL_LIST(list_msg.my_list);
list_msg.my_list = NULL;
} else
buffer = (Buf) list_dequeue(agent_list);
free_buf(buffer);
fail_time = 0;
} else {
/* We need to free a mult_msg even on failure */
if (list_msg.my_list) {
if (list_msg.my_list != agent_list)
FREE_NULL_LIST(list_msg.my_list);
list_msg.my_list = NULL;
free_buf(buffer);
}
fail_time = time(NULL);
}
slurm_mutex_unlock(&agent_lock);
/* END_TIMER; */
/* info("at the end with %s", TIME_STR); */
}
slurm_mutex_lock(&agent_lock);
_save_dbd_state();
FREE_NULL_LIST(agent_list);
slurm_mutex_unlock(&agent_lock);
return NULL;
}
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;
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_14_03_PROTOCOL_VERSION) {
int len;
Buf 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_buf(buffer);
} else if (protocol_version >= SLURM_2_6_PROTOCOL_VERSION) {
safe_write(*fd, &jobacct->user_cpu_sec,
sizeof(uint32_t));
safe_write(*fd, &jobacct->user_cpu_usec,
sizeof(uint32_t));
safe_write(*fd, &jobacct->sys_cpu_sec,
sizeof(uint32_t));
safe_write(*fd, &jobacct->sys_cpu_usec,
sizeof(uint32_t));
safe_write(*fd, &jobacct->max_vsize, sizeof(uint32_t));
safe_write(*fd, &jobacct->tot_vsize, sizeof(uint32_t));
safe_write(*fd, &jobacct->max_rss, sizeof(uint32_t));
safe_write(*fd, &jobacct->tot_rss, sizeof(uint32_t));
safe_write(*fd, &jobacct->max_pages, sizeof(uint32_t));
safe_write(*fd, &jobacct->tot_pages, sizeof(uint32_t));
safe_write(*fd, &jobacct->min_cpu, sizeof(uint32_t));
safe_write(*fd, &jobacct->tot_cpu, sizeof(uint32_t));
safe_write(*fd, &jobacct->act_cpufreq,
sizeof(uint32_t));
safe_write(*fd, &jobacct->energy.consumed_energy,
sizeof(uint32_t));
safe_write(*fd, &jobacct->max_disk_read,
sizeof(double));
safe_write(*fd, &jobacct->tot_disk_read,
sizeof(double));
safe_write(*fd, &jobacct->max_disk_write,
sizeof(double));
safe_write(*fd, &jobacct->tot_disk_write,
sizeof(double));
_write_jobacct_id(*fd, &jobacct->max_vsize_id,
protocol_version);
_write_jobacct_id(*fd, &jobacct->max_rss_id,
protocol_version);
_write_jobacct_id(*fd, &jobacct->max_pages_id,
protocol_version);
_write_jobacct_id(*fd, &jobacct->min_cpu_id,
protocol_version);
_write_jobacct_id(*fd, &jobacct->max_disk_read_id,
protocol_version);
_write_jobacct_id(*fd, &jobacct->max_disk_write_id,
protocol_version);
}
break;
case JOBACCT_DATA_RUSAGE:
jobacct->user_cpu_sec = rusage->ru_utime.tv_sec;
jobacct->user_cpu_usec = rusage->ru_utime.tv_usec;
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 = *uint32;
break;
case JOBACCT_DATA_ACT_CPUFREQ:
jobacct->act_cpufreq = *uint32;
break;
case JOBACCT_DATA_CONSUMED_ENERGY:
jobacct->energy.consumed_energy = *uint32;
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:
return SLURM_ERROR;
}
END_TEST
START_TEST(pack_1702_assoc_rec)
{
int rc;
Buf buf = init_buf(1024);
slurmdb_assoc_rec_t *pack_ar = xmalloc(sizeof(slurmdb_assoc_rec_t));
slurmdb_accounting_rec_t *art = xmalloc(sizeof(slurmdb_accounting_rec_t));
art->id = 66;
char *qos = xstrdup("Eusebius");
pack_ar->accounting_list = list_create(slurmdb_destroy_accounting_rec);
pack_ar->acct = xstrdup("Socrates");
pack_ar->assoc_next = xmalloc(sizeof(slurmdb_assoc_rec_t));
pack_ar->assoc_next->rgt = 11;
pack_ar->assoc_next->grp_jobs = 22;
pack_ar->assoc_next_id = xmalloc(sizeof(slurmdb_assoc_rec_t));
pack_ar->assoc_next_id->grp_jobs = 33;
pack_ar->cluster = xstrdup("Parmenides");
pack_ar->def_qos_id = 1;
pack_ar->grp_jobs = 2;
pack_ar->grp_submit_jobs = 3;
pack_ar->grp_tres = xstrdup("Parmenides");
pack_ar->grp_tres_ctld = NULL;
pack_ar->grp_tres_mins = xstrdup("Parmenides");
pack_ar->grp_tres_run_mins = xstrdup("Parmenides");
pack_ar->grp_tres_run_mins_ctld = NULL;
pack_ar->grp_wall = 6;
pack_ar->id = 7;
pack_ar->is_def = 8;
pack_ar->lft = 9;
pack_ar->max_jobs = 1;
pack_ar->max_submit_jobs = 2;
pack_ar->max_tres_mins_pj = xstrdup("Parmenides");
pack_ar->max_tres_mins_ctld = NULL;
pack_ar->max_tres_run_mins = xstrdup("Parmenides");
pack_ar->max_tres_run_mins_ctld = NULL;
pack_ar->max_tres_pj = xstrdup("Parmenides");
pack_ar->max_tres_ctld = NULL;
pack_ar->max_tres_pn = xstrdup("Parmenides");
pack_ar->max_tres_pn_ctld = NULL;
pack_ar->max_wall_pj = 7;
pack_ar->parent_acct = xstrdup("Parmenides");
pack_ar->parent_id = 8;
pack_ar->partition = xstrdup("Parmenides");
pack_ar->qos_list = list_create(slurm_destroy_char);
pack_ar->rgt = 9;
pack_ar->shares_raw = 1;
pack_ar->uid = 2;
pack_ar->usage = xmalloc(sizeof(slurmdb_assoc_usage_t));
pack_ar->user = xstrdup("Parmenides");
list_append(pack_ar->accounting_list, (void *)art);
list_append(pack_ar->qos_list , (void *)qos);
slurmdb_pack_assoc_rec(pack_ar, SLURM_MIN_PROTOCOL_VERSION, buf);
set_buf_offset(buf, 0);
slurmdb_assoc_rec_t *unpack_ar;
rc = slurmdb_unpack_assoc_rec((void **)&unpack_ar, SLURM_MIN_PROTOCOL_VERSION, buf);
ck_assert(rc == SLURM_SUCCESS);
ck_assert_str_eq(pack_ar->acct, unpack_ar->acct);
ck_assert(NULL == unpack_ar->assoc_next);
ck_assert(NULL == unpack_ar->assoc_next_id);
ck_assert_str_eq(pack_ar->cluster, unpack_ar->cluster);
ck_assert(pack_ar->def_qos_id == unpack_ar->def_qos_id);
ck_assert(pack_ar->grp_jobs == unpack_ar->grp_jobs);
ck_assert(pack_ar->grp_submit_jobs == unpack_ar->grp_submit_jobs);
ck_assert_str_eq(pack_ar->grp_tres, unpack_ar->grp_tres);
ck_assert(pack_ar->grp_tres_ctld == unpack_ar->grp_tres_ctld);
ck_assert_str_eq(pack_ar->grp_tres_run_mins, unpack_ar->grp_tres_run_mins);
ck_assert(pack_ar->grp_wall == unpack_ar->grp_wall);
ck_assert(pack_ar->id == unpack_ar->id);
ck_assert(pack_ar->is_def == unpack_ar->is_def);
ck_assert(pack_ar->lft == unpack_ar->lft);
ck_assert(pack_ar->max_jobs == unpack_ar->max_jobs);
ck_assert(pack_ar->max_submit_jobs == unpack_ar->max_submit_jobs);
ck_assert_str_eq(pack_ar->max_tres_mins_pj, unpack_ar->max_tres_mins_pj);
ck_assert(pack_ar->max_tres_mins_ctld == unpack_ar->max_tres_mins_ctld);
ck_assert_str_eq(pack_ar->max_tres_run_mins, unpack_ar->max_tres_run_mins);
ck_assert(pack_ar->max_tres_run_mins_ctld == unpack_ar->max_tres_run_mins_ctld);
ck_assert_str_eq(pack_ar->max_tres_pj, unpack_ar->max_tres_pj);
ck_assert(pack_ar->max_tres_ctld == unpack_ar->max_tres_ctld);
ck_assert_str_eq(pack_ar->max_tres_pn, unpack_ar->max_tres_pn);
ck_assert(pack_ar->max_tres_pn_ctld == unpack_ar->max_tres_pn_ctld);
ck_assert(pack_ar->max_wall_pj == unpack_ar->max_wall_pj);
ck_assert_str_eq(pack_ar->parent_acct, unpack_ar->parent_acct);
ck_assert(pack_ar->parent_id == unpack_ar->parent_id);
ck_assert_str_eq(pack_ar->partition, unpack_ar->partition);
ck_assert(pack_ar->rgt == unpack_ar->rgt);
ck_assert(pack_ar->shares_raw == unpack_ar->shares_raw);
ck_assert(pack_ar->uid == unpack_ar->uid);
ck_assert(NULL == unpack_ar->usage);
ck_assert_str_eq(pack_ar->user, unpack_ar->user);
slurmdb_accounting_rec_t *b = (slurmdb_accounting_rec_t *)list_peek(pack_ar->accounting_list);
slurmdb_accounting_rec_t *a = (slurmdb_accounting_rec_t *)list_peek(pack_ar->accounting_list);
char *before = (char *)list_peek(pack_ar->qos_list);
char *after = (char *)list_peek(unpack_ar->qos_list);
ck_assert(b->id == a->id);
ck_assert_str_eq(before, after);
free_buf(buf);
xfree(pack_ar->assoc_next);
xfree(pack_ar->assoc_next_id);
xfree(pack_ar->usage);
slurmdb_destroy_assoc_rec(pack_ar);
slurmdb_destroy_assoc_rec(unpack_ar);
}
void interruptDmaSpi(void) {
free_buf(pb_spi);
DMA_SetCurrDataCounter(DMA1_Stream5, SIZE_BIG_BUFFER);
return;
}
void do_spells(CHAR_DATA *ch, char *argument)
{
BUFFER *buffer;
char arg[MAX_INPUT_LENGTH];
char spell_list[LEVEL_HERO + 1][MAX_STRING_LENGTH];
char spell_columns[LEVEL_HERO + 1];
int sn, level, min_lev = 1, max_lev = LEVEL_HERO, mana;
bool fAll = FALSE, found = FALSE;
char buf[MAX_STRING_LENGTH];
if (IS_NPC(ch))
return;
if(ch->Class()->ctype!=CLASS_CASTER)
{
send_to_char("Your class knows no spells.\n\r",ch);
return;
}
if (argument[0] != '\0')
{
fAll = TRUE;
if (str_prefix(argument,"all"))
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or all.\n\r",ch);
return;
}
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (argument[0] != '\0')
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or all.\n\r",ch);
return;
}
min_lev = max_lev;
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,
"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (min_lev > max_lev)
{
send_to_char("That would be silly.\n\r",ch);
return;
}
}
}
}
/* initialize data */
for (level = 0; level < LEVEL_HERO + 1; level++)
{
spell_columns[level] = 0;
spell_list[level][0] = '\0';
}
for (sn = 0; sn < MAX_SKILL; sn++)
{
if (skill_table[sn].name == NULL )
break;
if ((level = skill_table[sn].skill_level[ch->Class()->GetIndex()]) < LEVEL_HERO + 1
&& level >= min_lev && level <= max_lev
&& skill_table[sn].spell_fun != spell_null
&& ch->pcdata->learned[sn] > 0
&& (skill_table[sn].ctype==CMD_SPELL || skill_table[sn].ctype==CMD_BOTH))
{
found = TRUE;
level = skill_table[sn].skill_level[ch->Class()->GetIndex()];
if (ch->level < level)
sprintf(buf,"%-18s n/a ", skill_table[sn].name);
else
{
mana = UMAX(skill_table[sn].min_mana,
100/(2 + ch->level - level));
sprintf(buf,"%-18s %3d mana ",skill_table[sn].name,mana);
}
if (spell_list[level][0] == '\0')
sprintf(spell_list[level],"\n\rLevel %2d: %s",level,buf);
else /* append */
{
if ( ++spell_columns[level] % 2 == 0)
strcat(spell_list[level],"\n\r ");
strcat(spell_list[level],buf);
}
}
}
/* return results */
if (!found)
{
send_to_char("No spells found.\n\r",ch);
return;
}
buffer = new_buf();
for (level = 0; level < LEVEL_HERO + 1; level++)
if (spell_list[level][0] != '\0')
add_buf(buffer,spell_list[level]);
add_buf(buffer,"\n\r");
page_to_char(buf_string(buffer),ch);
free_buf(buffer);
}
static int _write_last_decay_ran(time_t last_ran, time_t last_reset)
{
/* Save high-water mark to avoid buffer growth with copies */
static int high_buffer_size = BUF_SIZE;
int error_code = SLURM_SUCCESS;
int state_fd;
char *old_file, *new_file, *state_file;
Buf buffer;
if (!strcmp(slurmctld_conf.state_save_location, "/dev/null")) {
error("Can not save priority state information, "
"StateSaveLocation is /dev/null");
return error_code;
}
buffer = init_buf(high_buffer_size);
pack_time(last_ran, buffer);
pack_time(last_reset, buffer);
/* read the file */
old_file = xstrdup(slurmctld_conf.state_save_location);
xstrcat(old_file, "/priority_last_decay_ran.old");
state_file = xstrdup(slurmctld_conf.state_save_location);
xstrcat(state_file, "/priority_last_decay_ran");
new_file = xstrdup(slurmctld_conf.state_save_location);
xstrcat(new_file, "/priority_last_decay_ran.new");
lock_state_files();
state_fd = creat(new_file, 0600);
if (state_fd < 0) {
error("Can't save decay state, create file %s error %m",
new_file);
error_code = errno;
} else {
int pos = 0, nwrite = get_buf_offset(buffer), amount;
char *data = (char *)get_buf_data(buffer);
high_buffer_size = MAX(nwrite, high_buffer_size);
while (nwrite > 0) {
amount = write(state_fd, &data[pos], nwrite);
if ((amount < 0) && (errno != EINTR)) {
error("Error writing file %s, %m", new_file);
error_code = errno;
break;
}
nwrite -= amount;
pos += amount;
}
fsync(state_fd);
close(state_fd);
}
if (error_code != SLURM_SUCCESS)
(void) unlink(new_file);
else { /* file shuffle */
(void) unlink(old_file);
if (link(state_file, old_file))
debug3("unable to create link for %s -> %s: %m",
state_file, old_file);
(void) unlink(state_file);
if (link(new_file, state_file))
debug3("unable to create link for %s -> %s: %m",
new_file, state_file);
(void) unlink(new_file);
}
xfree(old_file);
xfree(state_file);
xfree(new_file);
unlock_state_files();
debug4("done writing time %ld", (long)last_ran);
free_buf(buffer);
return error_code;
}
static void _process_server_request(recv_header_t *_hdr, void *payload)
{
send_header_t *hdr = &_hdr->send_hdr;
char *nodename = pmixp_info_job_host(hdr->nodeid);
Buf buf;
int rc;
buf = create_buf(payload, hdr->msgsize);
switch (hdr->type) {
case PMIXP_MSG_FAN_IN:
case PMIXP_MSG_FAN_OUT: {
pmixp_coll_t *coll;
pmix_proc_t *procs = NULL;
size_t nprocs = 0;
pmixp_coll_type_t type = 0;
rc = pmixp_coll_unpack_ranges(buf, &type, &procs, &nprocs);
if (SLURM_SUCCESS != rc) {
PMIXP_ERROR("Bad message header from node %s", nodename);
return;
}
coll = pmixp_state_coll_get(type, procs, nprocs);
xfree(procs);
PMIXP_DEBUG("FENCE collective message from node \"%s\", type = %s, seq = %d",
nodename, (PMIXP_MSG_FAN_IN == hdr->type) ? "fan-in" : "fan-out",
hdr->seq);
rc = pmixp_coll_check_seq(coll, hdr->seq, nodename);
if (PMIXP_COLL_REQ_FAILURE == rc) {
/* this is unexepable event: either something went
* really wrong or the state machine is incorrect.
* This will 100% lead to application hang.
*/
PMIXP_ERROR("Bad collective seq. #%d from %s, current is %d",
hdr->seq, nodename, coll->seq);
pmixp_debug_hang(0); /* enable hang to debug this! */
slurm_kill_job_step(pmixp_info_jobid(), pmixp_info_stepid(),
SIGKILL);
break;
} else if (PMIXP_COLL_REQ_SKIP == rc) {
PMIXP_DEBUG("Wrong collective seq. #%d from %s, current is %d, skip this message",
hdr->seq, nodename, coll->seq);
free_buf(buf);
break;
}
if (PMIXP_MSG_FAN_IN == hdr->type) {
pmixp_coll_contrib_node(coll, nodename, buf);
/* we don't need this buffer anymore */
free_buf(buf);
} else {
pmixp_coll_bcast(coll, buf);
/* buf will be free'd by the PMIx callback */
}
break;
}
case PMIXP_MSG_DMDX: {
pmixp_dmdx_process(buf, nodename, hdr->seq);
break;
}
case PMIXP_MSG_HEALTH_CHK: {
/* this is just health ping.
* TODO: can we do something more sophisticated?
*/
free_buf(buf);
break;
}
default:
PMIXP_ERROR("Unknown message type %d", hdr->type);
break;
}
xfree(nodename);
}
static void _read_last_decay_ran(time_t *last_ran, time_t *last_reset)
{
int data_allocated, data_read = 0;
uint32_t data_size = 0;
int state_fd;
char *data = NULL, *state_file;
Buf buffer;
xassert(last_ran);
xassert(last_reset);
(*last_ran) = 0;
(*last_reset) = 0;
/* read the file */
state_file = xstrdup(slurmctld_conf.state_save_location);
xstrcat(state_file, "/priority_last_decay_ran");
lock_state_files();
state_fd = open(state_file, O_RDONLY);
if (state_fd < 0) {
info("No last decay (%s) to recover", state_file);
unlock_state_files();
return;
} else {
data_allocated = BUF_SIZE;
data = xmalloc(data_allocated);
while (1) {
data_read = read(state_fd, &data[data_size],
BUF_SIZE);
if (data_read < 0) {
if (errno == EINTR)
continue;
else {
error("Read error on %s: %m",
state_file);
break;
}
} else if (data_read == 0) /* eof */
break;
data_size += data_read;
data_allocated += data_read;
xrealloc(data, data_allocated);
}
close(state_fd);
}
xfree(state_file);
unlock_state_files();
buffer = create_buf(data, data_size);
safe_unpack_time(last_ran, buffer);
safe_unpack_time(last_reset, buffer);
free_buf(buffer);
if (priority_debug)
info("Last ran decay on jobs at %ld", (long)*last_ran);
return;
unpack_error:
error("Incomplete priority last decay file returning");
free_buf(buffer);
return;
}
int build_request(struct connection *conn)
{
char *url, *host, *p;
url = is_http(conn->url);
if (!url) {
#ifdef WANT_SSL
printf("Only http/https supported\n");
#else
printf("Only http supported\n");
#endif
return 1;
}
p = strchr(url, '/');
if (p) {
*p = '\0';
host = strdup(url);
*p = '/';
url = p;
} else {
host = strdup(url);
url = "/";
}
if (!host) {
printf("Out of memory\n");
return 1;
}
#ifdef REUSE_SOCKET
if (CONN_OPEN) {
if (hostcmp(conn->host, host)) {
if (verbose)
printf("New connection for %s\n", host);
release_connection(conn);
} else if (verbose)
printf("Reuse connection for %s\n", conn->host);
}
#endif
if (!get_buf(conn)) {
free(host);
return 1;
}
if (!CONN_OPEN)
if (open_socket(conn, host)) {
printf("Connection failed to %s\n", host);
free(host);
free_buf(conn);
return 1;
}
if (proxy)
snprintf(conn->buf, BUFSIZE, "%s http://%s/%s %s\r\n",
method, host, url, http);
else if (strchr(url, ' ')) {
/* Some sites cannot handle spaces in the url. */
int n = sprintf(conn->buf, "%s ", method);
char *in = url, *out = conn->buf + n;
while (*in)
if (*in == ' ') {
*out++ = '%';
*out++ = '2';
*out++ = '0';
++in;
} else
*out++ = *in++;
sprintf(out, " %s\r\n", http);
} else
snprintf(conn->buf, BUFSIZE, "%s %s %s\r\n", method, url, http);
add_full_header(conn, host);
free(host);
if (verbose > 1)
printf("%s %s", proxy ? ">P" : ">", conn->buf);
if (conn->referer)
sprintf(conn->buf + strlen(conn->buf),
"Referer: %.200s\r\n", conn->referer);
strcat(conn->buf, "\r\n");
conn->curp = conn->buf;
conn->length = strlen(conn->buf);
return 0;
}
extern Buf pack_slurmdbd_msg(slurmdbd_msg_t *req, uint16_t rpc_version)
{
Buf buffer;
if (rpc_version < SLURM_MIN_PROTOCOL_VERSION) {
error("slurmdbd: Invalid message version=%hu, type:%hu",
rpc_version, req->msg_type);
return NULL;
}
buffer = init_buf(MAX_DBD_MSG_LEN);
pack16(req->msg_type, buffer);
switch (req->msg_type) {
case REQUEST_PERSIST_INIT:
slurm_persist_pack_init_req_msg(req->data, buffer);
break;
case PERSIST_RC:
slurm_persist_pack_rc_msg(req->data, buffer, rpc_version);
break;
case DBD_ADD_ACCOUNTS:
case DBD_ADD_TRES:
case DBD_ADD_ASSOCS:
case DBD_ADD_CLUSTERS:
case DBD_ADD_FEDERATIONS:
case DBD_ADD_RES:
case DBD_ADD_USERS:
case DBD_GOT_ACCOUNTS:
case DBD_GOT_TRES:
case DBD_GOT_ASSOCS:
case DBD_GOT_CLUSTERS:
case DBD_GOT_EVENTS:
case DBD_GOT_FEDERATIONS:
case DBD_GOT_JOBS:
case DBD_GOT_LIST:
case DBD_GOT_PROBS:
case DBD_GOT_RES:
case DBD_ADD_QOS:
case DBD_GOT_QOS:
case DBD_GOT_RESVS:
case DBD_ADD_WCKEYS:
case DBD_GOT_WCKEYS:
case DBD_GOT_TXN:
case DBD_GOT_USERS:
case DBD_GOT_CONFIG:
case DBD_SEND_MULT_JOB_START:
case DBD_GOT_MULT_JOB_START:
case DBD_SEND_MULT_MSG:
case DBD_GOT_MULT_MSG:
case DBD_FIX_RUNAWAY_JOB:
slurmdbd_pack_list_msg(
(dbd_list_msg_t *)req->data, rpc_version,
req->msg_type, buffer);
break;
case DBD_ADD_ACCOUNT_COORDS:
case DBD_REMOVE_ACCOUNT_COORDS:
_pack_acct_coord_msg(
(dbd_acct_coord_msg_t *)req->data, rpc_version,
buffer);
break;
case DBD_ARCHIVE_LOAD:
slurmdb_pack_archive_rec(req->data, rpc_version, buffer);
break;
case DBD_CLUSTER_TRES:
case DBD_FLUSH_JOBS:
_pack_cluster_tres_msg(
(dbd_cluster_tres_msg_t *)req->data, rpc_version,
buffer);
break;
case DBD_GET_ACCOUNTS:
case DBD_GET_TRES:
case DBD_GET_ASSOCS:
case DBD_GET_CLUSTERS:
case DBD_GET_EVENTS:
case DBD_GET_FEDERATIONS:
case DBD_GET_JOBS_COND:
case DBD_GET_PROBS:
case DBD_GET_QOS:
case DBD_GET_RESVS:
case DBD_GET_RES:
case DBD_GET_TXN:
case DBD_GET_USERS:
case DBD_GET_WCKEYS:
case DBD_REMOVE_ACCOUNTS:
case DBD_REMOVE_ASSOCS:
case DBD_REMOVE_CLUSTERS:
case DBD_REMOVE_FEDERATIONS:
case DBD_REMOVE_QOS:
case DBD_REMOVE_RES:
case DBD_REMOVE_WCKEYS:
case DBD_REMOVE_USERS:
case DBD_ARCHIVE_DUMP:
_pack_cond_msg(
(dbd_cond_msg_t *)req->data, rpc_version, req->msg_type,
buffer);
break;
case DBD_GET_ASSOC_USAGE:
case DBD_GOT_ASSOC_USAGE:
case DBD_GET_CLUSTER_USAGE:
case DBD_GOT_CLUSTER_USAGE:
case DBD_GET_WCKEY_USAGE:
case DBD_GOT_WCKEY_USAGE:
slurmdbd_pack_usage_msg(
(dbd_usage_msg_t *)req->data, rpc_version,
req->msg_type, buffer);
break;
case DBD_FINI:
slurmdbd_pack_fini_msg((dbd_fini_msg_t *)req->data,
rpc_version, buffer);
break;
case DBD_JOB_COMPLETE:
_pack_job_complete_msg((dbd_job_comp_msg_t *)req->data,
rpc_version,
buffer);
break;
case DBD_JOB_START:
_pack_job_start_msg(req->data, rpc_version, buffer);
break;
case DBD_ID_RC:
slurmdbd_pack_id_rc_msg(req->data, rpc_version, buffer);
break;
case DBD_JOB_SUSPEND:
_pack_job_suspend_msg(
(dbd_job_suspend_msg_t *)req->data, rpc_version,
buffer);
break;
case DBD_MODIFY_ACCOUNTS:
case DBD_MODIFY_ASSOCS:
case DBD_MODIFY_CLUSTERS:
case DBD_MODIFY_FEDERATIONS:
case DBD_MODIFY_JOB:
case DBD_MODIFY_QOS:
case DBD_MODIFY_RES:
case DBD_MODIFY_USERS:
_pack_modify_msg(
(dbd_modify_msg_t *)req->data, rpc_version,
req->msg_type, buffer);
break;
case DBD_NODE_STATE:
_pack_node_state_msg(
(dbd_node_state_msg_t *)req->data, rpc_version,
buffer);
break;
case DBD_STEP_COMPLETE:
_pack_step_complete_msg(
(dbd_step_comp_msg_t *)req->data, rpc_version,
buffer);
break;
case DBD_STEP_START:
_pack_step_start_msg((dbd_step_start_msg_t *)req->data,
rpc_version,
buffer);
break;
case DBD_REGISTER_CTLD:
_pack_register_ctld_msg(
(dbd_register_ctld_msg_t *)req->data, rpc_version,
buffer);
break;
case DBD_ROLL_USAGE:
_pack_roll_usage_msg((dbd_roll_usage_msg_t *)req->data,
rpc_version,
buffer);
break;
case DBD_ADD_RESV:
case DBD_REMOVE_RESV:
case DBD_MODIFY_RESV:
_pack_rec_msg(
(dbd_rec_msg_t *)req->data, rpc_version, req->msg_type,
buffer);
break;
case DBD_GET_CONFIG:
packstr((char *)req->data, buffer);
break;
case DBD_RECONFIG:
case DBD_GET_STATS:
case DBD_CLEAR_STATS:
case DBD_SHUTDOWN:
break;
default:
error("slurmdbd: Invalid message type pack %u(%s:%u)",
req->msg_type,
slurmdbd_msg_type_2_str(req->msg_type, 1),
req->msg_type);
free_buf(buffer);
return NULL;
}
return buffer;
}
void
stretch(u8** image, BMP_HEADER* p_header, u8* color_buf, int width, int height)
{
char flag_bilinear, char_test;
int i, j;
float x_ratio, y_ratio, x, y;
printf("Give a float ratio to X-stretch (must > 0)\n");
/*
* no matter whether it's a '\n' in input-buf, SCANF ignores it
* except SCANF needs %c
*/
scanf("%f", &x_ratio);
/* eat the '\n' which user has typed follow a useful num */
while ((char_test = getchar()) != '\n' && char_test != EOF) ;
printf("Give a float ratio to Y-stretch (must > 0)\n");
scanf("%f", &y_ratio);
while ((char_test = getchar()) != '\n' && char_test != EOF) ;
printf("Choose one algorithm\n"
"[a] -> adjacent pixel\n"
"[b] -> bilinear interposition\n");
__asm__ __volatile__("4:");
while ((char_test = getchar()) != '\n' && char_test != EOF) {
flag_bilinear = char_test;
/* not *++bp, bp is a global-var */
*bp = '\n';
}
/* algorithm bilinear-interposition */
switch (flag_bilinear) {
case 'b':
flag_bilinear = 1;
break;
case 'a':
flag_bilinear = 0;
break;
default:
printf("Hey bro, type 'a' or 'b'\n");
__asm__ __volatile__("jmp 4b");
break;
}
int width_new = (int)(width * x_ratio);
int height_new = (int)(height * y_ratio);
u8* image_new[height_new];
width_pad(&width_new);
calloc_buf(image_new, width_new, height_new);
if (!flag_bilinear) {
int x_int, y_int;
for (i = 0; i < height_new; i++) {
y_int = (int)((float)i / y_ratio);
for (j = 0; j < width_new; j++) {
x_int = (int)((float)j / x_ratio);
if (x_int >= width)
/* why minus 1? see below */
x_int = width - 1;
if (y_int >= height)
y_int = height - 1;
/* here is the answer */
image_new[i][j] = image[y_int][x_int];
}
}
}
else {
for (i = 0; i < height_new; i++) {
y = ((float)i / y_ratio);
for (j = 0; j < width_new; j++) {
x = ((float)j / x_ratio);
if ((int)x >= width)
/* the same reason here */
x = width - 1;
if ((int)y >= height)
y = height - 1;
/* the same answer here */
image_new[i][j] = x - floor(x) || y - floor(y) ? \
bilinear_interposition(image, x, y, width, height) : \
image[(int)y][(int)x];
}
}
}
if (write_bmp_calloc(image_new, color_buf, width_new, height_new, p_header)) {
printf("Sorry, Stretch Failure!\n");
exit(EXIT_FAILURE);
}
free_buf(image_new, width_new, height_new);
printf("\nStretch Done!\tWhat's more?\n");
}
void do_skills(CHAR_DATA *ch, char *argument)
{
BUFFER *buffer;
char arg[MAX_INPUT_LENGTH];
char skill_list[LEVEL_HERO + 1][MAX_STRING_LENGTH];
char skill_columns[LEVEL_HERO + 1];
int sn, level, min_lev = 1, max_lev = LEVEL_HERO,p,gn,style_skill;
bool fAll = FALSE, found = FALSE, hide_skill=FALSE;
char buf[MAX_STRING_LENGTH];
if (IS_NPC(ch))
return;
if (argument[0] != '\0')
{
fAll = TRUE;
argument = one_argument(argument,arg);
if (is_number(arg))
{
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or name of skill.\n\r",ch);
return;
}
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (argument[0] != '\0')
{
argument = one_argument(argument,arg);
if (!is_number(arg))
{
send_to_char("Arguments must be numerical or name of skill.\n\r",ch);
return;
}
min_lev = max_lev;
max_lev = atoi(arg);
if (max_lev < 1 || max_lev > LEVEL_HERO)
{
sprintf(buf,
"Levels must be between 1 and %d.\n\r",LEVEL_HERO);
send_to_char(buf,ch);
return;
}
if (min_lev > max_lev)
{
send_to_char("That would be silly.\n\r",ch);
return;
}
}
} else {
if ((sn = skill_lookup(arg)) < 0)
return send_to_char("No such skill or spell.\n\r", ch);
if (ch->pcdata->learned[sn] == 0 ||
(ch->level < skill_table[sn].skill_level[ch->Class()->GetIndex()]) ||
((sn == gsn_gladiator_skill ||
sn == gsn_barbarian_skill ||
sn == gsn_duelist_skill ||
sn == gsn_skirmisher_skill ||
sn == gsn_dragoon_skill ||
sn == gsn_tactician_skill) && ch->level < AVATAR)) {
send_to_char("You are not learned in that.\n\r",ch);
}
else
{
sprintf(buf, "Your skill in '%s' is %d%%.\n\r",
skill_table[sn].name, ch->pcdata->learned[sn]);
send_to_char(buf, ch);
}
return;
}
}
/* initialize data */
for (level = 0; level < LEVEL_HERO + 1; level++)
{
skill_columns[level] = 0;
skill_list[level][0] = '\0';
}
for (sn = 0; sn < MAX_SKILL; sn++)
{
if (skill_table[sn].name == NULL )
break;
hide_skill=FALSE;
/*if ((level = skill_table[sn].skill_level[ch->Class()->GetIndex()]) < LEVEL_HERO + 1
&& (fAll || level <= ch->level)
&& level >= min_lev && level <= max_lev
&& skill_table[sn].spell_fun == spell_null
&& ch->pcdata->learned[sn] > 0)*/
if ((level = skill_table[sn].skill_level[ch->Class()->GetIndex()]) < LEVEL_HERO + 1
&& level >= min_lev && level <= max_lev
&& skill_table[sn].spell_fun == spell_null
&& ch->pcdata->learned[sn] > 0)
{
for(p=0; p<MAX_STYLE_SKILL; p++)
{
if(!str_prefix(style_percent[p].name, skill_table[sn].name))
{
gn = gn_skill_lookup(sn);
if(gn > 1)
{
style_skill = skill_lookup( group_table[gn].name );
if(ch->pcdata->learned[style_skill] < style_percent[p].percent)
hide_skill=TRUE;
if(hide_skill) break;
}
}
}
if ( sn == gsn_gladiator_skill || sn == gsn_duelist_skill ||
sn == gsn_barbarian_skill || sn == gsn_dragoon_skill ||
sn == gsn_skirmisher_skill || sn == gsn_tactician_skill)
hide_skill=TRUE;
found = TRUE;
level = skill_table[sn].skill_level[ch->Class()->GetIndex()];
if(!hide_skill)
{
if (ch->level < level)
sprintf(buf,"%-18s n/a ", skill_table[sn].name);
else
sprintf(buf,"%-18s %3d%% ",skill_table[sn].name,
ch->pcdata->learned[sn]);
if (skill_list[level][0] == '\0')
sprintf(skill_list[level],"\n\rLevel %2d: %s",level,buf);
else /* append */
{
if ( ++skill_columns[level] % 2 == 0)
strcat(skill_list[level],"\n\r ");
strcat(skill_list[level],buf);
}
}
}
}
/* return results */
if (!found)
{
send_to_char("No skills found.\n\r",ch);
return;
}
buffer = new_buf();
for (level = 0; level < LEVEL_HERO + 1; level++)
if (skill_list[level][0] != '\0')
add_buf(buffer,skill_list[level]);
add_buf(buffer,"\n\r");
page_to_char(buf_string(buffer),ch);
free_buf(buffer);
}
/*
* Bans a site from being able to login to the mud.
*/
void ban_site(CHAR_DATA * ch, char *argument, bool fPerm)
{
char buf[MAX_STRING_LENGTH], buf2[MAX_STRING_LENGTH];
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
char *name;
BUFFER *buffer;
BAN_DATA *pban, *prev;
bool prefix = FALSE, suffix = FALSE;
int type;
argument = one_argument(argument, arg1);
argument = one_argument(argument, arg2);
if (arg1[0] == '\0')
{
if (ban_list == NULL)
{
send_to_char("No sites banned at this time.\r\n", ch);
return;
}
buffer = new_buf();
add_buf(buffer, "Banned sites level type status\r\n");
for (pban = ban_list; pban != NULL; pban = pban->next)
{
sprintf(buf2, "%s%s%s",
IS_SET(pban->ban_flags, BAN_PREFIX) ? "*" : "",
pban->name,
IS_SET(pban->ban_flags, BAN_SUFFIX) ? "*" : "");
sprintf(buf, "%-12s %-3d %-7s %s\r\n",
buf2, pban->level,
IS_SET(pban->ban_flags, BAN_NEWBIES) ? "newbies" :
IS_SET(pban->ban_flags, BAN_PERMIT) ? "permit" :
IS_SET(pban->ban_flags, BAN_ALL) ? "all" : "",
IS_SET(pban->ban_flags,
BAN_PERMANENT) ? "perm" : "temp");
add_buf(buffer, buf);
}
page_to_char(buf_string(buffer), ch);
free_buf(buffer);
return;
}
/* find out what type of ban */
if (arg2[0] == '\0' || !str_prefix(arg2, "all"))
{
type = BAN_ALL;
}
else if (!str_prefix(arg2, "newbies"))
{
type = BAN_NEWBIES;
}
else if (!str_prefix(arg2, "permit"))
{
type = BAN_PERMIT;
}
else
{
send_to_char("Acceptable ban types are all, newbies, and permit.\r\n", ch);
return;
}
name = arg1;
if (name[0] == '*')
{
prefix = TRUE;
name++;
}
if (name[strlen(name) - 1] == '*')
{
suffix = TRUE;
name[strlen(name) - 1] = '\0';
}
if (strlen(name) == 0)
{
send_to_char("You have to ban SOMETHING.\r\n", ch);
return;
}
prev = NULL;
for (pban = ban_list; pban != NULL; prev = pban, pban = pban->next)
{
if (!str_cmp(name, pban->name))
{
if (pban->level > get_trust(ch))
{
send_to_char("That ban was set by a higher power.\r\n", ch);
return;
}
else
{
if (prev == NULL)
{
ban_list = pban->next;
}
else
{
prev->next = pban->next;
}
free_ban(pban);
}
}
}
pban = new_ban();
pban->name = str_dup(name);
pban->level = get_trust(ch);
/* set ban type */
pban->ban_flags = type;
if (prefix)
SET_BIT(pban->ban_flags, BAN_PREFIX);
if (suffix)
SET_BIT(pban->ban_flags, BAN_SUFFIX);
if (fPerm)
SET_BIT(pban->ban_flags, BAN_PERMANENT);
pban->next = ban_list;
ban_list = pban;
save_bans();
sprintf(buf, "%s has been banned.\r\n", pban->name);
send_to_char(buf, ch);
return;
} // end ban_site
/* ring_out messages come in from our parent,
* we process this and send ring_out messages to each of our children:
* count - starting rank for our leftmost application process
* left - left value for leftmost application process in our subtree
* right - right value for rightmost application process in our subtree */
int pmix_ring_out(int count, char* left, char* right)
{
int rc = SLURM_SUCCESS;
debug3("mpi/pmi2: in pmix_ring_out rank=%d count=%d left=%s right=%s",
pmix_stepd_rank, count, left, right);
/* our parent will send us a pmix_ring_out message, the count value
* contained in this message will be the rank of the first process
* in our subtree, the left value will be the left value for the
* first process in the subtree, and the right value will be the
* right value for the last process in our subtree */
/* allocate a structure to compute values to send to each child */
pmix_ring_msg* outmsgs = (pmix_ring_msg*) xmalloc(pmix_ring_children * sizeof(pmix_ring_msg));
/* initialize messages to all children */
int i;
for (i = 0; i < pmix_ring_children; i++) {
outmsgs[i].count = 0;
outmsgs[i].left = NULL;
outmsgs[i].right = NULL;
}
/* iterate over all msgs and set count and left neighbor */
for (i = 0; i < pmix_ring_children; i++) {
/* store current count in output message */
outmsgs[i].count = count;
/* add count for this child to our running total */
count += pmix_ring_msgs[i].count;
/* set left value for this child */
outmsgs[i].left = left;
/* get right value from child, if it exists,
* it will be the left neighbor of the next child,
* otherwise, reuse the current left value */
char* next = pmix_ring_msgs[i].right;
if (next != NULL) {
left = next;
}
}
/* now set all right values (iterate backwards through children) */
for (i = (pmix_ring_children - 1); i >= 0; i--) {
/* set right value for this child */
outmsgs[i].right = right;
/* get left value from child, if it exists,
* it will be the right neighbor of the next child,
* otherwise, reuse the current right value */
char* next = pmix_ring_msgs[i].left;
if (next != NULL) {
right = next;
}
}
/* send messages to children in stepd tree,
* we do this first to get the message down the tree quickly */
for (i = 0; i < pmix_stepd_children; i++) {
/* get pointer to message data for this child */
int ring_id = pmix_app_children + i;
pmix_ring_msg* msg = &outmsgs[ring_id];
/* TODO: do we need hton translation? */
/* construct message */
Buf buf = init_buf(1024);
pack16(TREE_CMD_RING_RESP, buf); /* specify message type (RING_OUT) */
pack32((uint32_t) msg->count, buf); /* send count value */
packstr(msg->left, buf); /* send left value */
packstr(msg->right, buf); /* send right value */
/* get global rank of our i-th child stepd */
int rank = pmix_stepd_rank_child(i);
debug3("mpi/pmi2: rank=%d sending RING_OUT to rank=%d count=%d left=%s right=%s",
pmix_stepd_rank, rank, msg->count, msg->left, msg->right);
/* send message to child */
rc = pmix_stepd_send(get_buf_data(buf), (uint32_t) size_buf(buf), rank);
/* TODO: use tmp_rc here to catch any failure */
/* free message */
free_buf(buf);
}
/* now send messages to children app procs,
* and set their state back to normal */
for (i = 0; i < pmix_app_children; i++) {
/* get pointer to message data for this child */
pmix_ring_msg* msg = &outmsgs[i];
/* TODO: want to catch send failure here? */
/* construct message and send to client */
client_resp_t *resp = client_resp_new();
client_resp_append(resp, "%s=%s;%s=%d;%s=%d;%s=%s;%s=%s;",
CMD_KEY, RINGRESP_CMD,
RC_KEY, 0,
RING_COUNT_KEY, msg->count,
RING_LEFT_KEY, msg->left,
RING_RIGHT_KEY, msg->right);
client_resp_send(resp, STEPD_PMI_SOCK(i));
client_resp_free(resp);
}
/* delete messages, note that we don't need to free
* left and right strings in each message since they
* are pointers to strings allocated in pmix_ring_msgs */
xfree(outmsgs);
/* clear the pmix_ring_in messages for next ring operation */
for (i = 0; i < pmix_ring_children; i++) {
pmix_ring_msg* msg = &pmix_ring_msgs[i];
msg->count = 0;
if (msg->left != NULL) {
xfree(msg->left);
msg->left = NULL;
}
if (msg->right != NULL) {
xfree(msg->right);
msg->right = NULL;
}
}
/* reset our ring count */
pmix_ring_count = 0;
debug3("mpi/pmi2: out pmix_ring_out");
return rc;
}
extern int jobacctinfo_getinfo(
jobacctinfo_t *jobacct, enum jobacct_data_type type, void *data,
uint16_t protocol_version)
{
int rc = SLURM_SUCCESS;
int *fd = (int *)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 rusage *rusage = (struct rusage *)data;
struct jobacctinfo *send = (struct jobacctinfo *) data;
if (!plugin_polling)
return SLURM_SUCCESS;
/* jobacct needs to be allocated before this is called. */
xassert(jobacct);
switch (type) {
case JOBACCT_DATA_TOTAL:
memcpy(send, jobacct, sizeof(struct jobacctinfo));
break;
case JOBACCT_DATA_PIPE:
if (protocol_version >= SLURM_14_03_PROTOCOL_VERSION) {
char* buf;
int len;
Buf buffer;
safe_read(*fd, &len, sizeof(int));
buf = xmalloc(len);
safe_read(*fd, buf, len);
buffer = create_buf(buf, len);
jobacctinfo_unpack(&jobacct, protocol_version,
PROTOCOL_TYPE_SLURM, buffer, 0);
free_buf(buffer);
} else if (protocol_version >= SLURM_2_6_PROTOCOL_VERSION) {
safe_read(*fd, &jobacct->user_cpu_sec,
sizeof(uint32_t));
safe_read(*fd, &jobacct->user_cpu_usec,
sizeof(uint32_t));
safe_read(*fd, &jobacct->sys_cpu_sec, sizeof(uint32_t));
safe_read(*fd, &jobacct->sys_cpu_usec,
sizeof(uint32_t));
safe_read(*fd, &jobacct->max_vsize, sizeof(uint32_t));
safe_read(*fd, &jobacct->tot_vsize, sizeof(uint32_t));
safe_read(*fd, &jobacct->max_rss, sizeof(uint32_t));
safe_read(*fd, &jobacct->tot_rss, sizeof(uint32_t));
safe_read(*fd, &jobacct->max_pages, sizeof(uint32_t));
safe_read(*fd, &jobacct->tot_pages, sizeof(uint32_t));
safe_read(*fd, &jobacct->min_cpu, sizeof(uint32_t));
safe_read(*fd, &jobacct->tot_cpu, sizeof(uint32_t));
safe_read(*fd, &jobacct->act_cpufreq, sizeof(uint32_t));
safe_read(*fd, &jobacct->energy.consumed_energy,
sizeof(uint32_t));
safe_read(*fd, &jobacct->max_disk_read, sizeof(double));
safe_read(*fd, &jobacct->tot_disk_read, sizeof(double));
safe_read(*fd, &jobacct->max_disk_write,
sizeof(double));
safe_read(*fd, &jobacct->tot_disk_write,
sizeof(double));
_read_jobacct_id(*fd, &jobacct->max_vsize_id,
protocol_version);
_read_jobacct_id(*fd, &jobacct->max_rss_id,
protocol_version);
_read_jobacct_id(*fd, &jobacct->max_pages_id,
protocol_version);
_read_jobacct_id(*fd, &jobacct->min_cpu_id,
protocol_version);
_read_jobacct_id(*fd, &jobacct->max_disk_read_id,
protocol_version);
_read_jobacct_id(*fd, &jobacct->max_disk_write_id,
protocol_version);
}
break;
case JOBACCT_DATA_RUSAGE:
memset(rusage, 0, sizeof(struct rusage));
rusage->ru_utime.tv_sec = jobacct->user_cpu_sec;
rusage->ru_utime.tv_usec = jobacct->user_cpu_usec;
rusage->ru_stime.tv_sec = jobacct->sys_cpu_sec;
rusage->ru_stime.tv_usec = jobacct->sys_cpu_usec;
break;
case JOBACCT_DATA_MAX_RSS:
*uint64 = jobacct->max_rss;
break;
case JOBACCT_DATA_MAX_RSS_ID:
*jobacct_id = jobacct->max_rss_id;
break;
case JOBACCT_DATA_TOT_RSS:
*uint64 = jobacct->tot_rss;
break;
case JOBACCT_DATA_MAX_VSIZE:
*uint64 = jobacct->max_vsize;
break;
case JOBACCT_DATA_MAX_VSIZE_ID:
*jobacct_id = jobacct->max_vsize_id;
break;
case JOBACCT_DATA_TOT_VSIZE:
*uint64 = jobacct->tot_vsize;
break;
case JOBACCT_DATA_MAX_PAGES:
*uint64 = jobacct->max_pages;
break;
case JOBACCT_DATA_MAX_PAGES_ID:
*jobacct_id = jobacct->max_pages_id;
break;
case JOBACCT_DATA_TOT_PAGES:
*uint64 = jobacct->tot_pages;
break;
case JOBACCT_DATA_MIN_CPU:
*uint32 = jobacct->min_cpu;
break;
case JOBACCT_DATA_MIN_CPU_ID:
*jobacct_id = jobacct->min_cpu_id;
break;
case JOBACCT_DATA_TOT_CPU:
*uint32 = jobacct->tot_cpu;
break;
case JOBACCT_DATA_ACT_CPUFREQ:
*uint32 = jobacct->act_cpufreq;
break;
case JOBACCT_DATA_CONSUMED_ENERGY:
*uint32 = jobacct->energy.consumed_energy;
break;
case JOBACCT_DATA_MAX_DISK_READ:
*dub = jobacct->max_disk_read;
break;
case JOBACCT_DATA_MAX_DISK_READ_ID:
*jobacct_id = jobacct->max_disk_read_id;
break;
case JOBACCT_DATA_TOT_DISK_READ:
*dub = jobacct->tot_disk_read;
break;
case JOBACCT_DATA_MAX_DISK_WRITE:
*dub = jobacct->max_disk_write;
break;
case JOBACCT_DATA_MAX_DISK_WRITE_ID:
*jobacct_id = jobacct->max_disk_write_id;
break;
case JOBACCT_DATA_TOT_DISK_WRITE:
*dub = jobacct->tot_disk_write;
break;
default:
debug("jobacct_g_set_getinfo data_type %d invalid", type);
}
return rc;
rwfail:
return SLURM_ERROR;
}
/* we get a ring_in message from each child (stepd and application tasks),
* once we've gotten a message from each child, we send a ring_in message
* to our parent
* ring_id - index of child (all app procs first, followed by stepds)
* count - count value from child
* left - left value from child
* right - right value from child
*
* upon receiving ring_in messages from all children, we send a ring_in
* message to our parent consisting of:
* rank = our rank in stepd tree (so parent knows which child msg is from)
* count = sum of counts from all children
* left = left value from leftmost child
* right = right value from rightmost child */
int pmix_ring_in(int ring_id, int count, char* left, char* right)
{
int i;
int rc = SLURM_SUCCESS;
debug3("mpi/pmi2: in pmix_ring_in rank=%d ring_id=%d count=%d left=%s right=%s",
pmix_stepd_rank, ring_id, count, left, right);
/* record values from child's ring_in message */
pmix_ring_msg* msg = &pmix_ring_msgs[ring_id];
msg->count = count;
msg->left = xstrdup(left);
msg->right = xstrdup(right);
/* update our running count of received ring_in messages */
pmix_ring_count++;
/* if we have received a ring_in message from each app process
* and each stepd child, forward a ring_in message to our
* parent in the stepd tree */
if (pmix_ring_count == pmix_ring_children) {
/* each stepd has at least one application process
* so each has at least one child */
/* lookup leftmost value from all children,
* take left value from leftmost process */
char* leftmost = pmix_ring_msgs[0].left;
/* lookup rightmost value from all children,
* take right value from rightmost process */
int right_id = pmix_ring_children - 1;
char* rightmost = pmix_ring_msgs[right_id].right;
/* total count values across all children */
uint32_t sum = 0;
for (i = 0; i < pmix_ring_children; i++) {
sum += (uint32_t) pmix_ring_msgs[i].count;
}
/* send to parent if we have one, otherwise create ring output
* message and start the broadcast */
if (pmix_stepd_rank > 0) {
/* include our global rank in message so parent can
* determine which child we are */
uint32_t my_rank = (uint32_t) pmix_stepd_rank;
/* TODO: do we need hton translation? */
/* construct message */
Buf buf = init_buf(1024);
pack16(TREE_CMD_RING, buf); /* specify message type (RING_IN) */
pack32(my_rank, buf); /* send our rank */
pack32(sum, buf); /* send count value */
packstr(leftmost, buf); /* send left value */
packstr(rightmost, buf); /* send right value */
/* get global rank of our parent stepd */
int rank = pmix_stepd_rank_parent();
debug3("mpi/pmi2: rank=%d sending RING_IN to rank=%d count=%d left=%s right=%s",
my_rank, rank, count, leftmost, rightmost);
/* send message to parent */
rc = pmix_stepd_send(get_buf_data(buf), (uint32_t) size_buf(buf), rank);
/* TODO: use tmp_rc here to catch any failure */
/* free message */
free_buf(buf);
} else {
/* we're the root of the tree, send values back down */
/* at the top level, we wrap the ends to create a ring,
* setting the rightmost process to be the left neighbor
* of the leftmost process */
/* we start the top of the tree at offset 0 */
/* simulate reception of a ring output msg */
pmix_ring_out(0, rightmost, leftmost);
}
}
debug3("mpi/pmi2: out pmix_ring_in");
return rc;
}
/* Send an RPC to the SlurmDBD. Do not wait for the reply. The RPC
* will be queued and processed later if the SlurmDBD is not responding.
* NOTE: slurm_open_slurmdbd_conn() must have been called with callbacks set
*
* Returns SLURM_SUCCESS or an error code */
extern int send_slurmdbd_msg(uint16_t rpc_version, slurmdbd_msg_t *req)
{
Buf buffer;
int cnt, rc = SLURM_SUCCESS;
static time_t syslog_time = 0;
static int max_agent_queue = 0;
/*
* Whatever our max job count is multiplied by 2 plus node count
* multiplied by 4 or MAX_AGENT_QUEUE which ever is bigger.
*/
if (!max_agent_queue)
max_agent_queue =
MAX(MAX_AGENT_QUEUE,
((slurmctld_conf.max_job_cnt * 2) +
(node_record_count * 4)));
buffer = slurm_persist_msg_pack(
slurmdbd_conn, (persist_msg_t *)req);
if (!buffer) /* pack error */
return SLURM_ERROR;
slurm_mutex_lock(&agent_lock);
if ((agent_tid == 0) || (agent_list == NULL)) {
_create_agent();
if ((agent_tid == 0) || (agent_list == NULL)) {
slurm_mutex_unlock(&agent_lock);
free_buf(buffer);
return SLURM_ERROR;
}
}
cnt = list_count(agent_list);
if ((cnt >= (max_agent_queue / 2)) &&
(difftime(time(NULL), syslog_time) > 120)) {
/* Record critical error every 120 seconds */
syslog_time = time(NULL);
error("slurmdbd: agent queue filling (%d), RESTART SLURMDBD NOW",
cnt);
syslog(LOG_CRIT, "*** RESTART SLURMDBD NOW ***");
if (slurmdbd_conn->trigger_callbacks.dbd_fail)
(slurmdbd_conn->trigger_callbacks.dbd_fail)();
}
if (cnt == (max_agent_queue - 1))
cnt -= _purge_step_req();
if (cnt == (max_agent_queue - 1))
cnt -= _purge_job_start_req();
if (cnt < max_agent_queue) {
if (list_enqueue(agent_list, buffer) == NULL)
fatal("list_enqueue: memory allocation failure");
} else {
error("slurmdbd: agent queue is full (%u), discarding %s:%u request",
cnt,
slurmdbd_msg_type_2_str(req->msg_type, 1),
req->msg_type);
if (slurmdbd_conn->trigger_callbacks.acct_full)
(slurmdbd_conn->trigger_callbacks.acct_full)();
free_buf(buffer);
rc = SLURM_ERROR;
}
slurm_cond_broadcast(&agent_cond);
slurm_mutex_unlock(&agent_lock);
return rc;
}
/*
* This function runs in the context of the background proxy process.
* Receive a control message from the parent (sent by the port_share_sendmsg
* function above) and act on it. Return false if the proxy process should
* exit, true otherwise.
*/
static bool
control_message_from_parent (const socket_descriptor_t sd_control,
struct proxy_connection **list,
struct event_set *es,
const in_addr_t server_addr,
const int server_port)
{
struct buffer buf = alloc_buf (PROXY_CONNECTION_BUFFER_SIZE);
struct msghdr mesg;
struct cmsghdr* h;
struct iovec iov[2];
char command = 0;
ssize_t status;
int ret = true;
CLEAR (mesg);
iov[0].iov_base = &command;
iov[0].iov_len = sizeof (command);
iov[1].iov_base = BPTR (&buf);
iov[1].iov_len = BCAP (&buf);
mesg.msg_iov = iov;
mesg.msg_iovlen = 2;
mesg.msg_controllen = cmsg_size ();
mesg.msg_control = (char *) malloc (mesg.msg_controllen);
check_malloc_return (mesg.msg_control);
mesg.msg_flags = 0;
h = CMSG_FIRSTHDR(&mesg);
h->cmsg_len = CMSG_LEN(sizeof(socket_descriptor_t));
h->cmsg_level = SOL_SOCKET;
h->cmsg_type = SCM_RIGHTS;
*((socket_descriptor_t*)CMSG_DATA(h)) = SOCKET_UNDEFINED;
status = recvmsg (sd_control, &mesg, MSG_NOSIGNAL);
if (status != -1)
{
if ( h == NULL
|| h->cmsg_len != CMSG_LEN(sizeof(socket_descriptor_t))
|| h->cmsg_level != SOL_SOCKET
|| h->cmsg_type != SCM_RIGHTS )
{
ret = false;
}
else
{
const socket_descriptor_t received_fd = *((socket_descriptor_t*)CMSG_DATA(h));
dmsg (D_PS_PROXY_DEBUG, "PORT SHARE PROXY: RECEIVED sd=%d", (int)received_fd);
if (status >= 2 && command == COMMAND_REDIRECT)
{
buf.len = status - 1;
if (proxy_entry_new (list,
es,
server_addr,
server_port,
received_fd,
&buf))
{
CLEAR (buf); /* we gave the buffer to proxy_entry_new */
}
else
{
openvpn_close_socket (received_fd);
}
}
else if (status >= 1 && command == COMMAND_EXIT)
{
dmsg (D_PS_PROXY_DEBUG, "PORT SHARE PROXY: RECEIVED COMMAND_EXIT");
openvpn_close_socket (received_fd); /* null socket */
ret = false;
}
}
}
free (mesg.msg_control);
free_buf (&buf);
return ret;
}
static void _load_dbd_state(void)
{
char *dbd_fname;
Buf buffer;
int fd, recovered = 0;
uint16_t rpc_version = 0;
dbd_fname = slurm_get_state_save_location();
xstrcat(dbd_fname, "/dbd.messages");
fd = open(dbd_fname, O_RDONLY);
if (fd < 0) {
/* don't print an error message if there is no file */
if (errno == ENOENT)
debug4("slurmdbd: There is no state save file to "
"open by name %s", dbd_fname);
else
error("slurmdbd: Opening state save file %s: %m",
dbd_fname);
} else {
char *ver_str = NULL;
uint32_t ver_str_len;
buffer = _load_dbd_rec(fd);
if (buffer == NULL)
goto end_it;
/* This is set to the end of the buffer for send so we
need to set it back to 0 */
set_buf_offset(buffer, 0);
safe_unpackstr_xmalloc(&ver_str, &ver_str_len, buffer);
debug3("Version string in dbd_state header is %s", ver_str);
unpack_error:
free_buf(buffer);
buffer = NULL;
if (ver_str) {
/* get the version after VER */
rpc_version = slurm_atoul(ver_str + 3);
xfree(ver_str);
}
while (1) {
/* If the buffer was not the VER%d string it
was an actual message so we don't want to
skip it.
*/
if (!buffer)
buffer = _load_dbd_rec(fd);
if (buffer == NULL)
break;
if (rpc_version != SLURM_PROTOCOL_VERSION) {
/* unpack and repack with new
* PROTOCOL_VERSION just so we keep
* things up to date.
*/
slurmdbd_msg_t msg;
int rc;
set_buf_offset(buffer, 0);
rc = unpack_slurmdbd_msg(
&msg, rpc_version, buffer);
free_buf(buffer);
if (rc == SLURM_SUCCESS)
buffer = pack_slurmdbd_msg(
&msg, SLURM_PROTOCOL_VERSION);
else
buffer = NULL;
}
if (!buffer) {
error("no buffer given");
continue;
}
if (!list_enqueue(agent_list, buffer))
fatal("slurmdbd: list_enqueue, no memory");
recovered++;
buffer = NULL;
}
end_it:
verbose("slurmdbd: recovered %d pending RPCs", recovered);
(void) close(fd);
}
xfree(dbd_fname);
}
extern int fed_mgr_state_save(char *state_save_location)
{
int error_code = 0, log_fd;
char *old_file = NULL, *new_file = NULL, *reg_file = NULL;
slurmctld_lock_t fed_read_lock = {
NO_LOCK, NO_LOCK, NO_LOCK, NO_LOCK, READ_LOCK };
Buf buffer = init_buf(0);
DEF_TIMERS;
START_TIMER;
/* write header: version, time */
pack16(SLURM_PROTOCOL_VERSION, buffer);
pack_time(time(NULL), buffer);
lock_slurmctld(fed_read_lock);
slurmdb_pack_federation_rec(fed_mgr_fed_rec, SLURM_PROTOCOL_VERSION,
buffer);
unlock_slurmctld(fed_read_lock);
/* write the buffer to file */
reg_file = xstrdup_printf("%s/%s", state_save_location,
FED_MGR_STATE_FILE);
old_file = xstrdup_printf("%s.old", reg_file);
new_file = xstrdup_printf("%s.new", reg_file);
log_fd = creat(new_file, 0600);
if (log_fd < 0) {
error("Can't save state, create file %s error %m", new_file);
error_code = errno;
} else {
int pos = 0, nwrite = get_buf_offset(buffer), amount;
char *data = (char *)get_buf_data(buffer);
while (nwrite > 0) {
amount = write(log_fd, &data[pos], nwrite);
if ((amount < 0) && (errno != EINTR)) {
error("Error writing file %s, %m", new_file);
error_code = errno;
break;
}
nwrite -= amount;
pos += amount;
}
fsync(log_fd);
close(log_fd);
}
if (error_code)
(void) unlink(new_file);
else { /* file shuffle */
(void) unlink(old_file);
if (link(reg_file, old_file))
debug4("unable to create link for %s -> %s: %m",
reg_file, old_file);
(void) unlink(reg_file);
if (link(new_file, reg_file))
debug4("unable to create link for %s -> %s: %m",
new_file, reg_file);
(void) unlink(new_file);
}
xfree(old_file);
xfree(reg_file);
xfree(new_file);
free_buf(buffer);
END_TIMER2("fed_mgr_state_save");
return error_code;
}
/* Send an RPC to the SlurmDBD and wait for an arbitrary reply message.
* The RPC will not be queued if an error occurs.
* The "resp" message must be freed by the caller.
* Returns SLURM_SUCCESS or an error code */
extern int send_recv_slurmdbd_msg(uint16_t rpc_version,
slurmdbd_msg_t *req,
slurmdbd_msg_t *resp)
{
int rc = SLURM_SUCCESS;
Buf buffer;
xassert(req);
xassert(resp);
/* To make sure we can get this to send instead of the agent
sending stuff that can happen anytime we set halt_agent and
then after we get into the mutex we unset.
*/
halt_agent = 1;
slurm_mutex_lock(&slurmdbd_lock);
halt_agent = 0;
if (!slurmdbd_conn || (slurmdbd_conn->fd < 0)) {
/* Either slurm_open_slurmdbd_conn() was not executed or
* the connection to Slurm DBD has been closed */
if (req->msg_type == DBD_GET_CONFIG)
_open_slurmdbd_conn(0);
else
_open_slurmdbd_conn(1);
if (!slurmdbd_conn || (slurmdbd_conn->fd < 0)) {
rc = SLURM_ERROR;
goto end_it;
}
}
if (!(buffer = pack_slurmdbd_msg(req, rpc_version))) {
rc = SLURM_ERROR;
goto end_it;
}
rc = slurm_persist_send_msg(slurmdbd_conn, buffer);
free_buf(buffer);
if (rc != SLURM_SUCCESS) {
error("slurmdbd: Sending message type %s: %d: %m",
rpc_num2string(req->msg_type), rc);
goto end_it;
}
buffer = slurm_persist_recv_msg(slurmdbd_conn);
if (buffer == NULL) {
error("slurmdbd: Getting response to message type %u",
req->msg_type);
rc = SLURM_ERROR;
goto end_it;
}
rc = unpack_slurmdbd_msg(resp, rpc_version, buffer);
/* check for the rc of the start job message */
if (rc == SLURM_SUCCESS && resp->msg_type == DBD_ID_RC)
rc = ((dbd_id_rc_msg_t *)resp->data)->return_code;
free_buf(buffer);
end_it:
slurm_cond_signal(&slurmdbd_cond);
slurm_mutex_unlock(&slurmdbd_lock);
return rc;
}
extern slurmdb_federation_rec_t *fed_mgr_state_load(char *state_save_location)
{
Buf buffer = NULL;
char *data = NULL, *state_file;
time_t buf_time;
uint16_t ver = 0;
uint32_t data_size = 0;
int state_fd;
int data_allocated, data_read = 0, error_code = SLURM_SUCCESS;
slurmdb_federation_rec_t *ret_fed = NULL;
state_file = xstrdup_printf("%s/%s", state_save_location,
FED_MGR_STATE_FILE);
state_fd = open(state_file, O_RDONLY);
if (state_fd < 0) {
error("No fed_mgr state file (%s) to recover", state_file);
xfree(state_file);
return NULL;
} else {
data_allocated = BUF_SIZE;
data = xmalloc(data_allocated);
while (1) {
data_read = read(state_fd, &data[data_size],
BUF_SIZE);
if (data_read < 0) {
if (errno == EINTR)
continue;
else {
error("Read error on %s: %m",
state_file);
break;
}
} else if (data_read == 0) /* eof */
break;
data_size += data_read;
data_allocated += data_read;
xrealloc(data, data_allocated);
}
close(state_fd);
}
xfree(state_file);
buffer = create_buf(data, data_size);
safe_unpack16(&ver, buffer);
debug3("Version in fed_mgr_state header is %u", ver);
if (ver > SLURM_PROTOCOL_VERSION || ver < SLURM_MIN_PROTOCOL_VERSION) {
error("***********************************************");
error("Can not recover fed_mgr state, incompatible version, "
"got %u need > %u <= %u", ver,
SLURM_MIN_PROTOCOL_VERSION, SLURM_PROTOCOL_VERSION);
error("***********************************************");
free_buf(buffer);
return NULL;
}
safe_unpack_time(&buf_time, buffer);
error_code = slurmdb_unpack_federation_rec((void **)&ret_fed, ver,
buffer);
if (error_code != SLURM_SUCCESS)
goto unpack_error;
else if (!ret_fed || !ret_fed->name ||
!list_count(ret_fed->cluster_list)) {
slurmdb_destroy_federation_rec(ret_fed);
ret_fed = NULL;
error("No feds retrieved");
} else {
/* We want to free the connections here since they don't exist
* anymore, but they were packed when state was saved. */
slurmdb_cluster_rec_t *cluster;
ListIterator itr = list_iterator_create(
ret_fed->cluster_list);
while ((cluster = list_next(itr))) {
slurm_persist_conn_destroy(cluster->fed.recv);
cluster->fed.recv = NULL;
slurm_persist_conn_destroy(cluster->fed.send);
cluster->fed.send = NULL;
}
list_iterator_destroy(itr);
}
free_buf(buffer);
return ret_fed;
unpack_error:
free_buf(buffer);
return NULL;
}
static void *
_handle_accept(void *arg)
{
/*struct request_params *param = (struct request_params *)arg;*/
int fd = ((struct request_params *)arg)->fd;
stepd_step_rec_t *job = ((struct request_params *)arg)->job;
int req;
int len;
Buf buffer;
void *auth_cred;
int rc;
uid_t uid;
gid_t gid;
debug3("Entering _handle_accept (new thread)");
xfree(arg);
safe_read(fd, &req, sizeof(int));
if (req != REQUEST_CONNECT) {
error("First message must be REQUEST_CONNECT");
goto fail;
}
safe_read(fd, &len, sizeof(int));
buffer = init_buf(len);
safe_read(fd, get_buf_data(buffer), len);
/* Unpack and verify the auth credential */
auth_cred = g_slurm_auth_unpack(buffer);
if (auth_cred == NULL) {
error("Unpacking authentication credential: %s",
g_slurm_auth_errstr(g_slurm_auth_errno(NULL)));
free_buf(buffer);
goto fail;
}
rc = g_slurm_auth_verify(auth_cred, NULL, 2, NULL);
if (rc != SLURM_SUCCESS) {
error("Verifying authentication credential: %s",
g_slurm_auth_errstr(g_slurm_auth_errno(auth_cred)));
(void) g_slurm_auth_destroy(auth_cred);
free_buf(buffer);
goto fail;
}
/* Get the uid & gid from the credential, then destroy it. */
uid = g_slurm_auth_get_uid(auth_cred, NULL);
gid = g_slurm_auth_get_gid(auth_cred, NULL);
debug3(" Identity: uid=%d, gid=%d", uid, gid);
g_slurm_auth_destroy(auth_cred);
free_buf(buffer);
rc = SLURM_PROTOCOL_VERSION;
safe_write(fd, &rc, sizeof(int));
while (1) {
rc = _handle_request(fd, job, uid, gid);
if (rc != SLURM_SUCCESS)
break;
}
if (close(fd) == -1)
error("Closing accepted fd: %m");
pthread_mutex_lock(&message_lock);
message_connections--;
pthread_cond_signal(&message_cond);
pthread_mutex_unlock(&message_lock);
debug3("Leaving _handle_accept");
return NULL;
fail:
rc = SLURM_FAILURE;
safe_write(fd, &rc, sizeof(int));
rwfail:
if (close(fd) == -1)
error("Closing accepted fd after error: %m");
debug("Leaving _handle_accept on an error");
return NULL;
}
void
rotate(u8** image, BMP_HEADER* p_header, u8* color_buf, int width, int height)
{
char char_test;
int i, j, flag_rotate;
float angle, x, y;
printf("Give a rotate angle (whatever >0 or <0)\n");
scanf("%f", &angle);
while ((char_test = getchar()) != '\n' && char_test != EOF) ;
printf("Choose one algorithm\n"
"[a] -> adjacent pixel\n"
"[b] -> bilinear interposition\n");
__asm__ __volatile__("5:");
while ((char_test = getchar()) != '\n' && char_test != EOF) {
flag_rotate = char_test;
/* not *++bp, bp is a global-var */
*bp = '\n';
}
switch (flag_rotate) {
case 'b':
flag_rotate = 1;
break;
case 'a':
flag_rotate = 0;
break;
default:
printf("Hey bro, type 'a' or 'b'\n");
__asm__ __volatile__("jmp 5b");
break;
}
float radian = RADIAN(angle);
float sina = sin(radian);
float cosa = cos(radian);
/*
* y Original Image -- regard (x1, y1) as (0, 0)
*
* ^
* |
* |
* |
* |
* |(x2, y2) (x4, y4)
* ..................................
* . .
* . .
* . .
* . .
* . .
* .(x1, y1) -- axis . (x3, y3)
* ..................................----------> x */
/* after anti-clock-wise rotation */
float x1 = 0;
float x2 = 0 - height * sina;
float x3 = 0 + width * cosa;
float x4 = 0 + width * cosa - height * sina;
float y1 = 0;
float y2 = 0 + height * cosa;
float y3 = 0 + width * sina;
float y4 = 0 + width * sina + height * cosa;
/*
* make sure that the image always locate
* in active-x-axis'n active-y-axis
* so we need to know how far they get away
*/
float x_offset = MAX(MAX(-x2, -x3), -x4);
float y_offset = MAX(MAX(-y2, -y3), -y4);
x_offset = x_offset > 0 ? x_offset : 0;
y_offset = y_offset > 0 ? y_offset : 0;
int width_new = ceil(MAX(fabs(x1 - x4), fabs(x2 - x3)));
int height_new = ceil(MAX(fabs(y1 - y4), fabs(y2 - y3)));
u8* image_new[height_new];
/* fill up */
width_pad(&width_new);
/* everything for making a new image has done, now calloc */
calloc_buf(image_new, width_new, height_new);
/* control every pixels in image new, not image original */
for (i = 0; i < height_new; i++) {
for (j = 0; j < width_new; j++) {
/* it's image new here, so clock-wise */
x = ( (j - x_offset) * cosa + (i - y_offset) * sina);
y = (- (j - x_offset) * sina + (i - y_offset) * cosa);
/*
* if the pixel in image new has the corresponding pixel in
* image original, we evaluate it, other wise, next one
*/
/* no equals */
if (y >= 0 && y < height && x >= 0 && x < width) {
image_new[i][j] = flag_rotate ? \
bilinear_interposition(image, x, y, width, height) : \
image[(int)y][(int)x];
}
}
}
if (write_bmp_calloc(image_new, color_buf, width_new, height_new, p_header)) {
printf("Sorry, Failure!\n");
exit(EXIT_FAILURE);
}
free_buf(image_new, width_new, height_new);
printf("\nRotate Done!\tWhat's more?\n");
}
/* dump_all_front_end_state - save the state of all front_end nodes to file */
extern int dump_all_front_end_state(void)
{
#ifdef HAVE_FRONT_END
/* Save high-water mark to avoid buffer growth with copies */
static int high_buffer_size = (1024 * 1024);
int error_code = 0, i, log_fd;
char *old_file, *new_file, *reg_file;
front_end_record_t *front_end_ptr;
/* Locks: Read config and node */
slurmctld_lock_t node_read_lock = { READ_LOCK, NO_LOCK, READ_LOCK,
NO_LOCK };
Buf buffer = init_buf(high_buffer_size);
DEF_TIMERS;
START_TIMER;
/* write header: version, time */
packstr(FRONT_END_STATE_VERSION, buffer);
pack_time(time(NULL), buffer);
/* write node records to buffer */
lock_slurmctld (node_read_lock);
for (i = 0, front_end_ptr = front_end_nodes;
i < front_end_node_cnt; i++, front_end_ptr++) {
xassert(front_end_ptr->magic == FRONT_END_MAGIC);
_dump_front_end_state(front_end_ptr, buffer);
}
old_file = xstrdup (slurmctld_conf.state_save_location);
xstrcat (old_file, "/front_end_state.old");
reg_file = xstrdup (slurmctld_conf.state_save_location);
xstrcat (reg_file, "/front_end_state");
new_file = xstrdup (slurmctld_conf.state_save_location);
xstrcat (new_file, "/front_end_state.new");
unlock_slurmctld (node_read_lock);
/* write the buffer to file */
lock_state_files();
log_fd = creat (new_file, 0600);
if (log_fd < 0) {
error ("Can't save state, error creating file %s %m", new_file);
error_code = errno;
} else {
int pos = 0, nwrite = get_buf_offset(buffer), amount, rc;
char *data = (char *)get_buf_data(buffer);
high_buffer_size = MAX(nwrite, high_buffer_size);
while (nwrite > 0) {
amount = write(log_fd, &data[pos], nwrite);
if ((amount < 0) && (errno != EINTR)) {
error("Error writing file %s, %m", new_file);
error_code = errno;
break;
}
nwrite -= amount;
pos += amount;
}
rc = fsync_and_close(log_fd, "front_end");
if (rc && !error_code)
error_code = rc;
}
if (error_code)
(void) unlink (new_file);
else { /* file shuffle */
(void) unlink (old_file);
if (link(reg_file, old_file))
debug4("unable to create link for %s -> %s: %m",
reg_file, old_file);
(void) unlink (reg_file);
if (link(new_file, reg_file))
debug4("unable to create link for %s -> %s: %m",
new_file, reg_file);
(void) unlink (new_file);
}
xfree (old_file);
xfree (reg_file);
xfree (new_file);
unlock_state_files ();
free_buf (buffer);
END_TIMER2("dump_all_front_end_state");
return error_code;
#else
return SLURM_SUCCESS;
#endif
}
void do_omni( CHAR_DATA *ch, char *argument )
{
char buf[MAX_STRING_LENGTH];
char buf2[MAX_STRING_LENGTH];
BUFFER *output;
DESCRIPTOR_DATA *d;
int immmatch;
int mortmatch;
int hptemp;
/*
* Initalize Variables.
*/
immmatch = 0;
mortmatch = 0;
buf[0] = '\0';
output = new_buf();
/*
* Count and output */
sprintf(buf,"\n\r{B---{WI{wm{Wm{wo{Wr{wt{Wa{wl{Ws{B----{x\n\r");
add_buf(output,buf);
sprintf( buf, "{WN{wa{Wm{we {WL{we{Wv{we{Wl {WW{wi{Wz {WI{wn{Wc{wo{Wg {WG{wh{Wo{ws{Wt {W[{wV{Wn{wu{Wm{W]{x\n\r");
add_buf(output,buf);
for ( d = descriptor_list; d != NULL; d = d->next )
{
CHAR_DATA *wch;
if ( d->connected != CON_PLAYING || !can_see( ch, d->character ) )
continue;
wch = ( d->original != NULL ) ? d->original : d->character;
if (!can_see(ch,wch) || wch->level < 102)
continue;
immmatch++;
sprintf( buf, "{R%-14s %-3d %-3d %-3d %-3d [%-3d]{x\n\r",
wch->name,
wch->level,
wch->invis_level,
wch->incog_level,
wch->ghost_level,
wch->in_room->vnum);
add_buf(output,buf);
}
/*
* Count and output the Morts.
*/
sprintf( buf, " \n\r {B----{YM{yo{Yr{yt{Ya{yl{Ys{B----{x\n\r");
add_buf(output,buf);
sprintf( buf, "{WN{wa{Wm{we {WG{wo{Wd {WR{wa{Wc{we{W/{wC{Wl{wa{Ws{ws {WP{wo{Ws{wi{Wt{wi{Wo{wn {WL{we{Wv {w%%{Wh{wp{Ws {w[{WV{wn{Wu{wm{W]{x\n\r");
add_buf(output,buf);
hptemp = 0;
for ( d = descriptor_list; d != NULL; d = d->next )
{
CHAR_DATA *wch;
char const *class;
if ( d->connected != CON_PLAYING || !can_see( ch, d->character ) )
continue;
wch = ( d->original != NULL ) ? d->original : d->character;
if (!can_see(ch,wch) || wch->level > ch->level || wch->level > 101)
continue;
mortmatch++;
if ((wch->max_hit != wch->hit) && (wch->hit > 0))
hptemp = (wch->hit*100)/wch->max_hit;
else if (wch->max_hit == wch->hit)
hptemp = 100;
else if (wch->hit < 0)
hptemp = 0;
class = class_table[wch->class].who_name;
sprintf( buf, "{G%-14s %-7s %6.6s/%3.3s %-10s %-3d %-3d%% [%-3d]{x\n\r",
wch->name,
IS_GOOD(wch)? "Good" : IS_EVIL(wch) ? "Evil" : "Neutral",
wch->race < MAX_PC_RACE ? pc_race_table[wch->race].who_name : " ",
class,
capitalize( position_table[wch->position].name) ,
wch->level,
hptemp,
wch->in_room->vnum);
add_buf(output,buf);
}
/*
* Tally the counts and send the whole list out.
*/
sprintf( buf2, "\n\r{CIMMs found: {w%d{x\n\r", immmatch );
add_buf(output,buf2);
sprintf( buf2, "{CMorts found: {y%d{x\n\r", mortmatch );
add_buf(output,buf2);
page_to_char( buf_string(output), ch );
free_buf(output);
return;
}
