크래프톤 정글 WEEK11 DAY 87 - PintOS Project3 - Memory Mapped Files (mmap)

📆2024. 04.02

 

Memory Mapped Files는 파일을 기반으로 매핑하는 페이지를 구현하는 것이다.

 

파일과 메모리 매핑은 System Call인 mmap()을 통해 이루어진다.

Pintos에서는 vm/file.c의 do_mmap()을 이용해서 매핑을 수행하는데, 그 이전에 mmap()에 전달된 인자들에 대한 검증이 먼저 이루어져야 한다.

 

시스템 콜 mmap()

1. offset의 값이 PGSIZE에 알맞게 align되어 있지 않은 경우

2. addr이 NULL이거나, addr이 page-aligned되지 않았거나 kernel 영역인 경우

3. 매핑하려는 페이지가 이미 존재하는 페이지와 겹칠 때 (=spt에 존재하는 페이지일 때)

4. 찾는 파일이 디스크에 없는 경우

5. fd로 열린 파일의 길이가 0바이트인 경우, length가 0인 경우

6. 콘솔 입출력과 연관된 파일 디스크립터 값인 경우

 

매핑이 이루어질 수 없다. 

위의 경우를 제외하고, do_mmap()을 호출해서 파일과 가상 주소 간의 매핑을 진행하고, 매핑된 가상 주소를 반환한다.

void *mmap (void *addr, size_t length, int writable, int fd, off_t offset){

	//offset의 값이 PGSIZE에 알맞게 aling되어 있지 않은 경우
	if(offset % PGSIZE != 0)
		return NULL;

	//addr이 NULL이거나, addr이 page-aligned되지 않았거나 kernel 영역인 경우 
	if(addr == NULL || addr == 0 || addr != pg_round_down(addr) || !is_user_vaddr(addr || !is_user_vaddr(addr + length)))
		return NULL;

	// 매핑하려는 페이지가 이미 존재하는 페이지와 겹칠 때(==SPT에 존재하는 페이지일 때)
	if(spt_find_page(&thread_current()->spt, addr))
		return NULL;

	//찾는 파일이 디스크에 없는 경우
	struct file *target = get_file_from_fd(fd);
	if(target == NULL)	
		return NULL;
	
	//fd로 열린 파일의 길이가 0바이트인 경우, length가 0일 때도 실패
	if( file_length(target) == 0 || (long long)length <= 0)
		return NULL;
	
	//콘솔 입출력과 연관된 파일 디스크립터 값인 경우
	if(fd == 0 || fd == 1)	
		return NULL;

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

 

do_mmap()

 

file-backed page도 anonymous page와 마찬가지로 lazy loading을 이용한다.

page가 초기화될 때 파일에서 내용을 읽어올 수 있도록 lazy_load_segment와 로딩할 때 필요한 데이터를 페이지에 저장해두어야 한다.

 

파일에 대한 독립적인 참조

유닉스 규칙에 따라 매핑은 매핑을 해제하는 munmap이 호출되거나 프로세스가 종료될 때까지 유효하다.( 파일을 닫거나 제거해도 매핑은 해제되지 않는다.)

 

동일한 파일에 대해 여러 프로세스에 의해 여러 개의 매핑이 존재한다고 생각해보자. 이때 한 프로세스에서 이 파일을 닫거나 제거하면 다른 프로세스에서도 이 매핑된 영역에 대한 참조가 유효하지 않게 되어버린다. 또한, 한 매핑에서 파일의 내용을 변경하면 다른 매핑에도 영향을 주게 된다.

 

그래서 file_reopen 함수를 사용하면 이 파일에 대한 새로운 fd를 얻게 되어 다른 매핑에 영향을 주거나 영향을 받지 않는 독립적인 매핑을 가질 수 있게 된다.

void *
do_mmap (void *addr, size_t length, int writable,
		struct file *file, off_t offset) {
	
	struct file *re_file = file_reopen(file);
	void *start_addr = addr; // 매핑 성공 시 파일이 매핑된 가상 주소 반환하는 데 사용

	size_t read_bytes = file_length(re_file) < length ? file_length(re_file) : length;
	size_t zero_bytes = PGSIZE - read_bytes % PGSIZE;

	ASSERT((read_bytes + zero_bytes) % PGSIZE == 0);
	ASSERT(pg_ofs(addr) == 0);	  // upage가 페이지 정렬되어 있는지 확인
	ASSERT(offset % PGSIZE == 0); // ofs가 페이지 정렬되어 있는지 확인

	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;

		struct lazy_load_arg *lazy_load_arg = (struct lazy_load_arg *)malloc(sizeof(struct lazy_load_arg));
		lazy_load_arg->file = re_file;
		lazy_load_arg->ofs = offset;
		lazy_load_arg->read_bytes = page_read_bytes;
		lazy_load_arg->zero_bytes = page_zero_bytes;

		// vm_alloc_page_with_initializer를 호출하여 대기 중인 객체를 생성합니다.
		if (!vm_alloc_page_with_initializer(VM_FILE, addr,
											writable, lazy_load_segment, lazy_load_arg))
			return NULL;

		read_bytes -= page_read_bytes;
		zero_bytes -= page_zero_bytes;
		addr += PGSIZE;
		offset += page_read_bytes;
	}

	return start_addr;
}

 

 

🚫에러 났던 점

struct file *re_file = file_reopen(file);
			:
lazy_load_arg->file = re_file;
			:

 

file_reopen(file)을 통해 새로 얻은 fd를 lazy_load_arg의 file로 넘겼어야 했는데 인자로 받아들인 file을 넘겼어서 자꾸 do_mmap()에서 끝나지 않는 에러가 났었다. 

꼭꼭!! 새로 얻은 fd인 re_file을 인자로 저장하기를 바란다!!

 

 

이 이후로 do_munmap()이 안되는 문제가 계속해서 발생했다. 애를 쓰다가 그 이유에 대해 알게 되었다.

 

1. file_page 구조체 문제

struct file_page {
	// struct file *file;
	// off_t ofs;
	// uint32_t read_bytes;
	// uint32_t zero_bytes;
	void* aux;
};

 

주석 처리된 것과 마찬가지로 file_page의 보조 데이터들을 저장해뒀는데 file 구조체 안에 file을 선언해두면 안된다는 동료분이 file_page->aux로 접근해야 한다고 해서 수정했다.

정확한 이유는 아직 잘 모르겠다 ㅜ

 

그래서 관련된 코드에 대해 전부 수정해주었다.

 

file_backed_initalizer()

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;
    file_page->aux = page->uninit.aux;

    // struct lazy_load_arg *lazy_load_arg = (struct lazy_load_arg *)page->uninit.aux;
    // file_page->file = lazy_load_arg->file;
    // file_page->ofs = lazy_load_arg->ofs;
    // file_page->read_bytes = lazy_load_arg->read_bytes;
    // file_page->zero_bytes = lazy_load_arg->zero_bytes;
    return true;

 

file_page 구조체의 포인터를 page->file로 초기화하고, 페이지에 연관된 보조 데이터들을 file_page->aux에 할당한다. 

 

file_backed_destroy

file-backed 페이지는 디스크에 존재하는 파일과 연관된 페이지다. 그래서 만약 해당 페이지의 수정사항이 있을 경우 이를 감지하여 변경사항을 디스크의 파일에 써줘야 한다.

 

1. 해당 페이지가 변경되어 있을 경우 디스크에 존재하는 file에 write 해주고 dirty-bit를 다시 0으로 변경시켜준다.

2. 만약 변경이 되어 있지 않다면 해당 페이지를 pml4에서 삭제 해준다.

static void
file_backed_destroy (struct page *page) {
	struct file_page *file_page UNUSED = &page->file;
	struct lazy_load_arg *file_aux = (struct lazy_load_arg *)file_page->aux;
	struct thread *t = thread_current();

	if(pml4_is_dirty(t->pml4, page->va)){			
		file_write_at(file_aux->file, page->va, file_aux->read_bytes, file_aux->ofs);
		pml4_set_dirty(t->pml4, page->va, 0);
	}
	pml4_clear_page(t->pml4, page->va);
    
      // if (pml4_is_dirty(thread_current()->pml4, page->va))
      // {
      //     file_write_at(file_page->file, page->va, file_page->read_bytes, file_page->ofs);
      //     pml4_set_dirty(thread_current()->pml4, page->va, 0);
      // }
      // pml4_clear_page(thread_current()->pml4, page->va);
}
}

 

 

do_munmap()

연결된 물리프레임과의 연결을 끊어줘야 한다.

우선 주어진 addr을 통해서 spt로부터 page를 하나 찾고, 해당 페이지의 보조 데이터들을 page->file.aux에 할당한 후에  file_backed_destroy()함수를 통해 파일의 수정사항을 반영하고 가상 페이지 목록에서 페이지를 제거하도록 한다.

void
do_munmap (void *addr) {

	while(true){
		struct thread *curr = thread_current();
		struct page *find_page = spt_find_page(&curr->spt, addr);
		
		if (find_page == NULL) {
    		return NULL;
    	}

		struct lazy_load_arg* container = (struct lazy_load_arg*)find_page->uninit.aux;
		find_page->file.aux = container;

		file_backed_destroy(find_page);
		addr += PGSIZE;
	}
}

 

 

supplemental_page_table_copy()

자식 프로세스가 부모 프로세스의 실행 컨텍스트를 상속하는 과정에서 spt를 복사할 때, file_backed_page는 자식 페이지가 부모의 프레임과 매핑되도록 분기를 추가한다.

bool supplemental_page_table_copy(struct supplemental_page_table *dst UNUSED,
								  struct supplemental_page_table *src UNUSED)
{

	struct hash_iterator i;
	hash_first(&i, &src->hash_table);

	while (hash_next(&i))
	{
		struct page *src_page = hash_entry(hash_cur(&i), struct page, hash_elem);

		enum vm_type vm_type = src_page->operations->type;
		void *va = src_page->va;
		bool writable = src_page->writable;

		/* 1) type이 uninit이면 */
		if (vm_type == VM_UNINIT)
		{ // uninit page 생성 & 초기화
			vm_initializer *init = src_page->uninit.init;
			void *aux = src_page->uninit.aux;
			vm_alloc_page_with_initializer(VM_ANON, va, writable, init, aux);
			continue;
		}

		// if(vm_type == VM_FILE)
		// {
		// 	//파일 로딩에 필요한 정보 저장
		// 	struct lazy_load_arg *file_aux =(struct lazy_load_arg *)malloc(sizeof(struct lazy_load_arg));
		// 	file_aux->file = src_page->file.file;
		// 	file_aux->ofs = src_page->file.ofs;
		// 	file_aux->read_bytes = src_page->file.read_bytes;
		// 	file_aux->zero_bytes = src_page->file.zero_bytes;

		// 	//file_aux 구조체를 인자로 전달하여 VM_FILE page 생성 & 초기화
	 	// 	if(!vm_alloc_page_with_initializer(vm_type, va, writable, NULL, file_aux))
		// 		return false;

		// 	//생성된 페이지 가져온다.
		// 	struct page *file_page = spt_find_page(dst, va);
		// 	//파일에서 데이터를 읽어와 페이지를 채운다.
		// 	file_backed_initializer(file_page, vm_type, va);

		// 	//생성된 페이지의 프레임을 원본 페이지의 프레임으로 설정한다.
		// 	file_page->frame = src_page->frame;

		// 	//페이지 테이블에 페이지 매핑
		// 	pml4_set_page(thread_current()->pml4, file_page->va, src_page->frame->kva, src_page->writable);
		// 	continue;
		// }
		else{

			/* 2) type이 uninit이 아니면 */
			if (!vm_alloc_page(vm_type, va, writable)) // uninit page 생성 & 초기화
				// init이랑 aux는 Lazy Loading에 필요함
				// 지금 만드는 페이지는 기다리지 않고 바로 내용을 넣어줄 것이므로 필요 없음
				return false;

			// vm_claim_page으로 요청해서 매핑 & 페이지 타입에 맞게 초기화
			if (!vm_claim_page(va))
				return false;

			// 매핑된 프레임에 내용 로딩
			struct page *dst_page = spt_find_page(dst, va);
			memcpy(dst_page->frame->kva, src_page->frame->kva, PGSIZE);
		}
		
	}
	return true;
}