3일이나 걸려 mmap, munmap 구현이 끝났다.
do_mmap
먼저 mmap을 살펴보자.
void *mmap (void *addr, size_t length, int writable, int fd, off_t offset) {
if (is_kernel_vaddr(addr) || addr == NULL)
return NULL;
if (is_kernel_vaddr(addr + length) || (addr + length) == NULL)
return NULL;
if (addr != pg_round_down(addr))
return NULL;
if (length == 0)
return NULL;
if (offset % PGSIZE)
return NULL;
struct file *file = process_get_file(fd);
if (file == NULL)
return NULL;
return do_mmap(addr, length, writable, file, offset);
}예외처리를 잘 해주어야 mmap test case중 예외사항에 관한 test를 통과할 수 있다.
현재 프로세스에서 전달받은 fd를 가지고 file을 찾아 do_mmap에 넘겨준다.
do_mmap은 아래와 같다.
void *do_mmap (void *addr, size_t length, int writable, struct file *f, off_t offset) {
uint64_t va = addr;
struct file *file = file_reopen(f);
int pg_cnt = DIV_ROUND_UP(length, PGSIZE);
size_t file_len = file_length(file);
size_t read_bytes = file_len < length ? file_len : length;
while (true) {
pg_cnt--;
size_t page_read_bytes = read_bytes < PGSIZE ? read_bytes : PGSIZE;
size_t page_zero_bytes = PGSIZE - page_read_bytes;
struct file_segment *file_segment = malloc(sizeof(struct file_segment));
// file_segment->file = malloc(sizeof(struct file));
// memcpy(file_segment->file, file, sizeof(struct file));
file_segment->file = file;
file_segment->page_read_bytes = page_read_bytes;
file_segment->page_zero_bytes = page_zero_bytes;
file_segment->ofs = offset;
if (!vm_alloc_page_with_initializer(VM_FILE, va, writable, lazy_load_segment, file_segment)) {
return NULL;
}
struct page *page = spt_find_page(&thread_current()->spt, va);
page->marker = VM_DUMMY;
if(pg_cnt == 0) {
page->marker = VM_FILE_END;
break;
}
read_bytes -= page_read_bytes;
offset += page_read_bytes;
va += PGSIZE;
}
return addr;
}아직도 length가 정확하게 무엇을 의미하는지는 모르겠으나 실제 file의 길이보다 짧거나 길수도 있다.
최대한 기존의 lazy_load_segment를 변경하지 않기 위해서 고민을 많이 했다.
length가 8KB인 반면에 실제 file의 길이가 PGSIZE보다 작다면 위의 코드에 따르면 pg_cnt = 2로 2개의 page를 만들게 된다. 하지만 이러한 경우 2번째 page는 page_fault가 났을 때 0으로만 채워진다. 즉, 불필요한 page이다.
위와 같은 상황에서 lazy_load_segment의 변경없이 1개의 page만 만드는 방법이 도저히 생각이 나지 않아 일단은 입력받은 length에 따라 만들 page의 갯수를 정하기로 하였다.
file_reopen을 하지 않으면 test case가 통과 되지 않았다.
-> 정확히 모르겠음
기존의 process.c의 load_segment() 함수도 마찬가지인데 항상 file_segment->file도 malloc으로 공간을 할당받아 원래의 file을 memcpy하여 저장해주었는데 직접 file을 넣어줘도 되길래 주석처리를 하였다.
전체적인 do_mmap의 기능은 length를 통해 만들 page의 갯수를 정하고, file을 어디에서부터 얼마나 읽을지에 대한 정보를 file_segment에 담아 vm_alloc_page_with_initializer()를 호출한다. 마지막 page라면 page 구조체의 marker 변수에 VM_FILE_END를 담는다.
vm_alloc_page_with_initializer()를 호출하였을 때를 살펴보자.
bool vm_alloc_page_with_initializer(enum vm_type type, void *upage, bool writable, vm_initializer *init, void *aux) {
ASSERT (VM_TYPE(type) != VM_UNINIT)
struct supplemental_page_table *spt = &thread_current()->spt;
/* Project 3 */
/* Check wheter the upage is already occupied or not. */
if (spt_find_page(spt, upage) == NULL) {
/* TODO: Create the page, fetch the initialier according to the VM type,
* TODO: and then create "uninit" page struct by calling uninit_new. You
* TODO: should modify the field after calling the uninit_new. */
struct page *page = malloc(sizeof(struct page));//palloc_get_page(PAL_ASSERT);
void *new_initializer;
switch (VM_TYPE(type)) {
case VM_ANON:
new_initializer = anon_initializer;
break;
case VM_FILE:
new_initializer = file_backed_initializer;
break;
}
uninit_new(page, upage, init, type, aux, new_initializer);
page->writable = writable;
return spt_insert_page(spt, page);
}
err:
return false;
}
void uninit_new (struct page *page, void *va, vm_initializer *init, enum vm_type type, void *aux,
bool (*initializer)(struct page *, enum vm_type, void *)) {
ASSERT (page != NULL);
*page = (struct page) {
.operations = &uninit_ops,
.va = va,
.frame = NULL, /* no frame for now */
.uninit = (struct uninit_page) {
.init = init,
.type = type,
.aux = aux,
.page_initializer = initializer,
}
};
}type에 따라 initializer가 바뀐다. uninit_new가 호출이 되면 operations에 uninit_ops의 주소가 담기고, uninit_page의 멤버 변수가 초기화 된다.
init에는 lazy_load_segment(), aux에는 file_segment*, initializer에는 타입별 initializer가 담긴다.
처음에는 헷갈렸다. 분명 VM_ANON과 VM_FILE을 type으로 넘겼지만 operations에도 uninit의 것이 담기고, union에서도 uninit page를 선택한다. 근데 또 uninit_page인데 멤버 변수에는 type에 따라 적절한 정보가 담긴다.
page_fault 처리
이러한 상태에서 page를 참조하려 하면 page_fault가 발생한다. page를 참조하려 한다는 것은 page가 물리 메모리와 맵핑이 되어 있어야 한다는 것이다.
순서는 이렇다.
-> page_fault -> vm_try_handle_fault -> vm_do_claim_page -> vm_get_frame
-> pml4_set_page -> swap_in -> operations.swap_in -> uninit_initialize
-> initializer -> lazy_load_segmentbool vm_try_handle_fault (struct intr_frame *f, void *addr, bool user, bool write, bool not_present) {
struct supplemental_page_table *spt = &thread_current()->spt;
struct page *page = NULL;
if (addr == NULL)
return false;
else if (is_kernel_vaddr(addr))
return false;
else if (USER_STACK >= addr && addr >= USER_STACK - (1 << 20)) {
if (f->rsp - 8 != addr)
return false;
vm_stack_growth(addr);
return true;
}
else if (not_present) {
page = spt_find_page(&spt->spt_hash, addr);
if (page == NULL)
return false;
return vm_do_claim_page(page);
}
return false;
}
static bool vm_do_claim_page(struct page *page) {
struct frame *frame = vm_get_frame();
/* Set links */
frame->page = page;
page->frame = frame;
/* Project 3. */
/* TODO: Insert page table entry to map page's VA to frame's PA. */
uint64_t* pml4 = thread_current()->pml4;
// 가상 주소와 물리 주소를 맵핑한 정보를 페이지 테이블에 추가한다.
pml4_set_page(pml4, page->va, frame->kva, page->writable);
// #define swap_in(page, v) (page)->operations->swap_in ((page), v)
return swap_in(page, frame->kva);
}
static bool uninit_initialize (struct page *page, void *kva) {
struct uninit_page *uninit = &page->uninit;
/* Fetch first, page_initialize may overwrite the values */
vm_initializer *init = uninit->init;
void *aux = uninit->aux;
/* TODO: You may need to fix this function. */
return uninit->page_initializer (page, uninit->type, kva) &&
(init ? init (page, aux) : true);
}
bool lazy_load_segment(struct page *page, void *aux) {
struct file_segment *file_segment = (struct file_segment *)aux;
struct file *file = file_segment->file;
size_t page_read_bytes = file_segment->page_read_bytes;
size_t page_zero_bytes = file_segment->page_zero_bytes;
off_t ofs = file_segment->ofs;
void *kpage = page->frame->kva;
if (kpage == NULL)
return false;
file_seek(file, ofs);
if (file_read(file, kpage, page_read_bytes) != (int)page_read_bytes) {
palloc_free_page(kpage);
return false;
}
memset((uint64_t)kpage + page_read_bytes, 0, page_zero_bytes);
return true;
}page를 참조하려는데 page_fault가 났다면 해당 page를 찾아서 물리 메모리에 올려주면 된다.
물리 메모리에 올려주는 작업이 바로 vm_get_frame과 pml4_set_page이다.
vm_get_frame에서는 malloc으로 size만큼 kernel pool에서 메모리를 할당받아온다. 이어서 palloc_get_page로 실질적인 물리 페이지를 user pool에서 할당 받는다.
pml4_set_page에서는 스택 영역의 upage와 커널 영역 user pool의 kpage를 맵핑을 해준다. 해당 함수를 정상적으로 마친다면 어떤 va가 들어왔을 때 va가 포함되는 upage를 찾고 이 upage를 가지고 table을 walk하며 연결되어 있는 kpage를 찾을 수 있다. kpage를 찾으면 va의 하위 12비트(오프셋)을 더하여 실제 읽으려 했던 위치를 찾아간다.
vm_try_handle_fault에서는 사용자 영역에 대해서만 처리를 해주어야 한다.
그러므로 전달받은 주소가 커널 영역이라면 return false로 예외처리를 해주어야한다. 그렇지 않으면 물리메모리에 정보를 변경하거나 입력하려 할 때 무한 page_fault에 갇혀버린다.
swap_in이 호출되고 uninit_initialize를 거치면 type에 따라 initializer가 호출된다.
initializer가 호출되면 union의 uninit_page에서 type_page로 덮어씌운다.
operations도 자기 type걸로 바뀐다.
-> union 공용체의 특성인듯한데 uninit_page에서 type_page로 덮는 순간 uninit_page에 담았었던 정보들은 변질될 가능성이 매우크다.
init 즉, lazy_load_segment 함수를 전달 받았다면 호출하고, 전달 받지 않았다면 true를 반환한다.
lazy_load_segment 함수는 전달 받은 aux 즉, file_segment에 따라 file을 읽어 물리 메모리에 적재한다. 읽으려는 file의 크기가 PGSIZE보다 작다면 남은 공간은 0으로 채운다.
-> Project 2까지는 page를 할당하는 순간 바로 물리 메모리에 올라갔지만, Project 3부터는 처음에는 page를 할당만 하고, 이후에 page_fault가 났을 때 물리 메모리에 올린다. 이 역할을 하는 함수가 lazy_load_segment 함수이다.
do_mummap
이제 mummap을 살펴보자.
void munmap (void *addr) {
do_munmap(addr);
}
void do_munmap (void *addr) {
while (true) {
struct page *page = spt_find_page(&thread_current()->spt, addr);
if (page->marker & VM_FILE_END) {
destroy(page);
break;
}
else {
destroy(page);
}
addr += PGSIZE;
}
}별거 없다. 들어온 주소에 해당하는 page를 찾고 destroy만 호출해주면 된다.
여기서 들어오는 addr은 do_mmap에서 반환한 주소로 같은 file에 대해 맵핑한 page들 중 가장 처음 page의 주소가 들어온다.
종료조건으로는 do_mmap에서 마지막 page의 marker에 넣어줬던 VM_FILE_END를 이용하였다.
destroy를 호출하게 되면 현재 page의 type에 따른 destroy 함수가 실행된다.
static void uninit_destroy (struct page *page) {
struct uninit_page *uninit = &page->uninit;
struct file_segment *file_segment = (struct file_segment *)uninit->aux;
hash_delete(&thread_current()->spt.spt_hash, &page->h_elem);
pml4_clear_page(thread_current()->pml4, page->va);
}
static void file_backed_destroy (struct page *page) {
struct file_page *file_page = &page->file;
if (pml4_is_dirty(thread_current()->pml4, page->va)) {
file_write_at(file_page->file, page->frame->kva, file_page->page_read_bytes, file_page->ofs);
pml4_set_dirty(thread_current()->pml4, page->va, 0);
}
hash_delete(&thread_current()->spt.spt_hash, &page->h_elem);
pml4_clear_page(thread_current()->pml4, page->va);
}
static void anon_destroy (struct page *page) {
struct anon_page *anon_page = &page->anon;
}아마 page를 만들고 참조하지 않아서 page_fault가 한번도 나지 않은 상태에서 destroy를 호출하게 되면 initializer가 호출된 적이 없어서 operations가 uninit의 것이라 uninit_destroy가 호출될 것이다.
page_fault가 나서 initializer가 호출된 적이 있다면 type에 file_backed_destroy 또는 anon_destroy가 호출될 것이다.
이 함수에서는 page talbe의 정보를 지운다. 즉, 물리메모리와의 맵핑을 끊고 현재 프로세스의 spt에서 해당 page를 제거 해준다.
만약 VM_FILE 이었다면 물리메모리의 정보가 변경된 적이 있으면 file에 덮어 씌우고 dirty를 다시 0으로 초기화 해준다.
미해결
- file을 굳이 malloc으로 공간을 할당받고 memcpy로 가져와야 할까
- file_segment, kpage, frame은 도대체 언제 해제 해줘야하는가
- file_reopen이 필요한 이유
- supplemental_page_table_copy에서 VM_FILE의 경우 file_segment를 만들어서 넘겨야 안터지는 이유
bool supplemental_page_table_copy (struct supplemental_page_table *dst, struct supplemental_page_table *src) {
struct hash_iterator i;
hash_first (&i, &src->spt_hash);
while (hash_next (&i)) {
struct page *parent_page = hash_entry(hash_cur(&i), struct page, h_elem);
enum vm_type type = parent_page->operations->type;
switch (VM_TYPE(type)) {
case VM_UNINIT: {
if(!vm_alloc_page_with_initializer(VM_ANON, parent_page->va, parent_page->writable, parent_page->uninit.init, parent_page->uninit.aux)) {
return false;
}
break;
}
case VM_ANON: {
if (!vm_alloc_page(type, parent_page->va, parent_page->writable)) {
return false;
}
if (!vm_claim_page(parent_page->va)) {
return false;
}
struct page *child_page = spt_find_page(dst, parent_page->va);
memcpy (child_page->frame->kva, parent_page->frame->kva, PGSIZE);
break;
}
case VM_FILE: {
struct file_segment *file_segment = malloc(sizeof(struct file_segment));
file_segment->file = parent_page->file.file;
file_segment->page_read_bytes = parent_page->file.page_read_bytes;
file_segment->page_zero_bytes = parent_page->file.page_zero_bytes;
file_segment->ofs = parent_page->file.page_zero_bytes;
if (!vm_alloc_page_with_initializer(type, parent_page->va, parent_page->writable, NULL, file_segment)) {
return false;
}
if (!vm_claim_page(parent_page->va)) {
return false;
}
struct page *child_page = spt_find_page(dst, parent_page->va);
memcpy (child_page->frame->kva, parent_page->frame->kva, PGSIZE);
break;
}
}
}
return true;
}