[Pintos-KAIST] Project 3 : Memory Mapped Files (+ page-merge FAIL 해결하기)

유선·2024년 5월 21일

pintos 정글 10주차 정글 11주차

Pintos - KAIST

목록 보기

14/16

👩🏻‍💻 GITHUB 레포지토리
👩🏻‍💻 GITHUB Memory Mapped Files 이슈

과제 설명

Anonymous Memory가 아닌 File-Backed memory = Memory Mapped Page에 대해 구현해야한다.

File backed page에 있는 내용물들은 모두 디스크에서 존재하고 있는 파일을 복사한 것이다. 만약 페이지 폴트가 일어나면 바로 물리 프레임이 할당되고 물리 프레임에 파일의 데이터가 복사된다.

디스크에 있는 파일에 대한 유저 가상 페이지를 미리 가상 주소 공간에 할당해주는 것을 mmap이라 하고, 페이지와 물리 메모리가 연결된 경우 그 연결을 끊어주는 것을 munmap이라 한다.

만약 file backed page가 memory unmapped되거나 swap out 되면, 해당 메모리에 변화가 생긴 경우(dirty bit) 그 변화를 파일에 업데이트하고 memory unmapped되거나 swap out되어야 한다.

mmap() 시스템 콜에 의해 매핑된 가상 메모리는 스택과 힙 사이의 미할당 공간(스택도 아니고 힙도 아닌)에 매핑된다.

구현

1. mmap, do_mmap 구현

1-1. mmap 선언하기

include/userprog/syscall.h

/** Project 3-Memory Mapped Files */
#include "include/filesys/off_t.h";
#include "stddef.h";
void *mmap(void *addr, size_t length, int writable, int fd, off_t offset);
void munmap(void *addr);

1-2. syscall에 mmap 추가

userprog/syscall.c

/** Project 3-Memory Mapped FIles */
#ifdef VM
        case SYS_MMAP:
            f->R.rax = mmap(f->R.rdi, f->R.rsi, f->R.rdx, f->R.r10, f->R.r8);
            break;
#endif

/** Project 3-Memory Mapped FIles */
#ifdef VM
void 
*mmap(void *addr, size_t length, int writable, int fd, off_t offset) {
    if (!addr || pg_round_down(addr) != addr || is_kernel_vaddr(addr) || is_kernel_vaddr(addr + length))
        return NULL;

    if (offset != pg_round_down(offset) || offset % PGSIZE != 0)
        return NULL;

    if (spt_find_page(&thread_current()->spt, addr))
        return NULL;

    struct file *file = process_get_file(fd);

    if ((file >= STDIN && file <= STDERR) || file == NULL)
        return NULL;

    if (file_length(file) == 0 || (long)length <= 0)
        return NULL;

    return do_mmap(addr, length, writable, file, offset);
}

#endif

1-3. filesys_lock 추가

include/userprog/syscall.h

/** Project 3-Memory Mapped Files */
#include "include/filesys/off_t.h";
#include "stddef.h";
void *mmap(void *addr, size_t length, int writable, int fd, off_t offset);
void munmap(void *addr);
extern struct lock filesys_lock;

1-4. do_mmap 구현

vm/file.c

/** Project 3-Memory Mapped FIles */
#include "threads/vaddr.h"
#include "userprog/syscall.c"
.
.
.
void *
do_mmap (void *addr, size_t length, int writable,
		struct file *file, off_t offset) {
			
	/** Project 3-Memory Mapped FIles */
	lock_acquire(&filesys_lock);
    struct file *mfile = file_reopen(file);
    void *ori_addr = addr;
    size_t read_bytes = (length > file_length(mfile)) ? file_length(mfile) : length;
    size_t zero_bytes = PGSIZE - read_bytes % PGSIZE;

    ASSERT((read_bytes + zero_bytes) % PGSIZE == 0);
    ASSERT(pg_ofs(addr) == 0);
    ASSERT(offset % PGSIZE == 0);

    struct vm_load_arg *aux;
    while (read_bytes > 0 || zero_bytes > 0) {
        size_t page_read_bytes = read_bytes < PGSIZE ? read_bytes : PGSIZE;
        size_t page_zero_bytes = PGSIZE - page_read_bytes;

        aux = (struct vm_load_arg *)malloc(sizeof(struct vm_load_arg));
        if (!aux)
            goto err;

        aux->file = mfile;
        aux->ofs = offset;
        aux->read_bytes = page_read_bytes;

        if (!vm_alloc_page_with_initializer(VM_FILE, addr, writable, lazy_load_segment, aux)) {
            goto err;
        }

        read_bytes -= page_read_bytes;
        zero_bytes -= page_zero_bytes;
        addr += PGSIZE;
        offset += page_read_bytes;
    }
	lock_release(&filesys_lock);
    return ori_addr;

err:
    free(aux);
    lock_release(&filesys_lock);
    return NULL;
}

2. munmap, do_munmap 구현

2-1. munmap 선언하기

include/userprog/syscall.h

/** Project 3-Memory Mapped Files */
#include "include/filesys/off_t.h";
#include "stddef.h";
void *mmap(void *addr, size_t length, int writable, int fd, off_t offset);
void munmap(void *addr);

2-2. syscall에 munmap 추가

userprog/syscall.c

/** Project 3-Memory Mapped FIles */
#ifdef VM
        case SYS_MMAP:
            f->R.rax = mmap(f->R.rdi, f->R.rsi, f->R.rdx, f->R.r10, f->R.r8);
            break;
        case SYS_MUNMAP:
            munmap(f->R.rdi);
            break;
#endif

/** Project 3-Memory Mapped Files */
void munmap(void *addr) {
    do_munmap(addr);
}

2-3. lazy_load_segment 불러오기

include/userprog/process.h

/** #Project 3: Memory Mapped Files */
bool lazy_load_segment(struct page *page, void *aux);

userprog/process.c
static 삭제하기
BEFORE

static bool
lazy_load_segment (struct page *page, void *aux) {
	/** Project 3-Anonymous Page */
    struct vm_load_arg *aux_p = aux;
    .
    .
    .

AFTER

bool
lazy_load_segment (struct page *page, void *aux) {
	/** Project 3-Anonymous Page */
    struct vm_load_arg *aux_p = aux;
    .
    .
    .

vm/file.c

/** Project 3-Memory Mapped FIles */
#include "threads/mmu.h"
#include "threads/vaddr.h"
#include "userprog/process.h"
#include "userprog/syscall.h"

2-4. do_munmap() 구현

vm/file.c

void
do_munmap (void *addr) {
	/** Project 3-Memory Mapped FIles */
    struct thread *curr = thread_current();
    struct page *page;

    lock_acquire(&filesys_lock);
    while ((page = spt_find_page(&curr->spt, addr))) {
        if (page)
            destroy(page);

        addr += PGSIZE;
    }
    lock_release(&filesys_lock);
}

3. file_backed_initializer() 구현

vm/file.c

bool
file_backed_initializer (struct page *page, enum vm_type type, void *kva) {
	/* Set up the handler */
	page->operations = &file_ops;

	struct file_page *file_page = &page->file;

	/** Project 3-Memory Mapped Files */
    struct vm_load_arg *aux = (struct vm_load_arg *)page->uninit.aux;
    file_page->file = aux->file;
    file_page->offset = aux->ofs;
    file_page->page_read_bytes = aux->read_bytes;

    return true;
}

4. file_backed_destroy() 구현

vm/file.c

static void
file_backed_destroy (struct page *page) {
	struct file_page *file_page UNUSED = &page->file;

	/** Project 3-Memory Mapped Files */
    if (pml4_is_dirty(thread_current()->pml4, page->va)) {
        file_write_at(file_page->file, page->va, file_page->page_read_bytes, file_page->offset);
        pml4_set_dirty(thread_current()->pml4, page->va, false);
    }

    if (page->frame) {
        list_remove(&page->frame->frame_elem);
        page->frame->page = NULL;
        page->frame = NULL;
        free(page->frame);
    }

    pml4_clear_page(thread_current()->pml4, page->va);
}

5. spt_remove_page() 수정

vm/vm.c

void
spt_remove_page (struct supplemental_page_table *spt, struct page *page) {
	/** Project 3-Memory Mapped Files */
	hash_delete(&thread_current()->spt.spt_hash, &page->hash_elem);
	vm_dealloc_page (page);
	return true;
}

6. supplemental_page_table_copy() 수정

vm/vm.c
TYPE 관련 조건 추가

bool
supplemental_page_table_copy (struct supplemental_page_table *dst UNUSED,
		struct supplemental_page_table *src UNUSED) {
	
	/** Project 3-Memory Mapped Files */
 	struct hash_iterator iter;
    hash_first(&iter, &src->spt_hash);
    while (hash_next(&iter)) {
        struct page *src_page = hash_entry(hash_cur(&iter), struct page, hash_elem);
        enum vm_type type = src_page->operations->type;
        void *upage = src_page->va;
        bool writable = src_page->writable;

        if (type == VM_UNINIT) {
            void *aux = src_page->uninit.aux;
            vm_alloc_page_with_initializer(page_get_type(src_page), upage, writable, src_page->uninit.init, aux);
        }

        else if (type == VM_FILE) {
            struct vm_load_arg *aux = malloc(sizeof(struct vm_load_arg));
            aux->file = src_page->file.file;
            aux->ofs = src_page->file.offset;
            aux->read_bytes = src_page->file.page_read_bytes;

            if (!vm_alloc_page_with_initializer(type, upage, writable, NULL, aux))
                return false;

            struct page *dst_page = spt_find_page(dst, upage);
            file_backed_initializer(dst_page, type, NULL);
            dst_page->frame = src_page->frame;
            pml4_set_page(thread_current()->pml4, dst_page->va, src_page->frame->kva, src_page->writable);
        }

        else {                                          
            if (!vm_alloc_page(type, upage, writable)) 
                return false;

            if (!vm_claim_page(upage))  
                return false;

            struct page *dst_page = spt_find_page(dst, upage); 
            memcpy(dst_page->frame->kva, src_page->frame->kva, PGSIZE);
        }
    }

    return true;
}

7. page_fault 조건 수정

userprog/exception.c
BEFORE

	if ((!not_present && write) || (fault_addr < 0x400000 ))
	{
		exit(-1);
	}

AFTER

	if ((!not_present && write) || (fault_addr < 0x400000 ))
	{
		exit(-1);
	}

여기까지의 테스트 결과

pass tests/userprog/args-none
pass tests/userprog/args-single
pass tests/userprog/args-multiple
pass tests/userprog/args-many
pass tests/userprog/args-dbl-space
pass tests/userprog/halt
pass tests/userprog/exit
pass tests/userprog/create-normal
pass tests/userprog/create-empty
pass tests/userprog/create-null
pass tests/userprog/create-bad-ptr
pass tests/userprog/create-long
pass tests/userprog/create-exists
pass tests/userprog/create-bound
pass tests/userprog/open-normal
pass tests/userprog/open-missing
pass tests/userprog/open-boundary
pass tests/userprog/open-empty
pass tests/userprog/open-null
pass tests/userprog/open-bad-ptr
pass tests/userprog/open-twice
pass tests/userprog/close-normal
pass tests/userprog/close-twice
pass tests/userprog/close-bad-fd
pass tests/userprog/read-normal
pass tests/userprog/read-bad-ptr
pass tests/userprog/read-boundary
pass tests/userprog/read-zero
pass tests/userprog/read-stdout
pass tests/userprog/read-bad-fd
pass tests/userprog/write-normal
pass tests/userprog/write-bad-ptr
pass tests/userprog/write-boundary
pass tests/userprog/write-zero
pass tests/userprog/write-stdin
pass tests/userprog/write-bad-fd
pass tests/userprog/fork-once
pass tests/userprog/fork-multiple
pass tests/userprog/fork-recursive
pass tests/userprog/fork-read
pass tests/userprog/fork-close
pass tests/userprog/fork-boundary
pass tests/userprog/exec-once
pass tests/userprog/exec-arg
pass tests/userprog/exec-boundary
pass tests/userprog/exec-missing
pass tests/userprog/exec-bad-ptr
pass tests/userprog/exec-read
pass tests/userprog/wait-simple
pass tests/userprog/wait-twice
pass tests/userprog/wait-killed
pass tests/userprog/wait-bad-pid
pass tests/userprog/multi-recurse
pass tests/userprog/multi-child-fd
pass tests/userprog/rox-simple
pass tests/userprog/rox-child
pass tests/userprog/rox-multichild
pass tests/userprog/bad-read
pass tests/userprog/bad-write
pass tests/userprog/bad-read2
pass tests/userprog/bad-write2
pass tests/userprog/bad-jump
pass tests/userprog/bad-jump2
pass tests/vm/pt-grow-stack
pass tests/vm/pt-grow-bad
pass tests/vm/pt-big-stk-obj
pass tests/vm/pt-bad-addr
pass tests/vm/pt-bad-read
pass tests/vm/pt-write-code
pass tests/vm/pt-write-code2
pass tests/vm/pt-grow-stk-sc
pass tests/vm/page-linear
pass tests/vm/page-parallel
pass tests/vm/page-merge-seq
pass tests/vm/page-merge-par
FAIL tests/vm/page-merge-stk
FAIL tests/vm/page-merge-mm
pass tests/vm/page-shuffle
pass tests/vm/mmap-read
pass tests/vm/mmap-close
pass tests/vm/mmap-unmap
pass tests/vm/mmap-overlap
pass tests/vm/mmap-twice
pass tests/vm/mmap-write
pass tests/vm/mmap-ro
pass tests/vm/mmap-exit
pass tests/vm/mmap-shuffle
pass tests/vm/mmap-bad-fd
pass tests/vm/mmap-clean
pass tests/vm/mmap-inherit
pass tests/vm/mmap-misalign
pass tests/vm/mmap-null
pass tests/vm/mmap-over-code
pass tests/vm/mmap-over-data
pass tests/vm/mmap-over-stk
pass tests/vm/mmap-remove
pass tests/vm/mmap-zero
pass tests/vm/mmap-bad-fd2
pass tests/vm/mmap-bad-fd3
pass tests/vm/mmap-zero-len
pass tests/vm/mmap-off
pass tests/vm/mmap-bad-off
pass tests/vm/mmap-kernel
pass tests/vm/lazy-file
pass tests/vm/lazy-anon
FAIL tests/vm/swap-file
FAIL tests/vm/swap-anon
FAIL tests/vm/swap-iter
FAIL tests/vm/swap-fork
pass tests/filesys/base/lg-create
pass tests/filesys/base/lg-full
pass tests/filesys/base/lg-random
pass tests/filesys/base/lg-seq-block
pass tests/filesys/base/lg-seq-random
pass tests/filesys/base/sm-create
pass tests/filesys/base/sm-full
pass tests/filesys/base/sm-random
pass tests/filesys/base/sm-seq-block
pass tests/filesys/base/sm-seq-random
pass tests/filesys/base/syn-read
pass tests/filesys/base/syn-remove
pass tests/filesys/base/syn-write
pass tests/threads/alarm-single
pass tests/threads/alarm-multiple
pass tests/threads/alarm-simultaneous
pass tests/threads/alarm-priority
pass tests/threads/alarm-zero
pass tests/threads/alarm-negative
pass tests/threads/priority-change
pass tests/threads/priority-donate-one
pass tests/threads/priority-donate-multiple
pass tests/threads/priority-donate-multiple2
pass tests/threads/priority-donate-nest
pass tests/threads/priority-donate-sema
pass tests/threads/priority-donate-lower
pass tests/threads/priority-fifo
pass tests/threads/priority-preempt
pass tests/threads/priority-sema
pass tests/threads/priority-condvar
pass tests/threads/priority-donate-chain
FAIL tests/vm/cow/cow-simple
7 of 141 tests failed.

tests/vm/page-merge-seq
tests/vm/page-merge-par
tests/vm/page-merge-stk
tests/vm/page-merge-mm

😹 page-merge 관련 테스트들이 전부 통과하지 못한다. 이유가 뭘까...

open이 실패했다고 뜬다...
팀원에게 물어보니 속도가 빠른거라고 한다..(?)
그리고 fdt를 linked_list로 구현한 팀은 이 문제가 발생하지 않는다.
팀원 말로는 linked_list가 검색 속도가 느려서 속도 문제가 발생하지 않는다고 한다.

해결하자!!!!!!!!!

page-merge FAIL 해결하기

1. lock을 추가하자!

1-1. syscall lock

userprog/syscall.c
create, remove, open에 lock을 추가해줬다.

bool 
create(const char *file, unsigned initial_size) 
{
    check_address(file);

    lock_acquire(&filesys_lock);
    bool success = filesys_create(file, initial_size);
    lock_release(&filesys_lock);

    return success;
}

bool 
remove(const char *file) 
{
    check_address(file);

    lock_acquire(&filesys_lock);
    bool success = filesys_remove(file);
    lock_release(&filesys_lock);

    return success;
}

int 
open(const char *file) 
{
    check_address(file);

    lock_acquire(&filesys_lock);
    struct file *newfile = filesys_open(file);

    if (newfile == NULL)
        goto err;

    int fd = process_add_file(newfile);

    if (fd == -1)
        file_close(newfile);

    lock_release(&filesys_lock);
    return fd;
err:
    lock_release(&filesys_lock);
    return -1;
}

1-2. load lock

userprog/process.c
lock 추가를 위해 syscall.h include 하기

/** Project 3-Memory Mapped FIles */
#include "userprog/syscall.h"

load 함수에 lock을 추가한다.

static bool
load (const char *file_name, struct intr_frame *if_) {
	struct thread *t = thread_current();
    struct ELF ehdr;
    struct file *file = NULL;
    off_t file_ofs;
    bool success = false;
    int i;

    /* Allocate and activate page directory. */
    t->pml4 = pml4_create();
    if (t->pml4 == NULL)
        goto done;
    process_activate(thread_current());

    /* Open executable file. */
    lock_acquire(&filesys_lock); /** Project 3-Memory Mapped FIles */
    file = filesys_open(file_name);
    if (file == NULL) {
        printf("load: %s: open failed\n", file_name);
        goto done;
    }

    /** project2-System Call - 파일 실행 명시 및 접근 금지 설정  */
    t->runn_file = file;
    file_deny_write(file); /** Project 2: Denying Writes to Executables */

    /* Read and verify executable header. */
    if (file_read(file, &ehdr, sizeof ehdr) != sizeof ehdr || memcmp(ehdr.e_ident, "\177ELF\2\1\1", 7) || ehdr.e_type != 2 || ehdr.e_machine != 0x3E  // amd64
        || ehdr.e_version != 1 || ehdr.e_phentsize != sizeof(struct Phdr) || ehdr.e_phnum > 1024) {
        printf("load: %s: error loading executable\n", file_name);
        goto done;
    }

    /* Read program headers. */
    file_ofs = ehdr.e_phoff;
    for (i = 0; i < ehdr.e_phnum; i++) {
        struct Phdr phdr;

        if (file_ofs < 0 || file_ofs > file_length(file))
            goto done;
        file_seek(file, file_ofs);

        if (file_read(file, &phdr, sizeof phdr) != sizeof phdr)
            goto done;
        file_ofs += sizeof phdr;
        switch (phdr.p_type) {
            case PT_NULL:
            case PT_NOTE:
            case PT_PHDR:
            case PT_STACK:
            default:
                /* Ignore this segment. */
                break;
            case PT_DYNAMIC:
            case PT_INTERP:
            case PT_SHLIB:
                goto done;
            case PT_LOAD:
                if (validate_segment(&phdr, file)) {
                    bool writable = (phdr.p_flags & PF_W) != 0;
                    uint64_t file_page = phdr.p_offset & ~PGMASK;
                    uint64_t mem_page = phdr.p_vaddr & ~PGMASK;
                    uint64_t page_offset = phdr.p_vaddr & PGMASK;
                    uint32_t read_bytes, zero_bytes;
                    if (phdr.p_filesz > 0) {
                        /* Normal segment.
                         * Read initial part from disk and zero the rest. */
                        read_bytes = page_offset + phdr.p_filesz;
                        zero_bytes = (ROUND_UP(page_offset + phdr.p_memsz, PGSIZE) - read_bytes);
                    } else {
                        /* Entirely zero.
                         * Don't read anything from disk. */
                        read_bytes = 0;
                        zero_bytes = ROUND_UP(page_offset + phdr.p_memsz, PGSIZE);
                    }
                    if (!load_segment(file, file_page, (void *)mem_page, read_bytes, zero_bytes, writable))
                        goto done;
                } else
                    goto done;
                break;
        }
    }

    /* Set up stack. */
    if (!setup_stack(if_))
        goto done;

    /* Start address. */
    if_->rip = ehdr.e_entry;

    success = true;

done:
    /* We arrive here whether the load is successful or not. */
    // file_close(file);
    lock_release(&filesys_lock); /** Project 3-Memory Mapped FIles */
    return success;
}

2. check_valid_buffer()를 구현하자!

include/userprog/syscall.h

void check_valid_buffer(void *buffer, size_t size, bool writable);

userprog/syscall.c

/** Project 3-Memory Mapped Files 버퍼 유효성 검사 */
void check_valid_buffer(void *buffer, size_t size, bool writable) {
    for (size_t i = 0; i < size; i += 8) {
        /* buffer가 spt에 존재하는지 검사 */
        struct page *page = check_address(buffer + i);

        if (!page || (writable && !(page->writable)))
            exit(-1);
    }
}

어떤때에는 ++ 증감으로 해야 통과하고, 어떤때에는 +=8 증감으로 해야 통과가 됐다.
하지만 지금은 +=8로 계속 통과되는 추세...
이유는 모르겠따.. ㅜㅜ
open 문제와 TIMEOUT 문제가 반복된다면 이 증감을 줄이거나 늘려서 해결해보자 ㅜㅜ

read, write에 추가

int 
read(int fd, void *buffer, unsigned length) 
{
#ifdef VM
    check_valid_buffer(buffer, length, true);
#endif
...

}

int 
write(int fd, const void *buffer, unsigned length) 
{
#ifdef VM
    check_valid_buffer(buffer, length, false);
#endif
...
}

여기까지 했는데도 fork에서 오류가 떴었다...
project1에서 구현한 donate_prorty() 문제였다 ㅜㅜ

3. fork 에러 해결

threads/thread.c

if (t == NULL)
		break;

조건을 추가해주자

void 
donate_priority() 
{
    struct thread *t = thread_current();
    int priority = t->priority;

    for (int depth = 0; depth < 8; depth++) 
	{
        if (t->wait_lock == NULL)
            break;
        t = t->wait_lock->holder;
		/** Project 3-Memory Mapped Files */
		if (t == NULL)
			break;
        t->priority = priority;
    }
}

최종 테스트 결과

pass tests/userprog/args-none
pass tests/userprog/args-single
pass tests/userprog/args-multiple
pass tests/userprog/args-many
pass tests/userprog/args-dbl-space
pass tests/userprog/halt
pass tests/userprog/exit
pass tests/userprog/create-normal
pass tests/userprog/create-empty
pass tests/userprog/create-null
pass tests/userprog/create-bad-ptr
pass tests/userprog/create-long
pass tests/userprog/create-exists
pass tests/userprog/create-bound
pass tests/userprog/open-normal
pass tests/userprog/open-missing
pass tests/userprog/open-boundary
pass tests/userprog/open-empty
pass tests/userprog/open-null
pass tests/userprog/open-bad-ptr
pass tests/userprog/open-twice
pass tests/userprog/close-normal
pass tests/userprog/close-twice
pass tests/userprog/close-bad-fd
pass tests/userprog/read-normal
pass tests/userprog/read-bad-ptr
pass tests/userprog/read-boundary
pass tests/userprog/read-zero
pass tests/userprog/read-stdout
pass tests/userprog/read-bad-fd
pass tests/userprog/write-normal
pass tests/userprog/write-bad-ptr
pass tests/userprog/write-boundary
pass tests/userprog/write-zero
pass tests/userprog/write-stdin
pass tests/userprog/write-bad-fd
pass tests/userprog/fork-once
pass tests/userprog/fork-multiple
pass tests/userprog/fork-recursive
pass tests/userprog/fork-read
pass tests/userprog/fork-close
pass tests/userprog/fork-boundary
pass tests/userprog/exec-once
pass tests/userprog/exec-arg
pass tests/userprog/exec-boundary
pass tests/userprog/exec-missing
pass tests/userprog/exec-bad-ptr
pass tests/userprog/exec-read
pass tests/userprog/wait-simple
pass tests/userprog/wait-twice
pass tests/userprog/wait-killed
pass tests/userprog/wait-bad-pid
pass tests/userprog/multi-recurse
pass tests/userprog/multi-child-fd
pass tests/userprog/rox-simple
pass tests/userprog/rox-child
pass tests/userprog/rox-multichild
pass tests/userprog/bad-read
pass tests/userprog/bad-write
pass tests/userprog/bad-read2
pass tests/userprog/bad-write2
pass tests/userprog/bad-jump
pass tests/userprog/bad-jump2
pass tests/vm/pt-grow-stack
pass tests/vm/pt-grow-bad
pass tests/vm/pt-big-stk-obj
pass tests/vm/pt-bad-addr
pass tests/vm/pt-bad-read
pass tests/vm/pt-write-code
pass tests/vm/pt-write-code2
pass tests/vm/pt-grow-stk-sc
pass tests/vm/page-linear
pass tests/vm/page-parallel
pass tests/vm/page-merge-seq
pass tests/vm/page-merge-par
pass tests/vm/page-merge-stk
pass tests/vm/page-merge-mm
pass tests/vm/page-shuffle
pass tests/vm/mmap-read
pass tests/vm/mmap-close
pass tests/vm/mmap-unmap
pass tests/vm/mmap-overlap
pass tests/vm/mmap-twice
pass tests/vm/mmap-write
pass tests/vm/mmap-ro
pass tests/vm/mmap-exit
pass tests/vm/mmap-shuffle
pass tests/vm/mmap-bad-fd
pass tests/vm/mmap-clean
pass tests/vm/mmap-inherit
pass tests/vm/mmap-misalign
pass tests/vm/mmap-null
pass tests/vm/mmap-over-code
pass tests/vm/mmap-over-data
pass tests/vm/mmap-over-stk
pass tests/vm/mmap-remove
pass tests/vm/mmap-zero
pass tests/vm/mmap-bad-fd2
pass tests/vm/mmap-bad-fd3
pass tests/vm/mmap-zero-len
pass tests/vm/mmap-off
pass tests/vm/mmap-bad-off
pass tests/vm/mmap-kernel
pass tests/vm/lazy-file
pass tests/vm/lazy-anon
FAIL tests/vm/swap-file
FAIL tests/vm/swap-anon
FAIL tests/vm/swap-iter
FAIL tests/vm/swap-fork
pass tests/filesys/base/lg-create
pass tests/filesys/base/lg-full
pass tests/filesys/base/lg-random
pass tests/filesys/base/lg-seq-block
pass tests/filesys/base/lg-seq-random
pass tests/filesys/base/sm-create
pass tests/filesys/base/sm-full
pass tests/filesys/base/sm-random
pass tests/filesys/base/sm-seq-block
pass tests/filesys/base/sm-seq-random
pass tests/filesys/base/syn-read
pass tests/filesys/base/syn-remove
pass tests/filesys/base/syn-write
pass tests/threads/alarm-single
pass tests/threads/alarm-multiple
pass tests/threads/alarm-simultaneous
pass tests/threads/alarm-priority
pass tests/threads/alarm-zero
pass tests/threads/alarm-negative
pass tests/threads/priority-change
pass tests/threads/priority-donate-one
pass tests/threads/priority-donate-multiple
pass tests/threads/priority-donate-multiple2
pass tests/threads/priority-donate-nest
pass tests/threads/priority-donate-sema
pass tests/threads/priority-donate-lower
pass tests/threads/priority-fifo
pass tests/threads/priority-preempt
pass tests/threads/priority-sema
pass tests/threads/priority-condvar
pass tests/threads/priority-donate-chain
FAIL tests/vm/cow/cow-simple
5 of 141 tests failed.

swap in/out과 cow test 제외하고 전부 PASS다!!!!😇

유선

Sunny Day!

이전 포스트

[Pintos-KAIST] Project 3 : Stack Growth

다음 포스트