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); }