p                  37 kernel/exec.c    struct proc *p = myproc();
p                  56 kernel/exec.c    if ((pagetable = proc_pagetable(p)) == 0)
p                  83 kernel/exec.c    p = myproc();
p                  84 kernel/exec.c    uint64 oldsz = p->sz;
p                 124 kernel/exec.c    p->trapframe->a1 = sp;
p                 130 kernel/exec.c    safestrcpy(p->name, last, sizeof(p->name));
p                 133 kernel/exec.c    oldpagetable = p->pagetable;
p                 134 kernel/exec.c    p->pagetable = pagetable;
p                 135 kernel/exec.c    p->sz = sz;
p                 136 kernel/exec.c    p->trapframe->epc = elf.entry; // initial program counter = ulib.c:start()
p                 137 kernel/exec.c    p->trapframe->sp = sp;         // initial stack pointer
p                  90 kernel/file.c    struct proc *p = myproc();
p                  97 kernel/file.c      if (copyout(p->pagetable, p->sz, addr, (char *)&st, sizeof(st)) < 0)
p                  36 kernel/kalloc.c   char *p;
p                  37 kernel/kalloc.c   p = (char *)PGROUNDUP((uint64)pa_start);
p                  38 kernel/kalloc.c   for (; p + PGSIZE <= (char *)pa_end; p += PGSIZE)
p                  39 kernel/kalloc.c     kfree(p);
p                  52 kernel/memlayout.h #define KSTACK(p) (TRAMPOLINE - ((p) + 1) * 2 * PGSIZE)
p                  19 kernel/proc.c  static void freeproc(struct proc *p);
p                  35 kernel/proc.c    struct proc *p;
p                  37 kernel/proc.c    for (p = proc; p < &proc[NPROC]; p++) {
p                  41 kernel/proc.c      uint64 va = KSTACK((int)(p - proc));
p                  50 kernel/proc.c    struct proc *p;
p                  54 kernel/proc.c    for (p = proc; p < &proc[NPROC]; p++) {
p                  55 kernel/proc.c      initlock(&p->lock, "proc");
p                  56 kernel/proc.c      p->state = UNUSED;
p                  57 kernel/proc.c      p->kstack = KSTACK((int)(p - proc));
p                  87 kernel/proc.c    struct proc *p = c->proc;
p                  89 kernel/proc.c    return p;
p                 112 kernel/proc.c    struct proc *p;
p                 114 kernel/proc.c    for (p = proc; p < &proc[NPROC]; p++) {
p                 115 kernel/proc.c      acquire(&p->lock);
p                 116 kernel/proc.c      if (p->state == UNUSED) {
p                 119 kernel/proc.c        release(&p->lock);
p                 125 kernel/proc.c    p->pid = allocpid();
p                 126 kernel/proc.c    p->state = USED;
p                 129 kernel/proc.c    if ((p->trapframe = (struct trapframe *)kalloc()) == 0) {
p                 130 kernel/proc.c      freeproc(p);
p                 131 kernel/proc.c      release(&p->lock);
p                 136 kernel/proc.c    p->pagetable = proc_pagetable(p);
p                 137 kernel/proc.c    if (p->pagetable == 0) {
p                 138 kernel/proc.c      freeproc(p);
p                 139 kernel/proc.c      release(&p->lock);
p                 145 kernel/proc.c    memset(&p->context, 0, sizeof(p->context));
p                 146 kernel/proc.c    p->context.ra = (uint64)forkret;
p                 147 kernel/proc.c    p->context.sp = p->kstack + PGSIZE;
p                 149 kernel/proc.c    return p;
p                 156 kernel/proc.c  freeproc(struct proc *p)
p                 158 kernel/proc.c    if (p->trapframe)
p                 159 kernel/proc.c      kfree((void *)p->trapframe);
p                 160 kernel/proc.c    p->trapframe = 0;
p                 161 kernel/proc.c    if (p->pagetable)
p                 162 kernel/proc.c      proc_freepagetable(p->pagetable, p->sz);
p                 163 kernel/proc.c    p->pagetable = 0;
p                 164 kernel/proc.c    p->sz = 0;
p                 165 kernel/proc.c    p->pid = 0;
p                 166 kernel/proc.c    p->name[0] = 0;
p                 167 kernel/proc.c    p->chan = 0;
p                 168 kernel/proc.c    p->killed = 0;
p                 169 kernel/proc.c    p->xstate = 0;
p                 170 kernel/proc.c    p->state = UNUSED;
p                 176 kernel/proc.c  proc_pagetable(struct proc *p)
p                 197 kernel/proc.c    if (mappages(pagetable, TRAPFRAME, PGSIZE, (uint64)(p->trapframe),
p                 221 kernel/proc.c    struct proc *p;
p                 223 kernel/proc.c    p = allocproc();
p                 224 kernel/proc.c    initproc = p;
p                 226 kernel/proc.c    p->cwd = namei("/");
p                 228 kernel/proc.c    p->state = RUNNABLE;
p                 230 kernel/proc.c    release(&p->lock);
p                 239 kernel/proc.c    struct proc *p = myproc();
p                 241 kernel/proc.c    sz = p->sz;
p                 246 kernel/proc.c      if ((sz = uvmalloc(p->pagetable, sz, sz + n, PTE_W)) == 0) {
p                 250 kernel/proc.c      sz = uvmdealloc(p->pagetable, sz, sz + n);
p                 252 kernel/proc.c    p->sz = sz;
p                 263 kernel/proc.c    struct proc *p = myproc();
p                 271 kernel/proc.c    if (uvmcopy(p->pagetable, np->pagetable, p->sz) < 0) {
p                 276 kernel/proc.c    np->sz = p->sz;
p                 279 kernel/proc.c    *(np->trapframe) = *(p->trapframe);
p                 286 kernel/proc.c      if (p->ofile[i])
p                 287 kernel/proc.c        np->ofile[i] = filedup(p->ofile[i]);
p                 288 kernel/proc.c    np->cwd = idup(p->cwd);
p                 290 kernel/proc.c    safestrcpy(np->name, p->name, sizeof(p->name));
p                 297 kernel/proc.c    np->parent = p;
p                 310 kernel/proc.c  reparent(struct proc *p)
p                 315 kernel/proc.c      if (pp->parent == p) {
p                 328 kernel/proc.c    struct proc *p = myproc();
p                 330 kernel/proc.c    if (p == initproc)
p                 335 kernel/proc.c      if (p->ofile[fd]) {
p                 336 kernel/proc.c        struct file *f = p->ofile[fd];
p                 338 kernel/proc.c        p->ofile[fd] = 0;
p                 343 kernel/proc.c    iput(p->cwd);
p                 345 kernel/proc.c    p->cwd = 0;
p                 350 kernel/proc.c    reparent(p);
p                 353 kernel/proc.c    wakeup(p->parent);
p                 355 kernel/proc.c    acquire(&p->lock);
p                 357 kernel/proc.c    p->xstate = status;
p                 358 kernel/proc.c    p->state = ZOMBIE;
p                 374 kernel/proc.c    struct proc *p = myproc();
p                 382 kernel/proc.c        if (pp->parent == p) {
p                 391 kernel/proc.c                copyout(p->pagetable, p->sz, addr, (char *)&pp->xstate,
p                 408 kernel/proc.c      if (!havekids || killed(p)) {
p                 414 kernel/proc.c      sleep_prepare(p); //DOC: wait-sleep
p                 431 kernel/proc.c    struct proc *p;
p                 445 kernel/proc.c      for (p = proc; p < &proc[NPROC]; p++) {
p                 446 kernel/proc.c        acquire(&p->lock);
p                 447 kernel/proc.c        if (p->state == RUNNABLE) {
p                 451 kernel/proc.c          p->state = RUNNING;
p                 452 kernel/proc.c          c->proc = p;
p                 453 kernel/proc.c          swtch(&c->context, &p->context);
p                 463 kernel/proc.c        release(&p->lock);
p                 483 kernel/proc.c    struct proc *p = myproc();
p                 485 kernel/proc.c    if (!holding(&p->lock))
p                 489 kernel/proc.c    if (p->state == RUNNING)
p                 495 kernel/proc.c    swtch(&p->context, &mycpu()->context);
p                 503 kernel/proc.c    struct proc *p = myproc();
p                 504 kernel/proc.c    acquire(&p->lock);
p                 505 kernel/proc.c    p->state = RUNNABLE;
p                 507 kernel/proc.c    release(&p->lock);
p                 517 kernel/proc.c    struct proc *p = myproc();
p                 520 kernel/proc.c    release(&p->lock);
p                 532 kernel/proc.c      p->trapframe->a0 = kexec("/init", (char *[]){"/init", 0});
p                 533 kernel/proc.c      if (p->trapframe->a0 == -1) {
p                 540 kernel/proc.c    uint64 satp = MAKE_SATP(p->pagetable);
p                 549 kernel/proc.c    struct proc *p = myproc();
p                 551 kernel/proc.c    acquire(&p->lock);
p                 554 kernel/proc.c    p->chan = chan;
p                 555 kernel/proc.c    release(&p->lock);
p                 564 kernel/proc.c    struct proc *p = myproc();
p                 566 kernel/proc.c    acquire(&p->lock);
p                 567 kernel/proc.c    if (p->chan != 0) {
p                 568 kernel/proc.c      p->state = SLEEPING;
p                 571 kernel/proc.c    release(&p->lock);
p                 578 kernel/proc.c    struct proc *p;
p                 580 kernel/proc.c    for (p = proc; p < &proc[NPROC]; p++) {
p                 581 kernel/proc.c      acquire(&p->lock);
p                 582 kernel/proc.c      if (p->chan == chan) {
p                 585 kernel/proc.c        p->chan = 0;
p                 589 kernel/proc.c        if (p->state == SLEEPING) {
p                 590 kernel/proc.c          p->state = RUNNABLE;
p                 593 kernel/proc.c      release(&p->lock);
p                 603 kernel/proc.c    struct proc *p;
p                 608 kernel/proc.c    for (p = proc; p < &proc[NPROC]; p++) {
p                 609 kernel/proc.c      acquire(&p->lock);
p                 610 kernel/proc.c      if (p->pid == pid) {
p                 611 kernel/proc.c        p->killed = 1;
p                 612 kernel/proc.c        if (p->state == SLEEPING) {
p                 614 kernel/proc.c          p->state = RUNNABLE;
p                 616 kernel/proc.c        release(&p->lock);
p                 619 kernel/proc.c      release(&p->lock);
p                 625 kernel/proc.c  setkilled(struct proc *p)
p                 627 kernel/proc.c    acquire(&p->lock);
p                 628 kernel/proc.c    p->killed = 1;
p                 629 kernel/proc.c    release(&p->lock);
p                 633 kernel/proc.c  killed(struct proc *p)
p                 637 kernel/proc.c    acquire(&p->lock);
p                 638 kernel/proc.c    k = p->killed;
p                 639 kernel/proc.c    release(&p->lock);
p                 649 kernel/proc.c    struct proc *p = myproc();
p                 651 kernel/proc.c      return copyout(p->pagetable, p->sz, dst, src, len);
p                 664 kernel/proc.c    struct proc *p = myproc();
p                 666 kernel/proc.c      return copyin(p->pagetable, p->sz, dst, src, len);
p                 689 kernel/proc.c    struct proc *p;
p                 693 kernel/proc.c    for (p = proc; p < &proc[NPROC]; p++) {
p                 694 kernel/proc.c      if (p->state == UNUSED)
p                 696 kernel/proc.c      if (p->state >= 0 && p->state < NELEM(states) && states[p->state])
p                 697 kernel/proc.c        state = states[p->state];
p                 700 kernel/proc.c      printk("%d %s %s", p->pid, state, p->name);
p                  61 kernel/string.c strncmp(const char *p, const char *q, uint n)
p                  63 kernel/string.c   while (n > 0 && *p && *p == *q)
p                  64 kernel/string.c     n--, p++, q++;
p                  67 kernel/string.c   return (uchar)*p - (uchar)*q;
p                  14 kernel/syscall.c   struct proc *p = myproc();
p                  15 kernel/syscall.c   if (addr >= p->sz ||
p                  16 kernel/syscall.c       addr + sizeof(uint64) > p->sz) // both tests needed, in case of overflow
p                  18 kernel/syscall.c   if (copyin(p->pagetable, p->sz, (char *)ip, addr, sizeof(*ip)) != 0)
p                  28 kernel/syscall.c   struct proc *p = myproc();
p                  29 kernel/syscall.c   if (copyinstr(p->pagetable, p->sz, buf, addr, max) < 0)
p                  37 kernel/syscall.c   struct proc *p = myproc();
p                  40 kernel/syscall.c     return p->trapframe->a0;
p                  42 kernel/syscall.c     return p->trapframe->a1;
p                  44 kernel/syscall.c     return p->trapframe->a2;
p                  46 kernel/syscall.c     return p->trapframe->a3;
p                  48 kernel/syscall.c     return p->trapframe->a4;
p                  50 kernel/syscall.c     return p->trapframe->a5;
p                 140 kernel/syscall.c   struct proc *p = myproc();
p                 142 kernel/syscall.c   num = p->trapframe->a7;
p                 146 kernel/syscall.c     p->trapframe->a0 = syscalls[num]();
p                 148 kernel/syscall.c     printk("%d %s: unknown sys call %d\n", p->pid, p->name, num);
p                 149 kernel/syscall.c     p->trapframe->a0 = -1;
p                  43 kernel/sysfile.c   struct proc *p = myproc();
p                  46 kernel/sysfile.c     if (p->ofile[fd] == 0) {
p                  47 kernel/sysfile.c       p->ofile[fd] = f;
p                  73 kernel/sysfile.c   uint64 p;
p                  75 kernel/sysfile.c   argaddr(1, &p);
p                  79 kernel/sysfile.c   return fileread(f, p, n);
p                  87 kernel/sysfile.c   uint64 p;
p                  89 kernel/sysfile.c   argaddr(1, &p);
p                  94 kernel/sysfile.c   return filewrite(f, p, n);
p                 438 kernel/sysfile.c   struct proc *p = myproc();
p                 452 kernel/sysfile.c   iput(p->cwd);
p                 454 kernel/sysfile.c   p->cwd = ip;
p                 507 kernel/sysfile.c   struct proc *p = myproc();
p                 515 kernel/sysfile.c       p->ofile[fd0] = 0;
p                 520 kernel/sysfile.c   if (copyout(p->pagetable, p->sz, fdarray, (char *)&fd0, sizeof(fd0)) < 0 ||
p                 521 kernel/sysfile.c       copyout(p->pagetable, p->sz, fdarray + sizeof(fd0), (char *)&fd1,
p                 523 kernel/sysfile.c     p->ofile[fd0] = 0;
p                 524 kernel/sysfile.c     p->ofile[fd1] = 0;
p                  34 kernel/sysproc.c   uint64 p;
p                  35 kernel/sysproc.c   argaddr(0, &p);
p                  36 kernel/sysproc.c   return kwait(p);
p                  49 kernel/trap.c    struct proc *p = myproc();
p                  52 kernel/trap.c    p->trapframe->epc = r_sepc();
p                  57 kernel/trap.c      if (killed(p))
p                  62 kernel/trap.c      p->trapframe->epc += 4;
p                  72 kernel/trap.c               vmfault(p->pagetable, p->sz, r_stval(),
p                  76 kernel/trap.c      printk("usertrap(): unexpected scause 0x%lx pid=%d\n", r_scause(), p->pid);
p                  78 kernel/trap.c      setkilled(p);
p                  81 kernel/trap.c    if (killed(p))
p                  91 kernel/trap.c    uint64 satp = MAKE_SATP(p->pagetable);
p                 103 kernel/trap.c    struct proc *p = myproc();
p                 116 kernel/trap.c    p->trapframe->kernel_satp = r_satp();         // kernel page table
p                 117 kernel/trap.c    p->trapframe->kernel_sp = p->kstack + PGSIZE; // process's kernel stack
p                 118 kernel/trap.c    p->trapframe->kernel_trap = (uint64)usertrap;
p                 119 kernel/trap.c    p->trapframe->kernel_hartid = r_tp(); // hartid for cpuid()
p                 131 kernel/trap.c    w_sepc(p->trapframe->epc);
p                 430 kernel/vm.c        char *p = (char *)(pa0 + (srcva - va0));
p                 432 kernel/vm.c          if (*p == '\0') {
p                 437 kernel/vm.c            *dst = *p;
p                 441 kernel/vm.c          p++;
p                  46 mkfs/mkfs.c    void iappend(uint inum, void *p, int n);
p                 261 mkfs/mkfs.c      char *p = (char *)xp;
p                 292 mkfs/mkfs.c        bcopy(p, buf + off - (fbn * BSIZE), n1);
p                 296 mkfs/mkfs.c        p += n1;
p                  15 user/grep.c      char *p, *q;
p                  21 user/grep.c        p = buf;
p                  22 user/grep.c        while ((q = strchr(p, '\n')) != 0) {
p                  24 user/grep.c          if (match(pattern, p)) {
p                  26 user/grep.c            write(1, p, q + 1 - p);
p                  28 user/grep.c          p = q + 1;
p                  31 user/grep.c          m -= p - buf;
p                  32 user/grep.c          memmove(buf, p, m);
p                  11 user/ls.c        char *p;
p                  14 user/ls.c        for (p = path + strlen(path); p >= path && *p != '/'; p--)
p                  16 user/ls.c        p++;
p                  19 user/ls.c        if (strlen(p) >= DIRSIZ)
p                  20 user/ls.c          return p;
p                  21 user/ls.c        memmove(buf, p, strlen(p));
p                  22 user/ls.c        memset(buf + strlen(p), ' ', DIRSIZ - strlen(p));
p                  30 user/ls.c        char buf[512], *p;
p                  58 user/ls.c          p = buf + strlen(buf);
p                  59 user/ls.c          *p++ = '/';
p                  63 user/ls.c            memmove(p, de.name, DIRSIZ);
p                  64 user/ls.c            p[DIRSIZ] = 0;
p                  61 user/sh.c        int p[2];
p                 103 user/sh.c          if (pipe(p) < 0)
p                 107 user/sh.c            dup(p[1]);
p                 108 user/sh.c            close(p[0]);
p                 109 user/sh.c            close(p[1]);
p                 114 user/sh.c            dup(p[0]);
p                 115 user/sh.c            close(p[0]);
p                 116 user/sh.c            close(p[1]);
p                 119 user/sh.c          close(p[0]);
p                 120 user/sh.c          close(p[1]);
p                  32 user/ulib.c    strcmp(const char *p, const char *q)
p                  34 user/ulib.c      while (*p && *p == *q)
p                  35 user/ulib.c        p++, q++;
p                  36 user/ulib.c      return (uchar)*p - (uchar)*q;
p                  27 user/umalloc.c   Header *bp, *p;
p                  30 user/umalloc.c   for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
p                  31 user/umalloc.c     if (p >= p->s.ptr && (bp > p || bp < p->s.ptr))
p                  33 user/umalloc.c   if (bp + bp->s.size == p->s.ptr) {
p                  34 user/umalloc.c     bp->s.size += p->s.ptr->s.size;
p                  35 user/umalloc.c     bp->s.ptr = p->s.ptr->s.ptr;
p                  37 user/umalloc.c     bp->s.ptr = p->s.ptr;
p                  38 user/umalloc.c   if (p + p->s.size == bp) {
p                  39 user/umalloc.c     p->s.size += bp->s.size;
p                  40 user/umalloc.c     p->s.ptr = bp->s.ptr;
p                  42 user/umalloc.c     p->s.ptr = bp;
p                  43 user/umalloc.c   freep = p;
p                  49 user/umalloc.c   char *p;
p                  54 user/umalloc.c   p = sbrk(nu * sizeof(Header));
p                  55 user/umalloc.c   if (p == SBRK_ERROR)
p                  57 user/umalloc.c   hp = (Header *)p;
p                  66 user/umalloc.c   Header *p, *prevp;
p                  74 user/umalloc.c   for (p = prevp->s.ptr;; prevp = p, p = p->s.ptr) {
p                  75 user/umalloc.c     if (p->s.size >= nunits) {
p                  76 user/umalloc.c       if (p->s.size == nunits)
p                  77 user/umalloc.c         prevp->s.ptr = p->s.ptr;
p                  79 user/umalloc.c         p->s.size -= nunits;
p                  80 user/umalloc.c         p += p->s.size;
p                  81 user/umalloc.c         p->s.size = nunits;
p                  84 user/umalloc.c       return (void *)(p + 1);
p                  86 user/umalloc.c     if (p == freep)
p                  87 user/umalloc.c       if ((p = morecore(nunits)) == 0)
p                2098 user/usertests.c   char *c, *oldbrk, *a, *lastaddr, *p;
p                2106 user/usertests.c   p = sbrk(amt);
p                2107 user/usertests.c   if (p != a) {
p                2305 user/usertests.c   uint64 p;
p                2308 user/usertests.c   for (p = 0; p <= (uint)hi; p += PGSIZE) {
p                2310 user/usertests.c     if (link("nosuchfile", (char *)p) != -1) {
p                2585 user/usertests.c   char *p = (char *)(top - 64);
p                2586 user/usertests.c   p[0] = 'x';
p                2587 user/usertests.c   p[1] = '\0';
p                2588 user/usertests.c   int fd = open(p, O_RDWR | O_CREATE);
p                2589 user/usertests.c   write(fd, p, 1);
p                2591 user/usertests.c   fd = open(p, O_RDWR);
p                2592 user/usertests.c   p[0] = '\0';
p                2593 user/usertests.c   read(fd, p, 1);
p                2594 user/usertests.c   if (p[0] != 'x')
p                2698 user/usertests.c     char *p = sbrk(0);
p                2700 user/usertests.c     open(p + 8192, 0);
p                2746 user/usertests.c   char *p = sbrk(0);
p                2747 user/usertests.c   sbrk(PGSIZE - ((uint64)p % PGSIZE));
p                2749 user/usertests.c   p = sbrk(0);
p                2750 user/usertests.c   if ((uint64)p % PGSIZE != 0) {
p                2756 user/usertests.c   p[4095] = '/';
p                2757 user/usertests.c   int fd = open(&p[4095], O_RDONLY);
p                2782 user/usertests.c   char *p = sbrk(0);
p                2783 user/usertests.c   while ((uint64)p < MAXVA - (1 << 30)) {
p                2784 user/usertests.c     p = sbrklazy(1 << 30);
p                2785 user/usertests.c     if (p < 0) {
p                2786 user/usertests.c       printf("sbrklazy(%d) returned %p\n", 1 << 30, p);
p                2790 user/usertests.c     p = sbrklazy(0);
p                2793 user/usertests.c   int n = TRAPFRAME - PGSIZE - (uint64)p;
p                2796 user/usertests.c   if (p1 < 0 || p1 != p) {
p                2797 user/usertests.c     printf("sbrklazy(%d) returned %p, not expected %p\n", n, p1, p);
p                2801 user/usertests.c   p = sbrk(PGSIZE);
p                2802 user/usertests.c   if (p < 0 || (uint64)p != TRAPFRAME - PGSIZE) {
p                2803 user/usertests.c     printf("sbrk(%d) returned %p, not expected TRAPFRAME-PGSIZE\n", PGSIZE, p);
p                2807 user/usertests.c   p[0] = 1;
p                2808 user/usertests.c   if (p[1] != 0) {
p                2813 user/usertests.c   p = sbrk(1);
p                2814 user/usertests.c   if ((uint64)p != -1) {
p                2815 user/usertests.c     printf("sbrk(1) returned %p, expected error\n", p);
p                2819 user/usertests.c   p = sbrklazy(1);
p                2820 user/usertests.c   if ((uint64)p != -1) {
p                2821 user/usertests.c     printf("sbrklazy(1) returned %p, expected error\n", p);
p                2858 user/usertests.c   char *p = sbrk(0);
p                2859 user/usertests.c   sbrk(PGSIZE - ((uint64)p % PGSIZE));
p                2861 user/usertests.c   p = sbrk(0);
p                2862 user/usertests.c   if ((uint64)p % PGSIZE != 0) {
p                2867 user/usertests.c   p[-1] = 'X';
p                2869 user/usertests.c   cc = write(fd, p - 1, 2);