void faulted(int fuckoff, int userspace, addr_t ip)
{
if(current_task == kernel_task || !current_task || current_task->system || !userspace)
{
kernel_fault(fuckoff, ip);
} else
{
printk(5, "%s occured in task %d (F=%d): He's dead, Jim.\n",
exception_messages[fuckoff], current_task->pid, current_task->flag);
/* we die for different reasons on different interrupts */
switch(fuckoff)
{
case 0: case 5: case 6: case 13:
current_task->sigd = SIGILL;
break;
case 1: case 3: case 4:
current_task->sigd = SIGTRAP;
break;
case 8: case 18:
current_task->sigd = SIGABRT;
break;
default:
kill_task(current_task->pid);
break;
}
/* the above signals WILL be handled, since at the end of schedule(), it checks
* for signals. Since we are returning to user-space here, the handler will always run */
while(!schedule());
}
}
int module_exit()
{
if(exe) iremove_force(exe);
if(!pid)
printk(1, "[sync]: Warning - invalid PID in sync module\n");
kill_task(pid);
printk(1, "[sync]: Autosync disabled\n");
return 0;
}
/* Here we find an unused filedes, and add it to the list. We rely on the
* list being sorted, and since this is the only function that adds to it,
* we can assume it is. This allows for relatively efficient determining of
* a filedes without limit. */
int add_file_pointer_do(task_t *t, struct file_ptr *f, int after)
{
assert(t && f);
while(after < FILP_HASH_LEN && t->filp[after])
after++;
if(after >= FILP_HASH_LEN) {
printk(1, "[vfs]: task %d ran out of files (syscall=%d). killed.\n",
t->pid, t == current_task ? (int)t->system : -1);
kill_task(t->pid);
}
t->filp[after] = f;
f->num = after;
return after;
}
/* 実行時初期化:
p[0] = map, p[1] = &player, p[2] = bmap */
task_func game_start(LPTCB t)
{
LPTCB task;
/* 初期タスク設定 */
task = create_task(floor_load, NULL, PRIO_00);
task->p[0] = t->p[0];
task->p[1] = t->p[1];
task->p[2] = t->p[2];
task = create_task(write_map, NULL, PRIO_01);
task->p[0] = t->p[0];
task->p[1] = t->p[1];
task = create_task(player_turn, NULL, PRIO_02);
task->p[0] = t->p[0];
task->p[1] = t->p[1];
task = create_task(set_player_smell, NULL, PRIO_02);
task->p[0] = t->p[1];
task->p[1] = t->p[2];
task = create_task(check_monster_alive, NULL, PRIO_06);
task->p[0] = t->p[0];
task->p[1] = t->p[1];
task->p[2] = t->p[2];
task = create_task(pl_level_up, NULL, PRIO_06);
task->p[1] = t->p[1];
task = create_task(monster_turn, NULL, PRIO_06);
task->p[0] = t->p[0];
task = create_task(more_monster, NULL, PRIO_06);
task->p[0] = t->p[0];
task->p[1] = t->p[1];
task->p[2] = t->p[2];
task = create_task(grow_mush, NULL, PRIO_08);
task->p[0] = t->p[0];
task->p[1] = t->p[1];
kill_task(t);
}
Tasksettings::Tasksettings(Settingsstore* store, Taskaccessmanager* taskaccessmanager, QWidget *parent) :
QWidget(parent),
ui(new Ui::Tasksettings)
{
ui->setupUi(this);
my_task_uid = -1;//default value to recognize if task uid has been set already...
storage = store;
taskaccess = taskaccessmanager;
taskpriority = new Taskpriority();
taskpriority->hide();
taskevent = new Taskevent(taskaccess);
taskevent->hide();
QObject::connect(ui->pushButtonBack, SIGNAL(clicked()), this, SLOT(hide_me()));
QObject::connect(ui->pushButtonRefresh, SIGNAL(clicked()), this, SLOT(refresh_info()));
QObject::connect(ui->pushButtonClose, SIGNAL(clicked()), this, SLOT(close_task()));
QObject::connect(ui->pushButtonKill, SIGNAL(clicked()), this, SLOT(kill_task()));
QObject::connect(ui->pushButtonPriority, SIGNAL(clicked()), this, SLOT(set_task_priority()));
QObject::connect(ui->pushButtonEvent, SIGNAL(clicked()), this, SLOT(send_system_event()));
refresh_interval = 1000;
timer_refresh = new QTimer();
timer_refresh->setInterval(refresh_interval);
QObject::connect(timer_refresh, SIGNAL(timeout()), this, SLOT(refresh_stats()));
}
void scan_for_terminated(void)
{
static char id[] = "scan_for_terminated";
int exiteval = 0;
pid_t pid;
job *pjob;
task *ptask = NULL;
int statloc;
unsigned int momport = 0;
int tcount;
if (LOGLEVEL >= 7)
{
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
id,
"entered");
}
/* update the latest intelligence about the running jobs; */
/* must be done before we reap the zombies, else we lose the info */
termin_child = 0;
if (mom_get_sample() == PBSE_NONE)
{
pjob = (job *)GET_PRIOR(svr_alljobs);
while (pjob != NULL)
{
mom_set_use(pjob);
pjob = (job *)GET_PRIOR(pjob->ji_alljobs);
}
}
/* Now figure out which task(s) have terminated (are zombies) */
/* NOTE: does a job's tasks include its epilog? */
while ((pid = waitpid(-1, &statloc, WNOHANG)) > 0)
{
pjob = (job *)GET_PRIOR(svr_alljobs);
while (pjob != NULL)
{
/*
* see if process was a child doing a special
* function for MOM
*/
if (LOGLEVEL >= 7)
{
snprintf(log_buffer, 1024, "checking job w/subtask pid=%d (child pid=%d)",
pjob->ji_momsubt,
pid);
LOG_EVENT(
PBSEVENT_DEBUG,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
}
if (pid == pjob->ji_momsubt)
{
if (LOGLEVEL >= 7)
{
snprintf(log_buffer, 1024, "found match with job subtask for pid=%d",
pid);
LOG_EVENT(
PBSEVENT_DEBUG,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
}
break;
}
/* look for task */
ptask = (task *)GET_NEXT(pjob->ji_tasks);
/* locate task with associated process id */
tcount = 0;
while (ptask != NULL)
{
if (ptask->ti_qs.ti_sid == pid)
{
if (LOGLEVEL >= 7)
{
snprintf(log_buffer, 1024, "found match with job task %d for pid=%d",
tcount,
pid);
LOG_EVENT(
PBSEVENT_DEBUG,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
}
break;
}
ptask = (task *)GET_NEXT(ptask->ti_jobtask);
tcount++;
} /* END while (ptask) */
if (ptask != NULL)
{
/* pid match located - break out of job loop */
break;
}
pjob = (job *)GET_PRIOR(pjob->ji_alljobs);
} /* END while (pjob != NULL) */
if (pjob == NULL)
{
if (LOGLEVEL >= 1)
{
sprintf(log_buffer, "pid %d not tracked, exitcode=%d",
pid,
statloc);
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
id,
log_buffer);
}
continue;
} /* END if (pjob == NULL) */
if (WIFEXITED(statloc))
exiteval = WEXITSTATUS(statloc);
else if (WIFSIGNALED(statloc))
exiteval = WTERMSIG(statloc) + 0x100;
else
exiteval = 1;
if (pid == pjob->ji_momsubt)
{
/* PID matches job mom subtask */
/* NOTE: both ji_momsubt and ji_mompost normally set in routine
preobit_reply() after epilog child is successfully forked */
if (pjob->ji_mompost != NULL)
{
if (pjob->ji_mompost(pjob, exiteval) == 0)
{
/* success */
pjob->ji_mompost = NULL;
}
} /* END if (pjob->ji_mompost != NULL) */
else
{
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
"job has no postprocessing routine registered");
}
/* clear mom sub-task */
pjob->ji_momsubt = 0;
if(multi_mom)
{
momport = pbs_rm_port;
}
job_save(pjob, SAVEJOB_QUICK, momport);
continue;
} /* END if (pid == pjob->ji_momsubt) */
/* what happens if mom PID is reaped before subtask? */
if (LOGLEVEL >= 2)
{
sprintf(log_buffer, "pid %d harvested for job %s, task %d, exitcode=%d",
pid,
pjob->ji_qs.ji_jobid,
ptask->ti_qs.ti_task,
exiteval);
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
id,
log_buffer);
}
/* where is job purged? How do we keep job from progressing in state until the obit is sent? */
kill_task(ptask, SIGKILL, 0);
ptask->ti_qs.ti_exitstat = exiteval;
ptask->ti_qs.ti_status = TI_STATE_EXITED;
task_save(ptask);
sprintf(log_buffer, "%s: job %s task %d terminated, sid=%d",
id,
pjob->ji_qs.ji_jobid,
ptask->ti_qs.ti_task,
ptask->ti_qs.ti_sid);
LOG_EVENT(
PBSEVENT_DEBUG,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
exiting_tasks = 1;
} /* END while ((pid = waitpid(-1,&statloc,WNOHANG)) > 0) */
return;
} /* END scan_for_terminated() */
void end_task(void) /* this ends the task that calls this */
{
kill_task(tswitch);
};
int task_kill_other(struct task_struct *killer, struct task_struct *task)
{
return kill_task(task);
}
int task_cancel (int taskid)
{
kill_task (taskid);
return 0;
}
void scan_for_terminated(void) /* linux */
{
int exiteval = 0;
pid_t pid;
job *pjob = NULL;
task *ptask = NULL;
int statloc;
unsigned int momport = 0;
#ifdef USESAVEDRESOURCES
int update_stats = TRUE;
#endif /* USESAVEDRESOURCES */
int tcount;
if (LOGLEVEL >= 9)
{
log_record(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, "entered");
}
/* update the latest intelligence about the running jobs; */
/* must be done before we reap the zombies, else we lose the info */
termin_child = 0;
if (mom_get_sample() == PBSE_NONE)
{
std::list<job *>::reverse_iterator iter;
// get a list of jobs in start time order, first to last
for (iter = alljobs_list.rbegin(); iter != alljobs_list.rend(); iter++)
{
pjob = *iter;
if ((pjob->ji_stats_done == true) ||
(pjob->ji_qs.ji_state < JOB_STATE_RUNNING))
continue;
#ifdef USESAVEDRESOURCES
ptask = (task *)GET_NEXT(pjob->ji_tasks);
/*
** check task with associated process id to see if we are recovering
** after a mom restart where process completed while we were gone
*/
while (ptask != NULL)
{
if (ptask->ti_flags & TI_FLAGS_RECOVERY)
{
if (LOGLEVEL >= 7)
{
snprintf(log_buffer, sizeof(log_buffer), "Found match for recovering job task for sid=%d",
ptask->ti_qs.ti_sid);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buffer);
}
update_stats = FALSE;
break;
}
ptask = (task *)GET_NEXT(ptask->ti_jobtask);
} /* END while (ptask) */
if (update_stats)
{
mom_set_use(pjob);
}
#else
mom_set_use(pjob);
#endif /* USESAVEDRESOURCES */
}
}
/* Now figure out which task(s) have terminated (are zombies) */
/* NOTE: does a job's tasks include its epilog? */
while ((pid = waitpid(-1, &statloc, WNOHANG)) > 0)
{
std::list<job *>::reverse_iterator iter;
if (LOGLEVEL >= 8)
{
sprintf(log_buffer, "Child exited with pid: %d", pid);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, log_buffer);
}
// get a list of jobs in start time order, first to last
for (iter = alljobs_list.rbegin(); iter != alljobs_list.rend(); iter++)
{
pjob = *iter;
/*
* see if process was a child doing a special
* function for MOM
*/
if (pjob->ji_momsubt != 0)
{
if (LOGLEVEL >= 9)
{
snprintf(log_buffer, sizeof(log_buffer),
"Checking to see if exiting child pid '%d' is a match for special mom task with pid=%d",
pid, pjob->ji_momsubt);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buffer);
}
if (pid == pjob->ji_momsubt)
{
if (LOGLEVEL >= 9)
{
snprintf(log_buffer, sizeof(log_buffer),
"The exiting child is a match of special subtask with pid=%d for job %s",
pid, pjob->ji_qs.ji_jobid);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buffer);
}
break;
}
}
/* look for task */
ptask = (task *)GET_NEXT(pjob->ji_tasks);
/* locate task with associated process id */
tcount = 0;
while (ptask != NULL)
{
if ((ptask->ti_qs.ti_sid == pid) &&
(ptask->ti_qs.ti_status != TI_STATE_EXITED))
{
if (LOGLEVEL >= 7)
{
snprintf(log_buffer, sizeof(log_buffer),
"Exiting child matches job task %d for pid=%d",
tcount,
pid);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buffer);
}
break;
}
ptask = (task *)GET_NEXT(ptask->ti_jobtask);
tcount++;
} /* END while (ptask) */
// make sure the task is the top level task for the job to mark the job done
if ((ptask != NULL) &&
(ptask->ti_qs.ti_parenttask == TM_NULL_TASK))
{
/* pid match located - break out of job loop */
pjob->ji_stats_done = true;
break;
}
} /* END while (pjob != NULL) */
if (WIFEXITED(statloc))
exiteval = WEXITSTATUS(statloc);
else if (WIFSIGNALED(statloc))
exiteval = WTERMSIG(statloc) + 0x100;
else
exiteval = 1;
if (pjob == NULL)
{
if (LOGLEVEL >= 1)
{
sprintf(log_buffer, "Child pid %d is not part of a job, statloc=%d, exitval=%d",
pid,
statloc,
exiteval);
log_record(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, log_buffer);
}
continue;
} /* END if (pjob == NULL) */
if (pid == pjob->ji_momsubt)
{
/* PID matches job mom subtask */
/* NOTE: both ji_momsubt and ji_mompost normally set in routine
preobit_reply() after epilog child is successfully forked */
if (pjob->ji_mompost != NULL)
{
if (pjob->ji_mompost(pjob, exiteval) == 0)
{
/* success */
pjob->ji_mompost = NULL;
}
} /* END if (pjob->ji_mompost != NULL) */
else if (LOGLEVEL >= 8) // This is a debug statement
{
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
"Job has no postprocessing routine registered");
}
/* clear mom sub-task */
pjob->ji_momsubt = 0;
if (multi_mom)
{
momport = pbs_rm_port;
}
job_save(pjob, SAVEJOB_QUICK, momport);
continue;
} /* END if (pid == pjob->ji_momsubt) */
if (ptask == NULL)
continue;
/* what happens if mom PID is reaped before subtask? */
if (LOGLEVEL >= 2)
{
sprintf(log_buffer, "pid %d harvested for job %s, task %d, exitcode=%d",
pid,
pjob->ji_qs.ji_jobid,
ptask->ti_qs.ti_task,
exiteval);
log_record(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, log_buffer);
}
/* where is job purged? How do we keep job from progressing in state until the obit is sent? */
kill_task(pjob, ptask, SIGKILL, 0);
ptask->ti_qs.ti_exitstat = exiteval;
ptask->ti_qs.ti_status = TI_STATE_EXITED;
task_save(ptask);
sprintf(log_buffer, "%s: job %s task %d terminated, sid=%d",
__func__,
pjob->ji_qs.ji_jobid,
ptask->ti_qs.ti_task,
ptask->ti_qs.ti_sid);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buffer);
exiting_tasks = 1;
} /* END while ((pid = waitpid(-1,&statloc,WNOHANG)) > 0) */
return;
} /* END scan_for_terminated() */
void _kill() {
Deprecated();
kill_task(current_task);
}
