void schedule(void)
{
int i;
for (i = 0; i < PROCESS_COUNT_MAX; i++) {
struct Process *proc = NULL;
round_robin_index++;
if (round_robin_index == PROCESS_COUNT_MAX)
{
round_robin_index = 0;
}
proc = &process_table[round_robin_index];
if (proc->state == READY) {
current_process = proc;
proc_start(proc);
}
}
/* no process? panic */
mon_status(0, 0);
dump_scheduler_status();
kprintf("PANIC");
while(1);
}
u32 procwrap_start(union trapped_args *args, void *pr_ctxt)
{
u32 ret;
ret = proc_start(((struct process_context *)pr_ctxt)->processor);
return ret;
}
int main(int argc, char *argv[])
{
log_init(NAME);
if (options_parse(&argc, argv, NULL) != 0) {
exit(1);
}
proc_start(argc-1, argv+1,
(proc_out_func_t) proc_out_func,
(proc_out_func_t) proc_err_func,
(proc_term_func_t) proc_term_func, NULL);
sys_run();
return 0;
}
static int tool_procedural_iter(goxel_t *goxel, const inputs_t *inputs,
int state, const vec2_t *view_size,
bool inside)
{
int snaped = 0;
vec3_t pos, normal;
box_t box;
gox_proc_t *proc = &goxel->proc;
const bool down = inputs->mouse_down[0];
if (proc->state == PROC_PARSE_ERROR) return 0;
// XXX: duplicate code with tool_brush_iter.
if (inside)
snaped = goxel_unproject(
goxel, view_size, &inputs->mouse_pos,
goxel->painter.op == OP_ADD && !goxel->snap_offset,
&pos, &normal);
if (snaped) {
if (goxel->tool == TOOL_BRUSH && goxel->snap_offset)
vec3_iaddk(&pos, normal, goxel->snap_offset * goxel->tool_radius);
pos.x = round(pos.x - 0.5) + 0.5;
pos.y = round(pos.y - 0.5) + 0.5;
pos.z = round(pos.z - 0.5) + 0.5;
box = bbox_from_extents(pos, 0.5, 0.5, 0.5);
render_box(&goxel->rend, &box, false, NULL, false);
}
if (state == STATE_IDLE) {
if (snaped) state = STATE_SNAPED;
}
if (state == STATE_SNAPED) {
if (!snaped) return STATE_IDLE;
if (down) {
image_history_push(goxel->image);
proc_stop(proc);
proc_start(proc, &box);
state = STATE_PAINT;
}
}
if (state == STATE_PAINT) {
if (!down) state = STATE_IDLE;
}
return state;
}
kernel_main()
{
disp_str("-------------\"kernel_main\" start-----------------\n");
proc_id = 0;
ticks = 0;
k_reenter = 0;
pcb_init(task_tty,TASK_PROC,TTY0);
pcb_init(TestA,USER_PROC,TTY1);
pcb_init(TestB,USER_PROC,TTY1);
pcb_init(TestC,USER_PROC,TTY2);
//init_clock();
p_proc_ready = proc_table;
proc_start();
//stop here
while(1){}
}
/*
* Run a command to authorize or refuse entry. Return status 0 means
* authorize, -1 means refuse.
*/
void
authorize(dest *dp)
{
process *pp;
String *errstr;
dp->authorized = 1;
pp = proc_start(s_to_c(dp->repl1), (stream *)0, (stream *)0, outstream(), 1, 0);
if (pp == 0){
dp->status = d_noforward;
return;
}
errstr = s_new();
while(s_read_line(pp->std[2]->fp, errstr))
;
if ((dp->pstat = proc_wait(pp)) != 0) {
dp->repl2 = errstr;
dp->status = d_noforward;
} else
s_free(errstr);
proc_free(pp);
}
/* pipe an address through a command to translate it */
extern dest *
translate(dest *dp)
{
process *pp;
String *line;
dest *rv;
char *cp;
int n;
pp = proc_start(s_to_c(dp->repl1), (stream *)0, outstream(), outstream(), 1, 0);
if (pp == 0) {
dp->status = d_resource;
return 0;
}
line = s_new();
for(;;) {
cp = Brdline(pp->std[1]->fp, '\n');
if(cp == 0)
break;
if(strncmp(cp, "_nosummary_", 11) == 0){
nosummary = 1;
continue;
}
n = Blinelen(pp->std[1]->fp);
cp[n-1] = ' ';
s_nappend(line, cp, n);
}
rv = s_to_dest(s_restart(line), dp);
s_restart(line);
while(s_read_line(pp->std[2]->fp, line))
;
if ((dp->pstat = proc_wait(pp)) != 0) {
dp->repl2 = line;
rv = 0;
} else
s_free(line);
proc_free(pp);
return rv;
}
/* run a function under a set of processes */
static double run_processes(int nprocs, void *(*fn)(int ))
{
int i;
pid_t *ids = calloc(sizeof(*ids), nprocs);
double t;
barrier_setup(&barriers[0]);
barrier_setup(&barriers[1]);
for (i=0;i<nprocs;i++) {
ids[i] = proc_start(fn, i);
if (ids[i] == (pid_t)-1) {
for (i--;i>=0;i--) {
kill(ids[i], SIGTERM);
}
exit(1);
}
}
barrier_parent(&barriers[0], nprocs);
t = barrier_parent(&barriers[1], nprocs);
for (i=0;i<nprocs;i++) {
int rc;
rc = proc_join(ids[i]);
if (rc != 0) {
fprintf(stderr, "Process %d failed : %s\n", i, strerror(errno));
exit(1);
}
}
barrier_cleanup(&barriers[0]);
barrier_cleanup(&barriers[1]);
free(ids);
return t;
}
String*
startcmd(void)
{
int n;
char *filename;
char **av;
Link *l;
String *cmd;
/*
* ignore the filterstate if the all the receivers prefer it.
*/
filterstate = optoutall(filterstate);
switch (filterstate){
case BLOCKED:
case DELAY:
rejectcount++;
logmsg("Blocked");
filename = dumpfile(s_to_c(senders.last->p));
cmd = s_new();
s_append(cmd, "cat > ");
s_append(cmd, filename);
pp = proc_start(s_to_c(cmd), instream(), 0, outstream(), 0, 0);
break;
case DIALUP:
logmsg("Dialup");
rejectcount++;
reply("554 5.7.1 We don't accept mail from dial-up ports.\r\n");
/*
* we could exit here, because we're never going to accept mail
* from this ip address, but it's unclear that RFC821 allows
* that. Instead we set the hardreject flag and go stupid.
*/
hardreject = 1;
return 0;
case DENIED:
logmsg("Denied");
rejectcount++;
reply("554-5.7.1 We don't accept mail from %s.\r\n",
s_to_c(senders.last->p));
reply("554 5.7.1 Contact postmaster@%s for more information.\r\n",
dom);
return 0;
case REFUSED:
logmsg("Refused");
rejectcount++;
reply("554 5.7.1 Sender domain must exist: %s\r\n",
s_to_c(senders.last->p));
return 0;
default:
case NONE:
logmsg("Confused");
rejectcount++;
reply("554-5.7.0 We have had an internal mailer error "
"classifying your message.\r\n");
reply("554-5.7.0 Filterstate is %d\r\n", filterstate);
reply("554 5.7.0 Contact postmaster@%s for more information.\r\n",
dom);
return 0;
case ACCEPT:
/*
* now that all other filters have been passed,
* do grey-list processing.
*/
if(gflag)
vfysenderhostok();
/* fall through */
case TRUSTED:
/*
* set up mail command
*/
cmd = s_clone(mailer);
n = 3;
for(l = rcvers.first; l; l = l->next)
n++;
av = malloc(n * sizeof(char*));
if(av == nil){
reply("450 4.3.2 We're busy right now, try later\r\n");
s_free(cmd);
return 0;
}
n = 0;
av[n++] = s_to_c(cmd);
av[n++] = "-r";
for(l = rcvers.first; l; l = l->next)
av[n++] = s_to_c(l->p);
av[n] = 0;
/*
* start mail process
*/
pp = noshell_proc_start(av, instream(), outstream(),
outstream(), 0, 0);
free(av);
break;
}
if(pp == 0) {
reply("450 4.3.2 We're busy right now, try later\r\n");
s_free(cmd);
return 0;
}
return cmd;
}
