MIT6.828操作系统工程Lab3-User Environments实验报告

struct Env *       envs   = NULL;    // All environments
struct Env *       curenv = NULL;    // The current env
static struct Env *env_free_list;    // Free environment list

struct Env {
	struct Trapframe env_tf;	// Saved registers
	struct Env *env_link;		// Next free Env
	envid_t env_id;			// Unique environment identifier
	envid_t env_parent_id;		// env_id of this env's parent
	enum EnvType env_type;		// Indicates special system environments
	unsigned env_status;		// Status of the environment
	uint32_t env_runs;		// Number of times environment has run

	// Address space
	pde_t *env_pgdir;		// Kernel virtual address of page dir
};

//////////////////////////////////////////////////////////////////////
// Make 'envs' point to an array of size 'NENV' of 'struct Env'.
// LAB 3: Your code here.
// get size of envs
uint32_t envs_size = sizeof(struct Env) * NENV;
// use boot_alloc to allocate memory
envs = (struct Env *)boot_alloc(envs_size);
// initialization
memset(envs, 0, envs_size);

//////////////////////////////////////////////////////////////////////
// Map the 'envs' array read-only by the user at linear address UENVS
// (ie. perm = PTE_U | PTE_P).
// Permissions:
//    - the new image at UENVS  -- kernel R, user R
//    - envs itself -- kernel RW, user NONE
// LAB 3: Your code here.
boot_map_region(kern_pgdir, UENVS, envs_size, PADDR(envs), PTE_U | PTE_P);

// In env_init():
// LAB 3: Your code here.
ssize_t i;
// loop in reverse order to keep ascending order in env free list
for (i = NENV - 1; i >= 0; i--) {
    // set env_status, env_id
    envs[i].env_status = ENV_FREE;
    envs[i].env_id     = 0;
    // set env_link and insert into env_free_list
    envs[i].env_link = env_free_list;
    env_free_list    = &envs[i];
}

// In env_setup_vm():
// LAB 3: Your code here.
// set env_pgdir and generate page directory based on kern_pgdir
e->env_pgdir = (pde_t *)page2kva(p);
memcpy(e->env_pgdir, kern_pgdir, PGSIZE);
// increase pp_ref
p->pp_ref++;

// In region_alloc():
// LAB 3: Your code here.
// (But only if you need it for load_icode.)
//
// Hint: It is easier to use region_alloc if the caller can pass
//   'va' and 'len' values that are not page-aligned.
//   You should round va down, and round (va + len) up.
//   (Watch out for corner-cases!)

// round va and va + len
uintptr_t start = (uintptr_t)ROUNDDOWN(va, PGSIZE);
uintptr_t end   = (uintptr_t)ROUNDUP(va + len, PGSIZE);

for (; start < end; start += PGSIZE) {
    // alloc page
    struct PageInfo *p;
    p = page_alloc(ALLOC_ZERO);
    if (!p) { panic("out of memory when allocating region!"); }
    // insert page into environment's page directory
    if (page_insert(e->env_pgdir, p, (char *)start, PTE_W | PTE_U | PTE_P) <
        0) {
        panic("out of memory when allocating region!");
    }
}

// In load_icode():
// LAB 3: Your code here.
// switch address space for loading program segments
lcr3(PADDR(e->env_pgdir));

struct Elf *elf = (struct Elf *)binary;
// check elf magic
if (elf->e_magic != ELF_MAGIC) { panic("invalid elf format!"); }

// set the program entry for env
e->env_tf.tf_eip = elf->e_entry;

struct Proghdr *ph, *eph;

// get the start and end of program header entry
ph  = (struct Proghdr *)(binary + elf->e_phoff);
eph = ph + elf->e_phnum;
for (; ph < eph; ph++) {
    if (ph->p_type == ELF_PROG_LOAD) {    // if the segment is to be loaded
        // alloc corresponding region(clear zero)
        region_alloc(e, (char *)ph->p_va, ph->p_memsz);
        // copy from ELF header to virtual addresses directly
        memcpy((char *)ph->p_va, (char *)binary + ph->p_offset, ph->p_filesz);
    }
}
// switch back
lcr3(PADDR(kern_pgdir));

// Now map one page for the program's initial stack
// at virtual address USTACKTOP - PGSIZE.
// LAB 3: Your code here.
// allocate a page and insert it into env's page directory
// panic when page_alloc or page_insert failed
struct PageInfo *stack_page = page_alloc(ALLOC_ZERO);
if (!stack_page) { panic("out of memory when alloc program's stack!"); }
if (page_insert(e->env_pgdir, stack_page, (char *)(USTACKTOP - PGSIZE),
                PTE_W | PTE_U | PTE_P) < 0) {
    panic("failed to set program's stack!");
}

// In env_create():
// LAB 3: Your code here.
struct Env *env;
// allocate new env with parent ID 0
if (env_alloc(&env, 0) < 0) { panic("failed to allocate env!"); }
// load elf binary and set env_type
load_icode(env, binary);
env->env_type = type;

// In env_run():
// LAB 3: Your code here.
if (curenv != NULL) {    // context switch
    if (curenv->env_status == ENV_RUNNING) {
        // change to runnable if current status is running
        // for not runnable, is not necessary to do this
        curenv->env_status = ENV_RUNNABLE;
    }
}

// set new curenv, update status and counter
curenv        = e;
e->env_status = ENV_RUNNING;
e->env_runs++;
// address space switch
// reference from inc/x86.h
lcr3(PADDR(e->env_pgdir));
// drop into user mode
env_pop_tf(&(e->env_tf));

// panic("env_run not yet implemented");

// In trapentry.S:
/*
 * Lab 3: Your code here for generating entry points for the different traps.
 */

TRAPHANDLER_NOEC(divide_error_handler, T_DIVIDE)
TRAPHANDLER_NOEC(debug_exception_handler, T_DEBUG)
TRAPHANDLER_NOEC(non_maskable_interrupt_handler, T_NMI)
TRAPHANDLER_NOEC(breakpoint_handler, T_BRKPT)
TRAPHANDLER_NOEC(overflow_handler, T_OFLOW)
TRAPHANDLER_NOEC(bounds_check_handler, T_BOUND)
TRAPHANDLER_NOEC(invalid_opcode_handler, T_ILLOP)
TRAPHANDLER_NOEC(device_not_available_handler, T_DEVICE)
TRAPHANDLER(double_fault_handler, T_DBLFLT)
TRAPHANDLER(invalid_tss_handler, T_TSS)
TRAPHANDLER(segment_not_present_handler, T_SEGNP)
TRAPHANDLER(stack_exception_handler, T_STACK)
TRAPHANDLER(general_protection_fault_handler, T_GPFLT)
TRAPHANDLER(pagefault_handler, T_PGFLT)
TRAPHANDLER_NOEC(floating_point_error_handler, T_FPERR)
TRAPHANDLER(alignment_check_handler, T_ALIGN)
TRAPHANDLER_NOEC(machine_check_handler, T_MCHK)
TRAPHANDLER_NOEC(simd_floating_point_error_handler, T_SIMDERR)

/*
 * Lab 3: Your code here for _alltraps
 */

_alltraps:
// push ds and es and general registers
push %ds
push %es
pushal

// load ds and es with GD_KD, for kernel stack locates in data
mov $GD_KD, %ax
mov %ax, %ds
mov %ax, %es

// pass tf as an argument
pushl %esp

// call trap and no need to return
call trap

// In trap.c, trap_init():

// LAB 3: Your code here.
// declare of exception handler
void divide_error_handler();
void debug_exception_handler();
void non_maskable_interrupt_handler();
void breakpoint_handler();
void overflow_handler();
void bounds_check_handler();
void invalid_opcode_handler();
void device_not_available_handler();
void double_fault_handler();
void invalid_tss_handler();
void segment_not_present_handler();
void stack_exception_handler();
void general_protection_fault_handler();
void pagefault_handler();
void floating_point_error_handler();
void alignment_check_handler();
void machine_check_handler();
void simd_floating_point_error_handler();

// set up trap gate descriptor
SETGATE(idt[T_DIVIDE],	 1, GD_KT, divide_error_handler,           	   0);
SETGATE(idt[T_DEBUG],    1, GD_KT, debug_exception_handler,            0);
SETGATE(idt[T_NMI],      1, GD_KT, non_maskable_interrupt_handler,     0);
SETGATE(idt[T_BRKPT],    1, GD_KT, breakpoint_handler,                 3);
SETGATE(idt[T_OFLOW],    1, GD_KT, overflow_handler,                   0);
SETGATE(idt[T_BOUND],    1, GD_KT, bounds_check_handler,               0);
SETGATE(idt[T_ILLOP],    1, GD_KT, invalid_opcode_handler,             0);
SETGATE(idt[T_DEVICE],   1, GD_KT, device_not_available_handler,       0);
SETGATE(idt[T_DBLFLT],   1, GD_KT, double_fault_handler,               0);
SETGATE(idt[T_TSS],      1, GD_KT, invalid_tss_handler,                0);
SETGATE(idt[T_SEGNP],    1, GD_KT, segment_not_present_handler,        0);
SETGATE(idt[T_STACK],    1, GD_KT, stack_exception_handler,            0);
SETGATE(idt[T_GPFLT],    1, GD_KT, general_protection_fault_handler,   0);
SETGATE(idt[T_PGFLT],    1, GD_KT, pagefault_handler,                  0);
SETGATE(idt[T_FPERR],    1, GD_KT, floating_point_error_handler,       0);
SETGATE(idt[T_ALIGN],    1, GD_KT, alignment_check_handler,            0);
SETGATE(idt[T_MCHK],     1, GD_KT, machine_check_handler,              0);
SETGATE(idt[T_SIMDERR],  1, GD_KT, simd_floating_point_error_handler,  0);

// In trap_dispatch():
if (tf->tf_trapno == T_PGFLT) {
    // dispatch page fault exceptions
    page_fault_handler(tf);
}

if (tf->tf_trapno == T_BRKPT) {
    // dispatch breakpoint exceptions
    monitor(tf);
}

// In trapentry.S:
TRAPHANDLER_NOEC(syscall_handler, T_SYSCALL)

// In trap.c, trap_init():
void syscall_handler();

SETGATE(idt[T_SYSCALL], 1, GD_KT, syscall_handler, 3);

// In kern/syscall.c, syscall():
// LAB 3: Your code here.

// panic("syscall not implemented");

switch (syscallno) {
    case SYS_cputs:
        // call sys_cputs
        sys_cputs((const char *)a1, (size_t)a2);
        break;
    case SYS_cgetc:
        // cll sys_cgetc
        return sys_cgetc();
        break;
    case SYS_getenvid:
        // call sys_getenvid
        return sys_getenvid();
        break;
    case SYS_env_destroy:
        // call sys_env_destroy
        return sys_env_destroy((envid_t)a1);
        break;
    default: return -E_INVAL;
}

// will not reach here
return -E_UNSPECIFIED;

// In libmain.c, libmain():
// LAB 3: Your code here.
// get env id use system call and use ENVX to get index
thisenv = envs + ENVX(sys_getenvid());

// In kern/trap.c, page_fault_handler():
// LAB 3: Your code here.
if ((tf->tf_cs & 3) == 0) {
    // code that causes page fault in kernel mode
    panic("page fault in kernel!");
}

// In kern/pmap.c, user_mem_check():
int user_mem_check(struct Env *env, const void *va, size_t len, int perm) {
    // LAB 3: Your code here.
    if ((uintptr_t)va >= ULIM) {
        // condition 1 - below ULIM violated
        user_mem_check_addr = (uintptr_t)va;
        return -E_FAULT;
    }

    uintptr_t va_start = (uintptr_t)ROUNDDOWN(va, PGSIZE);
    uintptr_t va_end   = (uintptr_t)ROUNDUP(va + len, PGSIZE);

    for (; va_start < va_end; va_start += PGSIZE) {
        // note we set page directory entry with less restrict
        // we will only test page table entry here
        pte_t *pgtable_entry_ptr =
            pgdir_walk(env->env_pgdir, (char *)va_start, false);
        if ((*pgtable_entry_ptr & (perm | PTE_P)) != (perm | PTE_P)) {
            // condition 2 - permission violated
            if (va_start <= (uintptr_t)va) {
                // va lie in the first page and not aligned, return va
                user_mem_check_addr = (uintptr_t)va;
            } else if (va_start >= (uintptr_t)va + len) {
                // va lie in the last page and exceed va + len, return va + len
                user_mem_check_addr = (uintptr_t)va + len;
            } else {
                // return corresponding page's initial address
                user_mem_check_addr = va_start;
            }

            return -E_FAULT;
        }
    }

    // pass user memory check
    return 0;
}

// In kern/syscall.c, syscall():
case SYS_cputs:
    // checks memory before use sys_cputs to dereference a1
    user_mem_assert(curenv, (char *)a1, (size_t)a2, PTE_U);
    // call sys_cputs
    sys_cputs((const char *)a1, (size_t)a2);
    break;

// In kern/kdebug.c, debuginfo_eip():
// Make sure this memory is valid.
// Return -1 if it is not.  Hint: Call user_mem_check.
// LAB 3: Your code here.
if (user_mem_check(curenv, usd, sizeof(struct UserStabData), PTE_U) < 0) {
    return -1;
}

// Make sure the STABS and string table memory is valid.
// LAB 3: Your code here.
if ((user_mem_check(curenv, stabs, stab_end - stabs, PTE_U) < 0) ||
    (user_mem_check(curenv, stabstr, stabstr_end - stabstr, PTE_U) < 0)) {
    return -1;
}