PUBLIC void set_timer(MESSAGE* m)
{
int expire=m->EXPIRETIME;
PROCESS* src=pid2proc(m->source);
TIMER* tp=&(src->p_timer);
tp->next=0;
tp->pid=m->source;
tp->exptime=expire;
if(!timerlist||timerlist->exptime>expire)
{
tp->next=timerlist;
timerlist=tp;
nextexpiretime=expire;
printf("Timer seted <%d>",ticks);
return;
}
TIMER* search=timerlist;
while(search->next&&search->next->exptime<expire){search=search->next;}
tp->next=search->next;
search->next=tp;
printf("Timer seted <%d>",ticks);
}
static enum callback_status
stop_non_p_processes(struct process *proc, void *data)
{
int stop = 1;
struct opt_p_t *it;
for (it = opt_p; it != NULL; it = it->next) {
struct process *p_proc = pid2proc(it->pid);
if (p_proc == NULL) {
printf("stop_non_p_processes: %d terminated?\n", it->pid);
continue;
}
if (p_proc == proc || p_proc->leader == proc->leader) {
stop = 0;
break;
}
}
if (stop) {
debug(2, "Sending SIGSTOP to process %u", proc->pid);
kill(proc->pid, SIGSTOP);
}
return CBS_CONT;
}
static void
add_process(struct Process *proc, int was_exec)
{
Process ** leaderp = &list_of_processes;
if (proc->pid) {
pid_t tgid = process_leader(proc->pid);
if (tgid == 0)
/* Must have been terminated before we managed
* to fully attach. */
return;
if (tgid == proc->pid)
proc->leader = proc;
else {
Process * leader = pid2proc(tgid);
proc->leader = leader;
if (leader != NULL)
leaderp = &leader->next;
}
}
if (!was_exec) {
proc->next = *leaderp;
*leaderp = proc;
}
}
PRIVATE void exp_timer(TIMER** tl,int time)
{
while(*tl!=0&&(*tl)->exptime<time)
{
printf("%s's Timer expire<%d>",pid2proc((*tl)->pid)->name,ticks);
lock_notify(TASK_CLOCK,(*tl)->pid);
(*tl)=(*tl)->next;
}
}
static void
handle_new(Event * event) {
Process * proc;
debug(DEBUG_FUNCTION, "handle_new(pid=%d)", event->e_un.newpid);
proc = pid2proc(event->e_un.newpid);
if (!proc) {
pending_new_insert(event->e_un.newpid);
} else {
assert(proc->state == STATE_BEING_CREATED);
if (options.follow) {
proc->state = STATE_ATTACHED;
} else {
proc->state = STATE_IGNORED;
}
continue_process(proc->pid);
}
}
void
open_pid(pid_t pid)
{
debug(DEBUG_PROCESS, "open_pid(pid=%d)", pid);
/* If we are already tracing this guy, we should be seeing all
* his children via normal tracing route. */
if (pid2proc(pid) != NULL)
return;
/* First, see if we can attach the requested PID itself. */
if (open_one_pid(pid)) {
fprintf(stderr, "Cannot attach to pid %u: %s\n",
pid, strerror(errno));
trace_fail_warning(pid);
return;
}
/* Now attach to all tasks that belong to that PID. There's a
* race between process_tasks and open_one_pid. So when we
* fail in open_one_pid below, we just do another round.
* Chances are that by then that PID will have gone away, and
* that's why we have seen the failure. The processes that we
* manage to open_one_pid are stopped, so we should eventually
* reach a point where process_tasks doesn't give any new
* processes (because there's nobody left to produce
* them). */
size_t old_ntasks = 0;
int have_all;
while (1) {
pid_t *tasks;
size_t ntasks;
size_t i;
if (process_tasks(pid, &tasks, &ntasks) < 0) {
fprintf(stderr, "Cannot obtain tasks of pid %u: %s\n",
pid, strerror(errno));
break;
}
have_all = 1;
for (i = 0; i < ntasks; ++i)
if (pid2proc(tasks[i]) == NULL
&& open_one_pid(tasks[i]))
have_all = 0;
free(tasks);
if (have_all && old_ntasks == ntasks)
break;
old_ntasks = ntasks;
}
struct Process *leader = pid2proc(pid)->leader;
/* XXX Is there a way to figure out whether _start has
* actually already been hit? */
arch_dynlink_done(leader);
/* Done. Continue everyone. */
each_task(leader, NULL, start_one_pid, NULL);
}
