Fork me on GitHub
p                  28 drivers/char/sysrq.c 	struct proc *p;
p                  31 drivers/char/sysrq.c 	FOR_EACH_PROCESS(p) {
p                  32 drivers/char/sysrq.c 		if(p->state != PROC_ZOMBIE) {
p                  34 drivers/char/sysrq.c 				p->uid,
p                  35 drivers/char/sysrq.c 				p->pid,
p                  36 drivers/char/sysrq.c 				p->ppid,
p                  37 drivers/char/sysrq.c 				pstate[p->state],
p                  38 drivers/char/sysrq.c 				p->argv0
p                  41 drivers/char/sysrq.c 		p = p->next;
p                  45 drivers/char/sysrq.c 	FOR_EACH_PROCESS_RUNNING(p) {
p                  46 drivers/char/sysrq.c 		printk("%d ", p->pid);
p                  47 drivers/char/sysrq.c 		p = p->next_run;
p                 237 drivers/char/tty.c 	struct proc *p;
p                 247 drivers/char/tty.c 	FOR_EACH_PROCESS(p) {
p                 248 drivers/char/tty.c 		if(p->sid == current->sid) {
p                 249 drivers/char/tty.c 			p->ctty = NULL;
p                 251 drivers/char/tty.c 		p = p->next;
p                 461 drivers/char/tty.c 	struct proc *p;
p                 481 drivers/char/tty.c 		FOR_EACH_PROCESS(p) {
p                 482 drivers/char/tty.c 			if(p->ctty == tty) {
p                 483 drivers/char/tty.c 				p->ctty = NULL;
p                 485 drivers/char/tty.c 			p = p->next;
p                 704 drivers/char/tty.c 	struct proc *p;
p                 844 drivers/char/tty.c 					FOR_EACH_PROCESS(p) {
p                 845 drivers/char/tty.c 						if(p->ctty == tty) {
p                 846 drivers/char/tty.c 							p->ctty = NULL;
p                 848 drivers/char/tty.c 						p = p->next;
p                  89 fs/iso9660/super.c int isonum_733(char *p)
p                  91 fs/iso9660/super.c 	return isonum_731(p);
p                  95 fs/iso9660/super.c unsigned long int isodate(char *p)
p                  99 fs/iso9660/super.c 	if(!p[0]) {
p                 103 fs/iso9660/super.c 	mt.mt_sec = p[5];
p                 104 fs/iso9660/super.c 	mt.mt_min = p[4];
p                 105 fs/iso9660/super.c 	mt.mt_hour = p[3];
p                 106 fs/iso9660/super.c 	mt.mt_day = p[2];
p                 107 fs/iso9660/super.c 	mt.mt_month = p[1];
p                 108 fs/iso9660/super.c 	mt.mt_year = p[0];
p                 110 fs/iso9660/super.c 	mt.mt_min += p[6] * 15;
p                 119 fs/iso9660/super.c 	char *p;
p                 121 fs/iso9660/super.c 	p = filename;
p                 125 fs/iso9660/super.c 				if(p[n] == ';' && p[n + 1] == '1') {
p                 127 fs/iso9660/super.c 					if(p[n - 1] == '.') {
p                  45 fs/locks.c     static struct flock_file * get_flock_file(struct inode *i, int op, struct proc *p)
p                  58 fs/locks.c     		if(p && p != ff->proc) {
p                 178 fs/procfs/data.c 	struct proc *p;
p                 186 fs/procfs/data.c 	FOR_EACH_PROCESS(p) {
p                 188 fs/procfs/data.c 		if(p->state == PROC_RUNNING) {
p                 191 fs/procfs/data.c 		p = p->next;
p                 365 fs/procfs/data.c 	struct proc *p;
p                 368 fs/procfs/data.c 	p = &proc_table[IDLE];
p                 369 fs/procfs/data.c 	idle = tv2ticks(&p->usage.ru_utime);
p                 370 fs/procfs/data.c 	idle += tv2ticks(&p->usage.ru_stime);
p                 443 fs/procfs/data.c 	struct proc *p;
p                 446 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 447 fs/procfs/data.c 		for(n = 0; n < p->argc && (p->argv + n); n++) {
p                 448 fs/procfs/data.c 			argv = p->argv + n;
p                 450 fs/procfs/data.c 			addr = get_mapped_addr(p, (int)argv) & PAGE_MASK;
p                 454 fs/procfs/data.c 			addr = get_mapped_addr(p, (int)argv[0]) & PAGE_MASK;
p                 471 fs/procfs/data.c 	struct proc *p;
p                 475 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 478 fs/procfs/data.c 		if(!p->pwd) {
p                 482 fs/procfs/data.c 		i = p->pwd;
p                 494 fs/procfs/data.c 	struct proc *p;
p                 497 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 498 fs/procfs/data.c 		for(n = 0; n < p->envc && (p->envp + n); n++) {
p                 499 fs/procfs/data.c 			envp = p->envp + n;
p                 501 fs/procfs/data.c 			addr = get_mapped_addr(p, (int)envp) & PAGE_MASK;
p                 505 fs/procfs/data.c 			addr = get_mapped_addr(p, (int)envp[0]) & PAGE_MASK;
p                 522 fs/procfs/data.c 	struct proc *p;
p                 526 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 529 fs/procfs/data.c 		if(!p->vma || !p->vma->inode) {
p                 533 fs/procfs/data.c 		i = p->vma->inode;
p                 547 fs/procfs/data.c 	struct proc *p;
p                 551 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 552 fs/procfs/data.c 		if(!p->vma) {
p                 555 fs/procfs/data.c 		vma = p->vma;
p                 624 fs/procfs/data.c 	struct proc *p;
p                 628 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 631 fs/procfs/data.c 		if(!p->root) {
p                 635 fs/procfs/data.c 		i = p->root;
p                 647 fs/procfs/data.c 	struct proc *p;
p                 653 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 654 fs/procfs/data.c 		if(!p->vma) {
p                 657 fs/procfs/data.c 		vma_start = p->vma[0].start;
p                 658 fs/procfs/data.c 		vma_end = p->vma[0].end;
p                 660 fs/procfs/data.c 		vma = p->vma;
p                 680 fs/procfs/data.c 			if(p->sigaction[signum].sa_handler == SIG_IGN) {
p                 683 fs/procfs/data.c 			if(p->sigaction[signum].sa_handler == SIG_DFL) {
p                 689 fs/procfs/data.c 		if(p->sp) {
p                 690 fs/procfs/data.c 			sc = (struct sigcontext *)p->sp;
p                 695 fs/procfs/data.c 		p->pid,
p                 696 fs/procfs/data.c 		p->argv0,
p                 697 fs/procfs/data.c 		pstate[p->state][0],
p                 698 fs/procfs/data.c 		p->ppid, p->pgid, p->sid,
p                 699 fs/procfs/data.c 		p->ctty ? p->ctty->dev : 0,
p                 700 fs/procfs/data.c 		p->ctty ? p->ctty->pgid : - 1,
p                 703 fs/procfs/data.c 		tv2ticks(&p->usage.ru_utime),
p                 704 fs/procfs/data.c 		tv2ticks(&p->usage.ru_stime),
p                 705 fs/procfs/data.c 		tv2ticks(&p->cusage.ru_utime),
p                 706 fs/procfs/data.c 		tv2ticks(&p->cusage.ru_stime),
p                 711 fs/procfs/data.c 		p->start_time,
p                 713 fs/procfs/data.c 		p->rss,
p                 720 fs/procfs/data.c 		p->sigpending,
p                 721 fs/procfs/data.c 		p->sigblocked,
p                 724 fs/procfs/data.c 		p->sleep_address
p                 733 fs/procfs/data.c 	struct proc *p;
p                 738 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 739 fs/procfs/data.c 		if(!p->vma) {
p                 742 fs/procfs/data.c 		vma = p->vma;
p                 761 fs/procfs/data.c 		size += sprintk(buffer + size, " %d", p->rss);
p                 776 fs/procfs/data.c 	struct proc *p;
p                 781 fs/procfs/data.c 	if((p = get_proc_by_pid(pid))) {
p                 782 fs/procfs/data.c 		if(!p->vma) {
p                 785 fs/procfs/data.c 		vma = p->vma;
p                 803 fs/procfs/data.c 		size = sprintk(buffer, "Name:\t%s\n", p->argv0);
p                 804 fs/procfs/data.c 		size += sprintk(buffer + size, "State:\t%s\n", pstate[p->state]);
p                 805 fs/procfs/data.c 		size += sprintk(buffer + size, "Pid:\t%d\n", p->pid);
p                 806 fs/procfs/data.c 		size += sprintk(buffer + size, "PPid:\t%d\n", p->ppid);
p                 807 fs/procfs/data.c 		size += sprintk(buffer + size, "Uid:\t%d\t%d\t%d\t-\n", p->uid, p->euid, p->suid);
p                 808 fs/procfs/data.c 		size += sprintk(buffer + size, "Gid:\t%d\t%d\t%d\t-\n", p->gid, p->egid, p->sgid);
p                 811 fs/procfs/data.c 		size += sprintk(buffer + size, "VmRSS:\t%8d kB\n", p->rss << 2);
p                 816 fs/procfs/data.c 		size += sprintk(buffer + size, "SigPnd:\t%08x\n", p->sigpending);
p                 817 fs/procfs/data.c 		size += sprintk(buffer + size, "SigBlk:\t%08x\n", p->sigblocked);
p                 820 fs/procfs/data.c 			if(p->sigaction[signum].sa_handler == SIG_IGN) {
p                 823 fs/procfs/data.c 			if(p->sigaction[signum].sa_handler == SIG_DFL) {
p                  64 fs/procfs/dir.c 	struct proc *p;
p                  72 fs/procfs/dir.c 	FOR_EACH_PROCESS(p) {
p                  73 fs/procfs/dir.c 		d.inode = PROC_PID_INO + (p->pid << 12);
p                  78 fs/procfs/dir.c 		n = p->pid;
p                  83 fs/procfs/dir.c 		d.name = p->pidstr;
p                  94 fs/procfs/dir.c 		p = p->next;
p                  24 fs/procfs/namei.c 	struct proc *p;
p                  70 fs/procfs/namei.c 	FOR_EACH_PROCESS(p) {
p                  71 fs/procfs/namei.c 		if(len == strlen(p->pidstr)) {
p                  72 fs/procfs/namei.c 			if(!(strcmp(p->pidstr, name))) {
p                  73 fs/procfs/namei.c 				inode = PROC_PID_INO + (p->pid << 12);
p                  83 fs/procfs/namei.c 		p = p->next;
p                  93 fs/procfs/symlink.c 	struct proc *p;
p                 103 fs/procfs/symlink.c 	p = NULL;
p                 105 fs/procfs/symlink.c 		if(!(p = get_proc_by_pid(pid))) {
p                 118 fs/procfs/symlink.c 			if(!p->pwd) {
p                 121 fs/procfs/symlink.c 			*i_res = p->pwd;
p                 122 fs/procfs/symlink.c 			p->pwd->count++;
p                 126 fs/procfs/symlink.c 			if(!p->vma || !p->vma->inode) {
p                 129 fs/procfs/symlink.c 			*i_res = p->vma->inode;
p                 130 fs/procfs/symlink.c 			p->vma->inode->count++;
p                 134 fs/procfs/symlink.c 			if(!p->root) {
p                 137 fs/procfs/symlink.c 			*i_res = p->root;
p                 138 fs/procfs/symlink.c 			p->root->count++;
p                  16 fs/script.c    	char *p;
p                  32 fs/script.c    	p = interpreter;
p                  42 fs/script.c    		*p = data[n];
p                  44 fs/script.c    		p++;
p                  54 fs/script.c    		p = args;
p                  66 fs/script.c    			*p = data[n];
p                  68 fs/script.c    			p++;
p                  34 include/fiwix/process.h #define SLOT(p)		((p) - (&proc_table[0]))
p                  47 include/fiwix/process.h #define PG_LEADER(p)	((p)->pid == (p)->pgid)
p                  48 include/fiwix/process.h #define SESS_LEADER(p)	((p)->pid == (p)->pgid && (p)->pid == (p)->sid)
p                  50 include/fiwix/process.h #define FOR_EACH_PROCESS(p)		p = proc_table_head->next ; while(p)
p                  51 include/fiwix/process.h #define FOR_EACH_PROCESS_RUNNING(p)	p = proc_run_head ; while(p)
p                 117 kernel/main.c  	struct proc *p;
p                 133 kernel/main.c  	FOR_EACH_PROCESS_RUNNING(p) {
p                 134 kernel/main.c  		not_runnable(p, PROC_SLEEPING);
p                 135 kernel/main.c  		p->sigpending = 0;
p                 136 kernel/main.c  		p = p->next_run;
p                 228 kernel/multiboot.c 		char *p;
p                 230 kernel/multiboot.c 		p = (char *)mbi.cmdline;
p                 231 kernel/multiboot.c 		len = strlen(p);
p                 234 kernel/multiboot.c 			c = *(p++);
p                 239 kernel/multiboot.c 		strcpy(cmdline, p);
p                  34 kernel/process.c 	struct proc *p;
p                  36 kernel/process.c 	FOR_EACH_PROCESS(p) {
p                  37 kernel/process.c 		if(p->pid == pid && p->state != PROC_ZOMBIE) {
p                  38 kernel/process.c 			return send_sig(p, signum);
p                  40 kernel/process.c 		p = p->next;
p                  47 kernel/process.c 	struct proc *p;
p                  51 kernel/process.c 	FOR_EACH_PROCESS(p) {
p                  52 kernel/process.c 		if(p->pgid == pgid && p->state != PROC_ZOMBIE) {
p                  53 kernel/process.c 			send_sig(p, signum);
p                  56 kernel/process.c 		p = p->next;
p                  66 kernel/process.c void add_crusage(struct proc *p, struct rusage *cru)
p                  68 kernel/process.c 	cru->ru_utime.tv_sec = p->usage.ru_utime.tv_sec + p->cusage.ru_utime.tv_sec;
p                  69 kernel/process.c 	cru->ru_utime.tv_usec = p->usage.ru_utime.tv_usec + p->cusage.ru_utime.tv_usec;
p                  74 kernel/process.c 	cru->ru_stime.tv_sec = p->usage.ru_stime.tv_sec + p->cusage.ru_stime.tv_sec;
p                  75 kernel/process.c 	cru->ru_stime.tv_usec = p->usage.ru_stime.tv_usec + p->cusage.ru_stime.tv_usec;
p                  80 kernel/process.c 	cru->ru_maxrss = p->usage.ru_maxrss + p->cusage.ru_maxrss;
p                  81 kernel/process.c 	cru->ru_ixrss = p->usage.ru_ixrss + p->cusage.ru_ixrss;
p                  82 kernel/process.c 	cru->ru_idrss = p->usage.ru_idrss + p->cusage.ru_idrss;
p                  83 kernel/process.c 	cru->ru_isrss = p->usage.ru_isrss + p->cusage.ru_isrss;
p                  84 kernel/process.c 	cru->ru_minflt = p->usage.ru_minflt + p->cusage.ru_minflt;
p                  85 kernel/process.c 	cru->ru_majflt = p->usage.ru_majflt + p->cusage.ru_majflt;
p                  86 kernel/process.c 	cru->ru_nswap = p->usage.ru_nswap + p->cusage.ru_nswap;
p                  87 kernel/process.c 	cru->ru_inblock = p->usage.ru_inblock + p->cusage.ru_inblock;
p                  88 kernel/process.c 	cru->ru_oublock = p->usage.ru_oublock + p->cusage.ru_oublock;
p                  89 kernel/process.c 	cru->ru_msgsnd = p->usage.ru_msgsnd + p->cusage.ru_msgsnd;
p                  90 kernel/process.c 	cru->ru_msgrcv = p->usage.ru_msgrcv + p->cusage.ru_msgrcv;
p                  91 kernel/process.c 	cru->ru_nsignals = p->usage.ru_nsignals + p->cusage.ru_nsignals;
p                  92 kernel/process.c 	cru->ru_nvcsw = p->usage.ru_nvcsw + p->cusage.ru_nvcsw;
p                  93 kernel/process.c 	cru->ru_nivcsw = p->usage.ru_nivcsw + p->cusage.ru_nivcsw;
p                  96 kernel/process.c void get_rusage(struct proc *p, struct rusage *ru)
p                 109 kernel/process.c 	add_crusage(p, &cru);
p                 114 kernel/process.c void add_rusage(struct proc *p)
p                 118 kernel/process.c 	add_crusage(p, &cru);
p                 149 kernel/process.c 	struct proc *p;
p                 155 kernel/process.c 	FOR_EACH_PROCESS(p) {
p                 156 kernel/process.c 		if(p->ppid == parent->pid && p->state == PROC_ZOMBIE) {
p                 157 kernel/process.c 			return p;
p                 159 kernel/process.c 		p = p->next;
p                 165 kernel/process.c __pid_t remove_zombie(struct proc *p)
p                 170 kernel/process.c 	pid = p->pid;
p                 171 kernel/process.c 	kfree(p->tss.esp0);
p                 172 kernel/process.c 	p->rss--;
p                 173 kernel/process.c 	kfree(P2V(p->tss.cr3));
p                 174 kernel/process.c 	p->rss--;
p                 175 kernel/process.c 	pp = get_proc_by_pid(p->ppid);
p                 176 kernel/process.c 	release_proc(p);
p                 190 kernel/process.c 	struct proc *p, *pp;
p                 196 kernel/process.c 	FOR_EACH_PROCESS(p) {
p                 197 kernel/process.c 		if(p->pgid == pgid) {
p                 198 kernel/process.c 			if(p->state != PROC_ZOMBIE) {
p                 199 kernel/process.c 				pp = get_proc_by_pid(p->ppid);
p                 201 kernel/process.c 				if(pp->pgid != pgid || pp->sid == p->sid) {
p                 206 kernel/process.c 		p = p->next;
p                 215 kernel/process.c 	struct proc *p = NULL;
p                 227 kernel/process.c 		p = proc_pool_head;
p                 236 kernel/process.c 	return p;
p                 239 kernel/process.c void release_proc(struct proc *p)
p                 244 kernel/process.c 	if(p == proc_table_tail) {
p                 252 kernel/process.c 		p->prev->next = p->next;
p                 253 kernel/process.c 		p->next->prev = p->prev;
p                 257 kernel/process.c 	memset_b(p, NULL, sizeof(struct proc));
p                 258 kernel/process.c 	p->next = proc_pool_head;
p                 259 kernel/process.c 	proc_pool_head = p;
p                 268 kernel/process.c 	struct proc *p;
p                 283 kernel/process.c 	FOR_EACH_PROCESS(p) {
p                 288 kernel/process.c 		if(lastpid == p->pid || lastpid == p->pgid || lastpid == p->sid) {
p                 291 kernel/process.c 		p = p->next;
p                 300 kernel/process.c 	struct proc *p;
p                 302 kernel/process.c 	FOR_EACH_PROCESS(p) {
p                 303 kernel/process.c 		if(p->pid == pid) {
p                 304 kernel/process.c 			return p;
p                 306 kernel/process.c 		p = p->next;
p                 334 kernel/process.c 	struct proc *p;
p                 336 kernel/process.c 	p = get_proc_free();
p                 337 kernel/process.c 	proc_slot_init(p);
p                 338 kernel/process.c 	p->pid = get_unused_pid();
p                 339 kernel/process.c 	p->ppid = 0;
p                 340 kernel/process.c 	p->flags |= PF_KPROC;
p                 341 kernel/process.c 	p->priority = DEF_PRIORITY;
p                 342 kernel/process.c 	if(!(p->tss.esp0 = kmalloc())) {
p                 343 kernel/process.c 		release_proc(p);
p                 346 kernel/process.c 	p->tss.esp0 += PAGE_SIZE - 4;
p                 347 kernel/process.c 	p->rss++;
p                 348 kernel/process.c 	p->tss.cr3 = (unsigned int)kpage_dir;
p                 349 kernel/process.c 	p->tss.eip = (unsigned int)fn;
p                 350 kernel/process.c 	p->tss.esp = p->tss.esp0;
p                 351 kernel/process.c 	sprintk(p->pidstr, "%d", p->pid);
p                 352 kernel/process.c 	sprintk(p->argv0, "%s", name);
p                 353 kernel/process.c 	runnable(p);
p                 354 kernel/process.c 	return p;
p                 357 kernel/process.c void proc_slot_init(struct proc *p)
p                 364 kernel/process.c 		p->prev = NULL;
p                 365 kernel/process.c 		p->next = NULL;
p                 366 kernel/process.c 		proc_table_head = proc_table_tail = p;
p                 368 kernel/process.c 		p->prev = proc_table_tail;
p                 369 kernel/process.c 		p->next = NULL;
p                 370 kernel/process.c 		proc_table_tail->next = p;
p                 371 kernel/process.c 		proc_table_tail = p;
p                 373 kernel/process.c 	p->prev_sleep = p->next_sleep = NULL;
p                 374 kernel/process.c 	p->prev_run = p->next_run = NULL;
p                 377 kernel/process.c 	memset_b(&p->tss, NULL, sizeof(struct i386tss));
p                 378 kernel/process.c 	p->tss.io_bitmap_addr = (unsigned int)&p->io_bitmap;
p                 386 kernel/process.c 		p->io_bitmap[n] = 0;	/* FIXME: change it to 1 */
p                 388 kernel/process.c 	p->state = PROC_IDLE;
p                 394 kernel/process.c 	struct proc *p;
p                 402 kernel/process.c 		p = &proc_table[n];
p                 405 kernel/process.c 		p->next = proc_pool_head;
p                 406 kernel/process.c 		proc_pool_head = p;
p                  35 kernel/sched.c void set_tss(struct proc *p)
p                  41 kernel/sched.c 	g->sd_lobase = (unsigned int)p;
p                  43 kernel/sched.c 	g->sd_hibase = (char)(((unsigned int)p) >> 24);
p                  50 kernel/sched.c 	struct proc *p, *selected;
p                  62 kernel/sched.c 		FOR_EACH_PROCESS_RUNNING(p) {
p                  63 kernel/sched.c 			if(p->cpu_count > count) {
p                  64 kernel/sched.c 				count = p->cpu_count;
p                  65 kernel/sched.c 				selected = p;
p                  67 kernel/sched.c 			p = p->next_run;
p                  74 kernel/sched.c 		FOR_EACH_PROCESS_RUNNING(p) {
p                  75 kernel/sched.c 			p->cpu_count = p->priority;
p                  76 kernel/sched.c 			p = p->next_run;
p                  21 kernel/signal.c int send_sig(struct proc *p, __sigset_t signum)
p                  23 kernel/signal.c 	if(signum > NSIG || !p) {
p                  27 kernel/signal.c 	if(!IS_SUPERUSER && current->euid != p->euid && current->sid != p->sid) {
p                  32 kernel/signal.c 	if(p->flags & PF_KPROC) {
p                  41 kernel/signal.c 			if(p->state == PROC_STOPPED) {
p                  42 kernel/signal.c 				runnable(p);
p                  46 kernel/signal.c 			p->sigpending &= SIG_MASK(SIGSTOP);
p                  47 kernel/signal.c 			p->sigpending &= SIG_MASK(SIGTSTP);
p                  48 kernel/signal.c 			p->sigpending &= SIG_MASK(SIGTTIN);
p                  49 kernel/signal.c 			p->sigpending &= SIG_MASK(SIGTTOU);
p                  56 kernel/signal.c 			p->sigpending &= SIG_MASK(SIGCONT);
p                  69 kernel/signal.c 			if(p->sigaction[signum - 1].sa_handler == SIG_IGN) {
p                  70 kernel/signal.c 				p->sigaction[signum - 1].sa_handler = SIG_DFL;
p                  75 kernel/signal.c 	if(p->sigaction[signum - 1].sa_handler == SIG_DFL) {
p                  81 kernel/signal.c 		if(p->pid == INIT) {
p                  91 kernel/signal.c 	if(p->sigaction[signum - 1].sa_handler == SIG_IGN) {
p                 101 kernel/signal.c 	p->sigpending |= 1 << (signum - 1);
p                 102 kernel/signal.c 	p->usage.ru_nsignals++;
p                 105 kernel/signal.c 	if(!(p->sigblocked & (1 << (signum - 1)))) {
p                 106 kernel/signal.c 		wakeup_proc(p);
p                 116 kernel/signal.c 	struct proc *p;
p                 127 kernel/signal.c 					while((p = get_next_zombie(current))) {
p                 128 kernel/signal.c 						remove_zombie(p);
p                 152 kernel/signal.c 	struct proc *p;
p                 195 kernel/signal.c 							if((p = get_proc_by_pid(current->ppid))) {
p                 196 kernel/signal.c 								send_sig(p, SIGCHLD);
p                  25 kernel/sleep.c void runnable(struct proc *p)
p                  27 kernel/sleep.c 	if(p->state == PROC_RUNNING) {
p                  28 kernel/sleep.c 		printk("WARNING: %s(): process with pid '%d' is already running!\n", __FUNCTION__, p->pid);
p                  33 kernel/sleep.c 		p->next_run = proc_run_head;
p                  34 kernel/sleep.c 		proc_run_head->prev_run = p;
p                  36 kernel/sleep.c 	proc_run_head = p;
p                  37 kernel/sleep.c 	p->state = PROC_RUNNING;
p                  40 kernel/sleep.c void not_runnable(struct proc *p, int state)
p                  42 kernel/sleep.c 	if(p->next_run) {
p                  43 kernel/sleep.c 		p->next_run->prev_run = p->prev_run;
p                  45 kernel/sleep.c 	if(p->prev_run) {
p                  46 kernel/sleep.c 		p->prev_run->next_run = p->next_run;
p                  48 kernel/sleep.c 	if(p == proc_run_head) {
p                  49 kernel/sleep.c 		proc_run_head = p->next_run;
p                  51 kernel/sleep.c 	p->prev_run = p->next_run = NULL;
p                  52 kernel/sleep.c 	p->state = state;
p                 135 kernel/sleep.c void wakeup_proc(struct proc *p)
p                 141 kernel/sleep.c 	if(p->state != PROC_SLEEPING && p->state != PROC_STOPPED) {
p                 148 kernel/sleep.c 	if(p->sleep_address) {
p                 149 kernel/sleep.c 		if(p->next_sleep) {
p                 150 kernel/sleep.c 			p->next_sleep->prev_sleep = p->prev_sleep;
p                 152 kernel/sleep.c 		if(p->prev_sleep) {
p                 153 kernel/sleep.c 			p->prev_sleep->next_sleep = p->next_sleep;
p                 156 kernel/sleep.c 		i = SLEEP_HASH((unsigned int)p->sleep_address);
p                 159 kernel/sleep.c 		if(*h == p) {	/* if it's the head */
p                 163 kernel/sleep.c 	p->sleep_address = NULL;
p                 164 kernel/sleep.c 	runnable(p);
p                  62 kernel/syscalls/execve.c 	int n, p, offset;
p                  71 kernel/syscalls/execve.c 	p = ARG_MAX - 1;
p                  73 kernel/syscalls/execve.c 	p -= ae_str_len / PAGE_SIZE;
p                  77 kernel/syscalls/execve.c 		p++;
p                  79 kernel/syscalls/execve.c 	page = (char *)barg->page[p];
p                  84 kernel/syscalls/execve.c 			p++;
p                  86 kernel/syscalls/execve.c 			page = (char *)barg->page[p];
p                  92 kernel/syscalls/execve.c 	p = ARG_MAX - 1;
p                 101 kernel/syscalls/execve.c 	p -= ae_str_len / PAGE_SIZE;
p                 105 kernel/syscalls/execve.c 		p++;
p                 108 kernel/syscalls/execve.c 	for(n = p; n < ARG_MAX; n++) {
p                 118 kernel/syscalls/execve.c 	page = (char *)barg->page[p];
p                 124 kernel/syscalls/execve.c 			p++;
p                 126 kernel/syscalls/execve.c 			page = (char *)barg->page[p];
p                 131 kernel/syscalls/execve.c 		p++;
p                 136 kernel/syscalls/execve.c 	page = (char *)barg->page[p];
p                 143 kernel/syscalls/execve.c 				p++;
p                 145 kernel/syscalls/execve.c 				page = (char *)barg->page[p];
p                 150 kernel/syscalls/execve.c 			p++;
p                 156 kernel/syscalls/execve.c 	page = (char *)barg->page[p];
p                 162 kernel/syscalls/execve.c 			p++;
p                 164 kernel/syscalls/execve.c 			page = (char *)barg->page[p];
p                 174 kernel/syscalls/execve.c 	int n, p, offset;
p                 178 kernel/syscalls/execve.c 	p = ARG_MAX - 1;
p                 180 kernel/syscalls/execve.c 	p -= ae_str_len / PAGE_SIZE;
p                 184 kernel/syscalls/execve.c 		p++;
p                 187 kernel/syscalls/execve.c 	for(n = p; n < ARG_MAX; n++) {
p                 195 kernel/syscalls/execve.c 		page = (char *)barg->page[p];
p                 201 kernel/syscalls/execve.c 				p++;
p                 203 kernel/syscalls/execve.c 				page = (char *)barg->page[p];
p                 208 kernel/syscalls/execve.c 			p++;
p                 214 kernel/syscalls/execve.c 		page = (char *)barg->page[p];
p                 220 kernel/syscalls/execve.c 				p++;
p                 222 kernel/syscalls/execve.c 				page = (char *)barg->page[p];
p                 227 kernel/syscalls/execve.c 			p++;
p                  21 kernel/syscalls/exit.c 	struct proc *p, *init;
p                  34 kernel/syscalls/exit.c 	FOR_EACH_PROCESS(p) {
p                  36 kernel/syscalls/exit.c 			if(p->sid == current->sid && p->state != PROC_ZOMBIE) {
p                  37 kernel/syscalls/exit.c 				p->pgid = 0;
p                  38 kernel/syscalls/exit.c 				p->sid = 0;
p                  39 kernel/syscalls/exit.c 				p->ctty = NULL;
p                  40 kernel/syscalls/exit.c 				send_sig(p, SIGHUP);
p                  41 kernel/syscalls/exit.c 				send_sig(p, SIGCONT);
p                  46 kernel/syscalls/exit.c 		if(p->ppid == current->pid) {
p                  47 kernel/syscalls/exit.c 			p->ppid = INIT;
p                  50 kernel/syscalls/exit.c 			if(p->state == PROC_ZOMBIE) {
p                  57 kernel/syscalls/exit.c 		p = p->next;
p                  82 kernel/syscalls/exit.c 	if((p = get_proc_by_pid(current->ppid))) {
p                  83 kernel/syscalls/exit.c 		send_sig(p, SIGCHLD);
p                  84 kernel/syscalls/exit.c 		if(p->sleep_address == &sys_wait4) {
p                  85 kernel/syscalls/exit.c 			wakeup_proc(p);
p                  27 kernel/syscalls/fork.c 	struct proc *child, *p;
p                  37 kernel/syscalls/fork.c 	FOR_EACH_PROCESS(p) {
p                  38 kernel/syscalls/fork.c 		if(p->uid == current->uid) {
p                  41 kernel/syscalls/fork.c 		p = p->next;
p                  19 kernel/syscalls/getpgid.c 	struct proc *p;
p                  31 kernel/syscalls/getpgid.c 	FOR_EACH_PROCESS(p) {
p                  32 kernel/syscalls/getpgid.c 		if(p->pid == pid) {
p                  33 kernel/syscalls/getpgid.c 			return p->pgid;
p                  35 kernel/syscalls/getpgid.c 		p = p->next;
p                  19 kernel/syscalls/getsid.c 	struct proc *p;
p                  32 kernel/syscalls/getsid.c 	FOR_EACH_PROCESS(p) {
p                  33 kernel/syscalls/getsid.c 		if(p->pid == pid) {
p                  34 kernel/syscalls/getsid.c 			return p->sid;
p                  36 kernel/syscalls/getsid.c 		p = p->next;
p                  19 kernel/syscalls/kill.c 	struct proc *p;
p                  30 kernel/syscalls/kill.c 		FOR_EACH_PROCESS(p) {
p                  31 kernel/syscalls/kill.c 			if(p->pid > 1 && p != current) {
p                  33 kernel/syscalls/kill.c 				send_sig(p, signum);
p                  35 kernel/syscalls/kill.c 			p = p->next;
p                  19 kernel/syscalls/setpgid.c 	struct proc *p;
p                  32 kernel/syscalls/setpgid.c 	if(!(p = get_proc_by_pid(pid))) {
p                  36 kernel/syscalls/setpgid.c 		pgid = p->pid;
p                  39 kernel/syscalls/setpgid.c 	if(p != current && p->ppid != current->pid) {
p                  42 kernel/syscalls/setpgid.c 	if(p->sid == p->pid || p->sid != current->sid) {
p                  47 kernel/syscalls/setpgid.c 		struct proc *p;
p                  49 kernel/syscalls/setpgid.c 		FOR_EACH_PROCESS(p) {
p                  50 kernel/syscalls/setpgid.c 			if(p->pgid == pgid && p->sid != current->sid) {
p                  53 kernel/syscalls/setpgid.c 			p = p->next;
p                  57 kernel/syscalls/setpgid.c 	if(p != current && p->flags & PF_PEXEC) {
p                  61 kernel/syscalls/setpgid.c 	p->pgid = pgid;
p                  18 kernel/syscalls/setsid.c 	struct proc *p;
p                  27 kernel/syscalls/setsid.c 	FOR_EACH_PROCESS(p) {	/* POSIX ANSI/IEEE Std 1003.1-1996 4.3.2 */
p                  28 kernel/syscalls/setsid.c 		if(p != current && p->pgid == current->pid) {
p                  31 kernel/syscalls/setsid.c 		p = p->next;
p                  23 kernel/syscalls/sysinfo.c 	struct proc *p;
p                  44 kernel/syscalls/sysinfo.c 	FOR_EACH_PROCESS(p) {
p                  46 kernel/syscalls/sysinfo.c 		p = p->next;
p                  23 kernel/syscalls/wait4.c 	struct proc *p;
p                  37 kernel/syscalls/wait4.c 		FOR_EACH_PROCESS(p) {
p                  38 kernel/syscalls/wait4.c 			if(p->ppid != current->pid) {
p                  39 kernel/syscalls/wait4.c 				p = p->next;
p                  43 kernel/syscalls/wait4.c 				if(p->pid == pid) {
p                  48 kernel/syscalls/wait4.c 				if(p->pgid == current->pgid) {
p                  53 kernel/syscalls/wait4.c 				if(p->pgid == -pid) {
p                  61 kernel/syscalls/wait4.c 				if(p->state == PROC_STOPPED) {
p                  62 kernel/syscalls/wait4.c 					if(p->exit_code) {
p                  64 kernel/syscalls/wait4.c 							*status = (p->exit_code << 8) | 0x7F;
p                  66 kernel/syscalls/wait4.c 						p->exit_code = 0;
p                  69 kernel/syscalls/wait4.c 						get_rusage(p, ru);
p                  71 kernel/syscalls/wait4.c 					return p->pid;
p                  73 kernel/syscalls/wait4.c 				if(p->state == PROC_ZOMBIE) {
p                  74 kernel/syscalls/wait4.c 					add_rusage(p);
p                  76 kernel/syscalls/wait4.c 						*status = p->exit_code;
p                  79 kernel/syscalls/wait4.c 						get_rusage(p, ru);
p                  81 kernel/syscalls/wait4.c 					return remove_zombie(p);
p                  84 kernel/syscalls/wait4.c 			p = p->next;
p                  51 kernel/timer.c 	struct proc *p;
p                  54 kernel/timer.c 	FOR_EACH_PROCESS_RUNNING(p) {
p                  56 kernel/timer.c 		p = p->next_run;
p                 282 kernel/timer.c 	struct proc *p;
p                 297 kernel/timer.c 	FOR_EACH_PROCESS(p) {
p                 298 kernel/timer.c 		if(p->timeout > 0 && p->timeout < INFINITE_WAIT) {
p                 299 kernel/timer.c 			p->timeout--;
p                 300 kernel/timer.c 			if(!p->timeout) {
p                 301 kernel/timer.c 				wakeup_proc(p);
p                 304 kernel/timer.c 		if(p->it_real_value > 0) {
p                 305 kernel/timer.c 			p->it_real_value--;
p                 306 kernel/timer.c 			if(!p->it_real_value) {
p                 307 kernel/timer.c 				p->it_real_value = p->it_real_interval;
p                 308 kernel/timer.c 				send_sig(p, SIGALRM);
p                 311 kernel/timer.c 		p = p->next;
p                  77 lib/printk.c   	char *ptr_s, *p;
p                  86 lib/printk.c   	p = NULL;
p                 107 lib/printk.c   						p = ptr_s;
p                 122 lib/printk.c   						while(*p && count < MAX_BUF) {
p                 123 lib/printk.c   							*(buffer++) = *(p++);
p                 141 lib/printk.c   						p = ptr_s;
p                 152 lib/printk.c   						while(*p && count < MAX_BUF) {
p                 153 lib/printk.c   							*(buffer++) = *(p++);
p                 173 lib/printk.c   						p = ptr_s;
p                 184 lib/printk.c   						while(*p && count < MAX_BUF) {
p                 185 lib/printk.c   							*(buffer++) = *(p++);
p                 206 lib/printk.c   						p = ptr_s;
p                 217 lib/printk.c   						while(*p && count < MAX_BUF) {
p                 218 lib/printk.c   							*(buffer++) = *(p++);
p                 239 lib/printk.c   						p = ptr_s;
p                 250 lib/printk.c   						while(*p && count < MAX_BUF) {
p                 251 lib/printk.c   							*(buffer++) = *(p++);
p                 172 lib/strings.c  	char *p;
p                 174 lib/strings.c  	p = path + (strlen(path) - 1);
p                 175 lib/strings.c  	while(p > path && *p == '/') {
p                 176 lib/strings.c  		*p = NULL;
p                 177 lib/strings.c  		p--;
p                 115 mm/memory.c    unsigned int get_mapped_addr(struct proc *p, unsigned int addr)
p                 120 mm/memory.c    	pgdir = (unsigned int *)P2V(p->tss.cr3);
p                 185 mm/memory.c    int free_page_tables(struct proc *p)
p                 190 mm/memory.c    	pgdir = (unsigned int *)P2V(p->tss.cr3);
p                 201 mm/memory.c    unsigned int map_page(struct proc *p, unsigned int vaddr, unsigned int addr, unsigned int prot)
p                 207 mm/memory.c    	pgdir = (unsigned int *)P2V(p->tss.cr3);
p                 215 mm/memory.c    		p->rss++;
p                 226 mm/memory.c    			p->rss++;
p                  19 mm/mmap.c      void show_vma_regions(struct proc *p)
p                  29 mm/mmap.c      	vma = p->vma;