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