$ ps
pid,state,name
1,sleep,init
2,sleep,sh
3,run,ps

$ ps 1 2
pid,state,name
1,sleep,init 
2,sleep,sh

$ ps 10
pid,state,name

int ps(int pid)

int
ps(int pid)
{
	static char *states[] = {
		[UNUSED] "unused",
		[USED] "used",
		[SLEEPING] "sleep",
		[RUNNABLE] "runble",
		[RUNNING] "run",
		[ZOMBIE] "zombie"
	};
 
	struct proc *p;
 
	int unfound = 1;
 
	if (pid == 0) {
		for(p = proc; p < &proc[NPROC]; p++) {
			int pid_local;
			char state_local[16];
			char name_local[16];
			if(p->state > UNUSED && p->state <= NELEM(states)) {
				acquire(&p->lock);
				unfound = 0;
				pid_local = p->pid;
				safestrcpy(state_local, states[p->state], 16);
				safestrcpy(name_local, p->name, 16);
				release(&p->lock);
				printf("%d,%s,%s\n", pid_local, state_local, name_local);
			}
		}
		
		if (unfound) {
			return 1;
		}
		return 0;
	}
 
		int pid_local;
		char state_local[16];
		char name_local[16];
		
	for(p = proc; p < &proc[NPROC]; p++) {
 
		acquire(&p->lock);
		if (p->pid != pid) {
			release(&p->lock);
			continue;
		}
		unfound = 0;
		pid_local = p->pid;
		safestrcpy(state_local, states[p->state], 16);
		safestrcpy(name_local, p->name, 16);
		release(&p->lock);
		break;
	}
 
	if (!unfound) {
		printf("%d,%s,%s\n", pid_local, state_local, name_local);
		return 0;
	}
	return 1;
}

#include "kernel/types.h"
#include "kernel/fcntl.h"
#include "user/user.h"
 
void 
print_ps_header()
{
    printf("pid,state,name\n");
}
 
int
main(int argc, char *argv[])
{
    print_ps_header();
    if (argc == 1) {
        ps(0);
        exit(0);
    }
    for (int i = 1; i < argc; i++) {
        ps(atoi(argv[i]));
    }
    exit(0);
}
 

// sysproc.c
uint64
sys_ps(void)
{
  int pid;
  argint(0, &pid);
  return ps(pid);
}

//in syscall.c
static uint64
argraw(int n)
{
  struct proc *p = myproc();
  switch (n) {
  case 0:
    return p->trapframe->a0;
  case 1:
    return p->trapframe->a1;
  case 2:
    return p->trapframe->a2;
  case 3:
    return p->trapframe->a3;
  case 4:
    return p->trapframe->a4;
  case 5:
    return p->trapframe->a5;
  }
  panic("argraw");
  return -1;
}
 
// Fetch the nth 32-bit system call argument.
void
argint(int n, int *ip)
{
  *ip = argraw(n);
}

// in syscall.c
extern uint64 sys_ps(void); //전역으로 정의된 sys_ps (in sysproc.c) 가져오기
 
static uint64 (*syscalls[])(void) = {
	[SYS_fork]    sys_fork,
	[SYS_exit]    sys_exit,
	[SYS_wait]    sys_wait,
	[SYS_pipe]    sys_pipe,
	[SYS_read]    sys_read,
	[SYS_kill]    sys_kill,
	[SYS_exec]    sys_exec,
	[SYS_fstat]   sys_fstat,
	[SYS_chdir]   sys_chdir,
	[SYS_dup]     sys_dup,
	[SYS_getpid]  sys_getpid,
	[SYS_sbrk]    sys_sbrk,
	[SYS_pause]   sys_pause,
	[SYS_uptime]  sys_uptime,
	[SYS_open]    sys_open,
	[SYS_write]   sys_write,
	[SYS_mknod]   sys_mknod,
	[SYS_unlink]  sys_unlink,
	[SYS_link]    sys_link,
	[SYS_mkdir]   sys_mkdir,
	[SYS_close]   sys_close,
	[SYS_ps]      sys_ps,
};
void
syscall(void)
{
  int num;
  struct proc *p = myproc();
 
  num = p->trapframe->a7;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    p->trapframe->a0 = syscalls[num]();
  } else {
    printf("%d %s: unknown sys call %d\n",
            p->pid, p->name, num);
    p->trapframe->a0 = -1;
  }
}
 

// in syscall.h
// System call numbers
#define SYS_fork    1
#define SYS_exit    2
#define SYS_wait    3
#define SYS_pipe    4
#define SYS_read    5
#define SYS_kill    6
#define SYS_exec    7
#define SYS_fstat   8
#define SYS_chdir   9
#define SYS_dup    10
#define SYS_getpid 11
#define SYS_sbrk   12
#define SYS_pause  13
#define SYS_uptime 14
#define SYS_open   15
#define SYS_write  16
#define SYS_mknod  17
#define SYS_unlink 18
#define SYS_link   19
#define SYS_mkdir  20
#define SYS_close  21
#define SYS_ps     22

// in usys.pl
sub entry {
    my $prefix = "sys_";
    my $name = shift;
    if ($name eq "sbrk") {
	print ".global $prefix$name\n";
	print "$prefix$name:\n";
    } else {
	print ".global $name\n";
	print "$name:\n";
    }
    print " li a7, SYS_${name}\n";
    print " ecall\n";
    print " ret\n";
}
 
// ...
entry("ps")

ps:
  li a7, SYS_ps   // syscall 번호
  ecall           // kernel 진입
  ret             // 결과 반환

uservec:
		csrw sscratch, a0
        li a0, TRAPFRAME
 
        # save the user registers in TRAPFRAME
        sd ra, 40(a0)
        ...
        sd t6, 280(a0)
 
		# save the user 00 in p->trapframe->a0
        csrr t0, sscratch
        sd t0, 112(a0)
 
        # initialize kernel stack pointer, from p->trapframe->kernel_sp
        ld sp, 8(a0)
 
        # make tp hold the current hartid, from p->trapframe->kernel_hartid
        ld tp, 32(a0)
 
        # load the address of usertrap(), from p->trapframe->kernel_trap
        ld t0, 16(a0)
 
        # fetch the kernel page table address, from p->trapframe->kernel_satp.
        ld t1, 0(a0)
 
        # wait for any previous memory operations to complete, so that
        # they use the user page table.
        sfence.vma zero, zero
 
        # install the kernel page table.
        csrw satp, t1
        sfence.vma zero, zero
 
        # call usertrap()
        jalr t0
 

uint64
usertrap(void)
{
  int which_dev = 0;
 
  if((r_sstatus() & SSTATUS_SPP) != 0)
    panic("usertrap: not from user mode");
 
  w_stvec((uint64)kernelvec);  //DOC: kernelvec
 
  struct proc *p = myproc();
  p->trapframe->epc = r_sepc();
 
  if(r_scause() == 8){
    // system call
 
    if(killed(p))
      kexit(-1);
 
    p->trapframe->epc += 4;
 
    intr_on();
 
    syscall();
  } else if((which_dev = devintr()) != 0){
    // ok
  } else if((r_scause() == 15 || r_scause() == 13) &&
            vmfault(p->pagetable, r_stval(), (r_scause() == 13)? 1 : 0) != 0) {
    // page fault on lazily-allocated page
  } else {
    printf("usertrap(): unexpected scause 0x%lx pid=%d\n", r_scause(), p->pid);
    printf("            sepc=0x%lx stval=0x%lx\n", r_sepc(), r_stval());
    setkilled(p);
  }
 
  if(killed(p))
    kexit(-1);
 
  // give up the CPU if this is a timer interrupt.
  if(which_dev == 2)
    yield();
 
  prepare_return();
 
  // the user page table to switch to, for trampoline.S
  uint64 satp = MAKE_SATP(p->pagetable);
 
  // return to trampoline.S; satp value in a0.
  return satp;
}

void
prepare_return(void)
{
  struct proc *p = myproc();
  intr_off();
 
  uint64 trampoline_uservec = TRAMPOLINE + (uservec - trampoline);
  w_stvec(trampoline_uservec);
 
  p->trapframe->kernel_satp = r_satp();         // kernel page table
  p->trapframe->kernel_sp = p->kstack + PGSIZE; // process's kernel stack
  p->trapframe->kernel_trap = (uint64)usertrap;
  p->trapframe->kernel_hartid = r_tp();         // hartid for cpuid()
 
  unsigned long x = r_sstatus();
  x &= ~SSTATUS_SPP; // clear SPP to 0 for user mode
  x |= SSTATUS_SPIE; // enable interrupts in user mode
  w_sstatus(x);
 
  w_sepc(p->trapframe->epc);
}

- 넘겨준 memory block은 해당 프로세스의 [VA; Virtual Address](/knowledge/sw/os/_data/va-virtual-address) 기준이므로 

// Return the current struct proc *, or zero if none.
struct proc*
myproc(void)
{
	push_off();
	struct cpu *c = mycpu();
	struct proc *p = c->proc;
	pop_off();
	return p;
}

#define NAME_LEN 16
#define STATE_LEN 16
 
struct psInfo {
	int pid;
	char name[NAME_LEN];
	char state[STATE_LEN];
};

int
ps(int pid)
{
	static char *states[] = {
		[UNUSED] "unused",
		[USED] "used",
		[SLEEPING] "sleep",
		[RUNNABLE] "runble",
		[RUNNING] "run",
		[ZOMBIE] "zombie"
	};
 
	struct proc *p;
	int unfound = 1;
 
	uint64 bp; // for getting buffer pointer 
	argaddr(0, &bp); // 체크할 필요없음. copyout/in 때 수행함.
 
	struct psInfo kps;
 
	for(p = proc; p < &proc[NPROC]; p++) {
		acquire(&p->lock);
		if (p->pid != pid) {
			release(&p->lock);
			continue;
		}
		unfound = 0;
		kps.pid = pid;
		safestrcpy(kps.state, states[p->state], STATE_LEN);
		safestrcpy(kps.name, p->name, 16);
		release(&p->lock);
		break;
	}
 
	if (unfound || copyout(myproc()->pagetable, bp, (char*)&kps, sizeof(kps)) == -1) {
		return 1;
	}
 
	return 0;
}