static int
start_config_set(void *cb_data, int shutdown)
{
solparm_set_handler_t *elem = cb_data;
int rv;
if (shutdown) {
ipmi_log(IPMI_LOG_ERR_INFO,
"solparm.c(start_config_set): "
"SOLPARM was destroyed while an operation was in progress");
solparm_lock(elem->solparm);
set_complete(elem->solparm, ECANCELED, elem);
return OPQ_HANDLER_STARTED;
}
/* The read lock must be claimed before the solparm lock to avoid
deadlock. */
rv = ipmi_mc_pointer_cb(elem->solparm->mc, start_config_set_cb, elem);
if (rv) {
ipmi_log(IPMI_LOG_ERR_INFO,
"solparm.c(start_config_set): "
"SOLPARM's MC is not valid");
solparm_lock(elem->solparm);
set_complete(elem->solparm, rv, elem);
}
return OPQ_HANDLER_STARTED;
}
int main() {
LIST *jlist = init_list();
assert(gen_job_id(jlist) == 1);
assert(get_fg(jlist) == (job *)NULL);
assert(jlist->size == 0);
//print_bg(jlist);
job *jb1 = tstjob(1);
push(jlist, JOB, jb1);
assert(gen_job_id(jlist) == 2);
assert(get_fg(jlist) == jb1);
//print_bg(jlist);
job *jb2 = tstjob(3);
push(jlist, JOB, jb2);
assert(gen_job_id(jlist) == 2);
job *jb3 = tstjob(2);
push(jlist, JOB, jb3);
assert(gen_job_id(jlist) == 4);
push(jlist, JOB, tstjob(7));
assert(gen_job_id(jlist) == 4);
print_bg(jlist);
pop(jlist);
assert(gen_job_id(jlist) == 4);
assert(get_job_pgid(jlist, 11) == (job *)NULL);
assert(get_job_pgid(jlist, 7) == jb2);
assert(get_job_pgid(jlist, 3) == jb3);
assert(get_job(jlist, 3) == jb2);
assert(del_job(jlist, 7) == jb2);
assert(get_job(jlist, 3) == (job *)NULL);
assert(get_job(jlist, 55) == jb3);
assert(get_job(jlist, 10) == (job *)NULL);
assert(set_complete(jb2, 3) == 0);
assert(set_complete(jb2, 4) == -1);
assert(set_complete(jb3, 55) == 0);
assert(((process *)jb2->pid_list->head->node_ptr)->complete == 0);
assert(jb2->complete == 0);
assert(jb3->complete == 1);
assert(jlist->size == 2);
assert(get_job_jid(jlist, 1) == jb1);
assert(get_job_jid(jlist, 11) == (job *)NULL);
printf("[job_handler_tst] All tests pass!\n");
return 0;
}
static void
start_config_set_cb(ipmi_mc_t *mc, void *cb_data)
{
solparm_set_handler_t *elem = cb_data;
ipmi_solparm_t *solparm = elem->solparm;
ipmi_msg_t msg;
int rv;
solparm_lock(solparm);
if (solparm->destroyed) {
ipmi_log(IPMI_LOG_ERR_INFO,
"%ssolparm.c(start_config_set_cb): "
"SOLPARM was destroyed while an operation was in progress",
MC_NAME(mc));
set_complete(solparm, ECANCELED, elem);
goto out;
}
msg.netfn = IPMI_TRANSPORT_NETFN;
msg.cmd = IPMI_SET_SOL_CONFIGURATION_PARAMETERS;
msg.data = elem->data;
msg.data_len = elem->data_len;
rv = ipmi_mc_send_command(mc, 0, &msg, solparm_config_set, elem);
if (rv) {
ipmi_log(IPMI_LOG_ERR_INFO,
"%ssolparm.c(start_config_set_cb): "
"SOLPARM start_config_set: could not send cmd: %x",
MC_NAME(mc), rv);
set_complete(solparm, ECANCELED, elem);
goto out;
}
solparm_unlock(solparm);
out:
return;
}
static void
solparm_config_set(ipmi_mc_t *mc,
ipmi_msg_t *rsp,
void *rsp_data)
{
solparm_set_handler_t *elem = rsp_data;
ipmi_solparm_t *solparm = elem->solparm;
int rv;
rv = check_solparm_response_param(solparm, mc, rsp, 1,
"solparm_config_set");
solparm_lock(solparm);
set_complete(solparm, rv, elem);
}
/** SIGCHLD handler **/
void handler(int signum, siginfo_t *info, void *context) {
int cpid, status;
cpid = info->si_pid; // sending pid
//printf("Got a SIGCHLD from %d!\n", cpid);
// loop to catch simultaneous SIGCHLDs
while( (cpid = waitpid(-1, &status, WNOHANG | WUNTRACED | WCONTINUED)) > 0 ) {
//printf("HANDLER Got %d from waitpid\n", cpid);
job *j = get_job(job_list, cpid);
if(j == NULL) {
printf("Error: get_job returned null\n");
_exit(EXIT_FAILURE);
}
if(WIFEXITED(status)) { // completed
if( set_complete(j, cpid) == -1 ) {
printf("HANDLER set_complete went awry!\n");
_exit(EXIT_FAILURE);
}
}
else if(WIFSIGNALED(status)) { // terminated
set_complete(j, cpid);
printf("\n");
//printf("TERMINATED: %d\n", WTERMSIG(status));
}
else if(WIFSTOPPED(status)) { // stopped
j->running = 0;
if(j->fg) {
send_back(job_list, j->pgid);
printf("\nStopped: %s\n", j->rawcmd);
} else {
// queue stopped message
message *m = malloc(sizeof(message));
copy_to_buf(j->rawcmd, m->msg);
m->status = 0;
push(msg_q, PROCESS, (void *)m);
}
}
else if(WIFCONTINUED(status)) { // continued
j->running = 1;
//printf("CONTINUED\n");
}
if(j->complete) {
j->running = 0;
if(!j->fg) {
// queue finished message
message *m = malloc(sizeof(message));
copy_to_buf(j->rawcmd, m->msg);
m->status = 1;
push(msg_q, PROCESS, (void *)m);
free_job(del_job(job_list, j->pgid));
}
}
}
//printf("HANDLER Done with waitpid loop\n");
}
SEQ_T *print_random_seqs (
FILE *out, // Stream to print on.
int seed, // Random number seed.
int nseqs, // Number of sequences to print.
int min, // Minimum sequence length.
int max, // Maximum sequence length.
char **letters, // Array of letter strings.
int r, // Number of letter strings.
int c, // Length of letter strings.
int order, // Order of Markov model.
double *cum // Cumulative distribution(s) defining model.
)
{
int i, j;
int n; // Length of sequence.
char *buffer = NULL; // Buffer for sequences.
char *id = NULL; // Sequence name.
char first_letter = letters[0][0]; // First letter in alphabet.
// Create the buffer for the string.
mm_resize(buffer, max*(c-1)+1, char);
/* set up random number generator */
if (seed != 0) srand48(seed);
/* print random sequences */
for (i=0; i<nseqs; i++) { /* sequence */
// Decide length of sequence to print.
n = (int) (min + drand48() * (max - min + 1));
// Print FASTA ID line.
if (out != NULL) {
fprintf(out, ">SEQ_%-d %d\n", i+1, n);
} else {
mm_resize(id, 50, char);
sprintf(id, ">SEQ_%-d %d\n", i+1, n);
}
/*
Generate letters by
1) random x ~ [0,1)
2) binary search of cum for cum[i-1]<x<=cum[i]
3) letter/codon is letters[i-1]
*/
for (j=0; j<n; j++) { // generate letters/codons
double x = drand48(); // random number
int lo = 0;
int hi = r;
int offset = 0; // Offset into cum array.
if (order >= 1) { // Markov model.
int start_ptr;
// Find the offset into the cumulative prob array by looking
// for the offset of the preceeding "order" characters.
buffer[j] = first_letter; // Now contains index into array.
buffer[j+1] = '\0';
start_ptr = j > order ? j-order : 0; // Start of index string.
offset = s2i(buffer + start_ptr);
//fprintf(stderr, "b: %s\n offset: %d x: %f\n", buffer+start_ptr, offset, x);
}
while (hi-lo > 1) { // binary search
int mid = (lo+hi)/2; // midpoint
if (x > cum[mid+offset]) { lo = mid; } else { hi = mid; }
}
//fprintf(stderr, "%11.8f %s r %d\n", x, letters[x<cum[lo+offset] ? lo : lo+1], r);
//fprintf(stderr, "%s", letters[x<cum[lo+offset] ? lo : lo+1]);
buffer[j] = letters[x<cum[lo+offset] ? lo : lo+1][0];
} /* generate letters/codons */
buffer[j] = '\0';
// Print the sequence.
if (out != NULL) {
for (j=0; j<n; j+=50) {
fprintf(out, "%-50.50s\n", buffer+j);
}
} else {
SEQ_T *seq = allocate_seq(id, "", 0, buffer);
set_complete(TRUE, seq);
myfree(buffer);
return(seq);
}
} /* sequence */
myfree(buffer);
return(NULL);
} // print_random_seqs
