BUAA_OS lab4难点梳理

#ifndef UNISTD_H
#define UNISTD_H

#define __SYSCALL_BASE 9527
#define __NR_SYSCALLS 20


#define SYS_putchar         ((__SYSCALL_BASE ) + (0 ) ) 
#define SYS_getenvid        ((__SYSCALL_BASE ) + (1 ) )
#define SYS_yield           ((__SYSCALL_BASE ) + (2 ) )
#define SYS_env_destroy     ((__SYSCALL_BASE ) + (3 ) )
#define SYS_set_pgfault_handler ((__SYSCALL_BASE ) + (4 ) )
#define SYS_mem_alloc       ((__SYSCALL_BASE ) + (5 ) )
#define SYS_mem_map         ((__SYSCALL_BASE ) + (6 ) )
#define SYS_mem_unmap       ((__SYSCALL_BASE ) + (7 ) )
#define SYS_env_alloc       ((__SYSCALL_BASE ) + (8 ) )
#define SYS_set_env_status  ((__SYSCALL_BASE ) + (9 ) )
#define SYS_set_trapframe       ((__SYSCALL_BASE ) + (10 ) )
#define SYS_panic           ((__SYSCALL_BASE ) + (11 ) )
#define SYS_ipc_can_send        ((__SYSCALL_BASE ) + (12 ) )
#define SYS_ipc_recv        ((__SYSCALL_BASE ) + (13 ) )
#define SYS_cgetc           ((__SYSCALL_BASE ) + (14 ) )
#endif

/* Overview:
 *  Allocate a page of memory and map it at 'va' with permission
 * 'perm' in the address space of 'envid'.
 *
 *  If a page is already mapped at 'va', that page is unmapped as a
 * side-effect.
 *
 * Pre-Condition:
 * perm -- PTE_V is required,
 *         PTE_COW is not allowed(return -E_INVAL),
 *         other bits are optional.
 *
 * Post-Condition:
 * Return 0 on success, < 0 on error
 *  - va must be < UTOP
 *  - env may modify its own address space or the address space of its children
 */
/*** exercise 4.3 ***/
int sys_mem_alloc(int sysno, u_int envid, u_int va, u_int perm)
{
    // Your code here.
    struct Env *env;
    struct Page *ppage;
    int ret;
    ret = 0;
    //check the address
    if (va >= UTOP) {
        return -E_INVAL;
    }
    //check the perm
    if ((perm & PTE_COW) || !(perm & PTE_V)) {//big bug!
        return -E_INVAL;
    }
    if (ret = page_alloc(&ppage)) {
        return ret;
    }
    if (ret = envid2env(envid, &env, 1)) {
     	return ret;   
    }//checkperm is 1
    if (ret = page_insert(env->env_pgdir, ppage, va, perm)) {
        return ret;
    }
    return 0;
}

/* Overview:
 *  Map the page of memory at 'srcva' in srcid's address space
 * at 'dstva' in dstid's address space with permission 'perm'.
 * Perm has the same restrictions as in sys_mem_alloc.
 * (Probably we should add a restriction that you can't go from
 * non-writable to writable?)
 *
 * Post-Condition:
 *  Return 0 on success, < 0 on error.
 *
 * Note:
 *  Cannot access pages above UTOP.
 */
/*** exercise 4.4 ***/
int sys_mem_map(int sysno, u_int srcid, u_int srcva, u_int dstid, u_int dstva,
                u_int perm)
{
    int ret;
    u_int round_srcva, round_dstva;
    struct Env *srcenv;
    struct Env *dstenv;
    struct Page *ppage;
    Pte *ppte;
    ppage = NULL;
    ret = 0;
    if (ret = envid2env(srcid, &srcenv, 0)) {
     	return ret;   
    }//checkperm is 0
    if (ret = envid2env(dstid, &dstenv, 0)) {
     	return ret;   
    }//checkperm is 0
    
    round_srcva = ROUNDDOWN(srcva, BY2PG);
    round_dstva = ROUNDDOWN(dstva, BY2PG);
	//check the perm
    if (!(perm & PTE_V)) {
        return -E_INVAL;
    }
    //check the address
    if (round_srcva >= UTOP || round_dstva >= UTOP) {
        return -E_INVAL;
    }
    //your code here
	ppage = page_lookup(srcenv->env_pgdir, round_srcva, &ppte);
    if (ppage == 0) {
        return -1;
    }
    if (!((*ppte) & PTE_R) && (perm & PTE_R)) {
        return -E_INVAL;//from non-writable to writable?
    }
    if (ret = page_insert(dstenv->env_pgdir, ppage, round_dstva, perm)) {
        return ret;
    }
    return ret;
}

/* Overview:
 *  Unmap the page of memory at 'va' in the address space of 'envid'
 * (if no page is mapped, the function silently succeeds)
 *
 * Post-Condition:
 *  Return 0 on success, < 0 on error.
 *
 * Cannot unmap pages above UTOP.
 */
/*** exercise 4.5 ***/
int sys_mem_unmap(int sysno, u_int envid, u_int va)
{
    // Your code here.
    int ret;
    struct Env *env;
	//check the address
    if (va >= UTOP) {
        return -1;
    }
    if (ret = envid2env(envid, &env, 0)) {
     	return ret;   
    }//checkperm is 0
    page_remove(env->env_pgdir, va);
    return 0;
    //  panic("sys_mem_unmap not implemented");
}

/* Overview:
 *  This function enables the current process to give up CPU.
 *
 * Post-Condition:
 *  Deschedule current environment. This function will never return.
 */
/*** exercise 4.6 ***/
void sys_yield(void)
{
    bcopy((void *)KERNEL_SP - sizeof(struct Trapframe),
              (void *)TIMESTACK - sizeof(struct Trapframe),
              sizeof(struct Trapframe));
    sched_yield();
}

/* Overview:
 *  This function enables caller to receive message from
 * other process. To be more specific, it will flag
 * the current process so that other process could send
 * message to it.
 *
 * Pre-Condition:
 *  `dstva` is valid (Note: NULL is also a valid value for `dstva`).
 *
 * Post-Condition:
 *  This syscall will set the current process's status to
 * ENV_NOT_RUNNABLE, giving up cpu.
 */
/*** exercise 4.7 ***/
void sys_ipc_recv(int sysno, u_int dstva)
{
    if (dstva >= UTOP) {//big bug
        return;
    }
    curenv->env_ipc_recving = 1;
    curenv->env_ipc_dstva = dstva;
    curenv->env_status = ENV_NOT_RUNNABLE;
    sys_yield();
}

/* Overview:
 *  Try to send 'value' to the target env 'envid'.
 *
 *  The send fails with a return value of -E_IPC_NOT_RECV if the
 * target has not requested IPC with sys_ipc_recv.
 *  Otherwise, the send succeeds, and the target's ipc fields are
 * updated as follows:
 *    env_ipc_recving is set to 0 to block future sends
 *    env_ipc_from is set to the sending envid
 *    env_ipc_value is set to the 'value' parameter
 *  The target environment is marked runnable again.
 *
 * Post-Condition:
 *  Return 0 on success, < 0 on error.
 *
 * Hint: the only function you need to call is envid2env.
 */
/*** exercise 4.7 ***/
int sys_ipc_can_send(int sysno, u_int envid, u_int value, u_int srcva,
                     u_int perm)
{

    int r;
    struct Env *e;
    struct Page *p;
    if (srcva >= UTOP) {
        return -E_IPC_NOT_RECV;
    }
	if (r = envid2env(envid, &e, 0)) {
        return r;
    }
    if (!e->env_ipc_recving) {
        return -E_IPC_NOT_RECV;
    } 
    e->env_ipc_recving = 0;
    e->env_ipc_from = curenv->env_id;
    e->env_ipc_value = value;
    e->env_status = ENV_RUNNABLE;
	e->env_ipc_perm = perm;
   	if (srcva) {
        p = page_lookup(curenv->env_pgdir, srcva, NULL);
        if (p == 0) {
            return -1;
        }
        if (r = page_insert(e->env_pgdir, p, e->env_ipc_dstva, perm)) {
            return r;
        }
    }
    return 0;
}

u_int mkenvid(struct Env *e) {
    u_int idx = e - envs;
    u_int asid = asid_alloc();//从0到63中选一个作为asid
    return (asid << (1 + LOG2NENV)) | (1 << LOG2NENV) | idx;
}

#include <stdio.h>
#include <unistd.h>

int main() {
	int var = 1;
	long pid;
	printf("Before fork, var = %d.\n", var);
	pid = fork();
	printf("After fork, var = %d.\n", var);
	if (pid == 0) {
		var = 2;
		sleep(3);
		printf("child got %ld, var = %d", pid, var);
	} else {
		sleep(2);
		printf("parent got %ld, var = %d", pid, var);
	}
	printf(", pid: %ld\n", (long) getpid());
	return 0;
}

/* Overview:
 *  Allocate a new environment.
 *
 * Pre-Condition:
 * The new child is left as env_alloc created it, except that
 * status is set to ENV_NOT_RUNNABLE and the register set is copied
 * from the current environment.
 *
 * Post-Condition:
 *  In the child, the register set is tweaked so sys_env_alloc returns 0.
 *  Returns envid of new environment, or < 0 on error.
 */
/*** exercise 4.8 ***/
int sys_env_alloc(void)
{
    // Your code here.
    int r;
    struct Env *e;
	if ((r = env_alloc(&e, curenv->env_id))) {
        return r;
    }
    e->env_status = ENV_NOT_RUNNABLE;
	bcopy((void *)(KERNEL_SP - sizeof(struct Trapframe)), (void *)(&(e->env_tf)), sizeof(struct Trapframe));
    //系统调用，当前进程上下文保存在KERNEL_SP中
    e -> env_tf.pc = e -> env_tf.cp0_epc;
    e->env_pri = curenv->env_pri;
    e->env_tf.regs[2] = 0;//return 0;
    return e->env_id;
    //  panic("sys_env_alloc not implemented");
}

e -> env_tf.pc = e -> env_tf.cp0_epc;

// user/libos.c
void
libmain(int argc, char **argv)
{
    // set env to point at our env structure in envs[].
    env = 0;    // Your code here.
    //writef("xxxxxxxxx %x  %x  xxxxxxxxx\n",argc,(int)argv);
    int envid;
    envid = syscall_getenvid();
    envid = ENVX(envid);
    env = &envs[envid];
    // call user main routine
    umain(argc, argv);
    // exit gracefully
    exit();
    //syscall_env_destroy(0);
}

//get a new envid
newenvid = //? how ?
env = envs + ENVX(newenvid);

/* Overview:
 *  User-level fork. Create a child and then copy our address space
 * and page fault handler setup to the child.
 *
 * Hint: use vpd, vpt, and duppage.
 * Hint: remember to fix "env" in the child process!
 * Note: `set_pgfault_handler`(user/pgfault.c) is different from
 *       `syscall_set_pgfault_handler`.
 */
/*** exercise 4.9 4.15***/
extern void __asm_pgfault_handler(void);
int
fork(void)
{
    // Your code here.
    u_int newenvid;
    extern struct Env *envs;
    extern struct Env *env;
    u_int i;


    //The parent installs pgfault using set_pgfault_handler

    //alloc a new alloc
	newenvid = syscall_env_alloc();
    if (newenvid == 0) {
        env = envs + ENVX(syscall_getenvid());
        return 0;
    }

    return newenvid;
}

vpt[0] = *vpt = UVPT = 0x7fc00000， vpd[0] = *vpd = 0x7fdff000

e->env_pgdir[PDX(UVPT)]  = e->env_cr3 | PTE_V;//read-only

extern volatile Pte* vpt[];//指针数组
extern volatile Pde* vpd[];

e->env_pgdir[PDX(UVPT)] = e->env_cr3 | PTE_V;//read-only

for (i = 0; i < VPN(USATCKTOP); i++) {
    if (((*vpd)[ i >> 10] & PTE_V) && ((*vpt)[i] & PTE_V)) {
         duppage(newenvid, i);
    }
}

/* Overview:
 *  Map our virtual page `pn` (address pn*BY2PG) into the target `envid`
 * at the same virtual address.
 *
 * Post-Condition:
 *  if the page is writable or copy-on-write, the new mapping must be
 * created copy on write and then our mapping must be marked
 * copy on write as well. In another word, both of the new mapping and
 * our mapping should be copy-on-write if the page is writable or
 * copy-on-write.
 *
 * Hint:
 *  PTE_LIBRARY indicates that the page is shared between processes.
 * A page with PTE_LIBRARY may have PTE_R at the same time. You
 * should process it correctly.
 */
/*** exercise 4.10 ***/
static void
duppage(u_int envid, u_int pn)
{
    u_int addr;
    u_int perm;
	
    addr = pn * BY2PG;
    perm = (*vpt)[pn] & 0xfff;//低12位权限位
    int flag = 0;
    if (!(perm & PTE_LIBRARY) && (perm & PTE_R)) {
    	perm = perm | PTE_COW;
        //syscall_mem_map(0, addr, 0, addr, perm);
		flag = 1;
    }
    syscall_mem_map(0, addr, envid, addr, perm);
    if (flag) 
        syscall_mem_map(0, addr, 0, addr, perm);//父在子后防止COW
    //  user_panic("duppage not implemented");
}

void
page_fault_handler(struct Trapframe *tf)
{
    struct Trapframe PgTrapFrame;
    extern struct Env *curenv;

    bcopy(tf, &PgTrapFrame, sizeof(struct Trapframe));

    if (tf->regs[29] >= (curenv->env_xstacktop - BY2PG) &&
        tf->regs[29] <= (curenv->env_xstacktop - 1)) {
            tf->regs[29] = tf->regs[29] - sizeof(struct  Trapframe);
            bcopy(&PgTrapFrame, (void *)tf->regs[29], sizeof(struct Trapframe));
        } else {
            tf->regs[29] = curenv->env_xstacktop - sizeof(struct  Trapframe);
            bcopy(&PgTrapFrame,(void *)curenv->env_xstacktop - sizeof(struct  Trapframe),sizeof(struct Trapframe));
        }
    // TODO: Set EPC to a proper value in the trapframe
	tf -> cp0_epc = curenv -> env_pgfault_handler;
    return;
}

if (tf->regs[29] >= (curenv->env_xstacktop - BY2PG) &&
        tf->regs[29] <= (curenv->env_xstacktop - 1)) {
            tf->regs[29] = tf->regs[29] - sizeof(struct  Trapframe);
            bcopy(&PgTrapFrame, (void *)tf->regs[29], sizeof(struct Trapframe));
        }

/* Overview:
 *  Set envid's pagefault handler entry point and exception stack.
 *
 * Pre-Condition:
     *  xstacktop points one byte past exception stack.
 *
 * Post-Condition:
 *  The envid's pagefault handler will be set to `func` and its
 *  exception stack will be set to `xstacktop`.
 *  Returns 0 on success, < 0 on error.
 */
/*** exercise 4.12 ***/
int sys_set_pgfault_handler(int sysno, u_int envid, u_int func, u_int xstacktop)
{
    // Your code here.
    struct Env *env;
    int ret;
    if ((ret = envid2env(envid, &env, 0))) {
        return ret;
    }
    env -> env_pgfault_handler = func;//设置了env_pgfault_handle
    env -> env_xstacktop = xstacktop;//设置了异常处理栈

    return 0;
    //  panic("sys_set_pgfault_handler not implemented");
}

//
// Set the page fault handler function.
// If there isn't one yet, _pgfault_handler will be 0.
// The first time we register a handler, we need to
// allocate an exception stack and tell the kernel to
// call _asm_pgfault_handler on it.
//
void
set_pgfault_handler(void (*fn)(u_int va))
{
    if (__pgfault_handler == 0) {
        // Your code here:
        // map one page of exception stack with top at UXSTACKTOP
        // register assembly handler and stack with operating system
        if (syscall_mem_alloc(0, UXSTACKTOP - BY2PG, PTE_V | PTE_R) < 0 ||
            syscall_set_pgfault_handler(0, __asm_pgfault_handler, UXSTACKTOP) < 0) {
            writef("cannot set pgfault handler\n");
            return;
        }

        //      panic("set_pgfault_handler not implemented");
    }

    // Save handler pointer for assembly to call.
    __pgfault_handler = fn;
}

/* Overview:
 *  Custom page fault handler - if faulting page is copy-on-write,
 * map in our own private writable copy.
 *
 * Pre-Condition:
 *  `va` is the address which leads to a TLBS exception.
 *
 * Post-Condition:
 *  Launch a user_panic if `va` is not a copy-on-write page.
 * Otherwise, this handler should map a private writable copy of
 * the faulting page at correct address.
 */
/*** exercise 4.13 ***/
static void
pgfault(u_int va)
{
    u_int *tmp;
    va = ROUNDDOWN(va, BY2PG);
    tmp = (u_int *)USTACKTOP;
    //  writef("fork.c:pgfault():\t va:%x\n",va);
    u_int perm = (*vpt)[VPN(va)] & 0xfff;
	if (!(perm & PTE_COW)) {
        user_panic("no PTE_COW exists!");
        return;
    }
    //map the new page at a temporary place
	if (syscall_mem_alloc(0 ,tmp, PTE_V|PTE_R)) {
        user_panic("can't sys_mem_alloc!")
        return;
    }
    //copy the content
	user_bcopy((void *)va, (void *)tmp, BY2PG);
    //map the page on the appropriate place
	if (syscall_mem_map(0, tmp, 0, va, PTE_V|PTE_R)) {
        user_panic("map fails!");
        return;
    }
    //unmap the temporary place
	if (syscall_mem_unmap(0 ,tmp)) {
        user_panic("ummap fails!");
        return;
    }
}

/* Overview:
 *  Set envid's env_status to status.
 *
 * Pre-Condition:
 *  status should be one of `ENV_RUNNABLE`, `ENV_NOT_RUNNABLE` and
 * `ENV_FREE`. Otherwise return -E_INVAL.
 *
 * Post-Condition:
 *  Returns 0 on success, < 0 on error.
 *  Return -E_INVAL if status is not a valid status for an environment.
 *  The status of environment will be set to `status` on success.
 */
/*** exercise 4.14 ***/
int sys_set_env_status(int sysno, u_int envid, u_int status)
{
    // Your code here.
    struct Env *env;
    int ret;
	if((ret = envid2env(envid, &env, 0))) {
        return ret;
    }
    if (status > 2 || status < 0) {
        return -E_INVAL;
    }
    env->env_status = status;
    if (env->env_status == ENV_RUNNABLE) {
        LIST_INSERT_HEAD(env_sched_list, env, env_sched_link);
    }
    return 0;
    //  panic("sys_env_set_status not implemented");
}

extern void __asm_pgfault_handler(void);
int
fork(void)
{
    // Your code here.
    u_int newenvid;
    extern struct Env *envs;
    extern struct Env *env;
    u_int i;


    //The parent installs pgfault using set_pgfault_handler
    set_pgfault_handler(pgfault);//
    //alloc a new alloc
    newenvid = syscall_env_alloc();

    if (newenvid == 0) {
        env = envs + ENVX(syscall_getenvid());
        return 0;
    }

    for (i = 0; i < VPN(USTACKTOP); i++) {
        if (((*vpd)[ i >> 10] & PTE_V) && ((*vpt)[i] & PTE_V)) {
            duppage(newenvid, i);
        }
    }

    if (syscall_mem_alloc(newenvid, UXSTACKTOP - BY2PG, PTE_V | PTE_R)) {//父进程需要为子进程的异常处理栈映射物理页面。
        return -1;
    }
        
    if (syscall_set_pgfault_handler(newenvid, __asm_pgfault_handler, UXSTACKTOP)) {
        return -1;
    }
    syscall_set_env_status(newenvid, ENV_RUNNABLE);
    return newenvid;
}

//user/libos.c
void exit(void)
{
    syscall_env_destroy(0);
}

struct Env *env;

void libmain(int argc, char **argv)
{
    // set env to point at our env structure in envs[].
    env = 0;    // Your code here.
    //writef("xxxxxxxxx %x  %x  xxxxxxxxx\n",argc,(int)argv);
    int envid;
    envid = syscall_getenvid();
    envid = ENVX(envid);
    env = &envs[envid];
    // call user main routine
    umain(argc, argv);//用户程序开始执行，在本lab里它是一个测试函数
    // exit gracefully
    exit();
}