[TIL/06.06]PintOS VM - Anonymous Page

참고 자료

https://casys-kaist.github.io/pintos-kaist/project3/introduction.html
https://oslab.kaist.ac.kr/pintosslides/

• 🚨 두번째 링크인 Kaist OS LAB(EE) 자료는 64비트가 아닌 32비트 기준으로 서술되어 있음

Anonymous Page란?

핀토스안에서 돌아가는 프로세스의 주소 공간을 도식화 하면 위와 같다.
그림을 자세히보면 Disk 영역과 매핑되는 파랑(text), 초록색 영역(Data)이 있고,
Disk 영역과 아무런 관련이 없는 빨강(Stack), 주황(BSS) 영역이 있다.

결론부터 말하자면 Stack, BSS 영역과 매핑된 빨강, 주황색 페이지가 바로 Anonymous Page.
즉 지정된 파일 소스가 없기 때문에 익명이라고 부른다.

스택과 힙 과 같은 실행파일에 사용되며, 필요한 메모리 공간을 동적으로 할당하여 프로그램의 요구사항에 맞게 메모리를 활용할 수 있다.

Lazy Loading과 무슨 관계?

프로젝트 3에서 마주하는 첫번째 장애물은 Lazy Loading이다.
이걸 구현하기 위해 이전에 SPT와 Frame 관리 함수를 구현했다.

Lazy Loading의 목적은 실행파일을 로드할때 불필요한 디스크 접근을 줄이기 위해 구현하는 것.
만약 파일 기반 페이지라면, 물리 프레임 할당 -> 디스크에서 파일 읽기(I/O)
의 작업 순서를,

익명페이지라면, 물리 프레임 할당 -> 해당프레임 0으로 채우기(CPU연산)
디스크 I/O도 없고, 비용이 많이 드는 작업을 실제 사용 되는 순간으로 미룬다.

Ex. BSS Segment

BSS segment는 초기화되지 않은(uninitialized) 전역/정적 변수를 위한 영역이다.
프로글램 시작시 모든 내용이 0이어야 한다.

지연 로딩이 없다면 프로그램 시작시 커널, 물리 프레임을 모두 할당하고 memset을 이용해서 0으로 채워주어야 함.

반면 지연로딩이 있다면,
프로그램 시작시 커널은 메모리에 아무런 작업을 하지 않고,
SPT에 이 VA는 나중에 접근이 일어나면 0으로 채워진 Anonymous Page 가 되어야 한다고 약속만 기록해둠.

Page Fault 처리 + Lazy Loading

1. 페이지 폴트 발생
   1. 프로그램, 아직 실제 내용이 로드 되지 않은 VM_UNINIT 페이지에 접근 ⇒ Page Fault 발생
2. 제어 전달
   1. userprog/exception.c의 page_fault() ⇒ vm/vm.c의 vm_try_handle_fault() 로 제어 이동
3. Fault 유효성 검사
   1. vm_try_handle_fault() ⇒ 이 폴트가 유효한 페이지 fault(지연로딩, 스왑 인)인지 확인
4. 내용 로드
   1. 유효한 fault라면 커널, 해당 페이지에 필요한 내용을 로드, 사용자 프로그램으로 실행 제어를 반환

• 지연 로딩 페이지 Fault 의 처리 과정

  • Page Fault 가 지연 로딩을 위한 것 ⇒ 커널, vm_alloc_page_with_initializer 함수에서 이전에 설정해둔 특정 초기화 함수 호출
    • Lazy Loading하는 작업 수행
    • lazy_load_segment 함수를 구현해야함 ⇒ 특정 세그먼트를 실제로 로딩하는 역할 담당

• Anonymous Page Flow
  

vm_alloc_page_with_initializer 구현

1. 페이지 생성
2. 타입에 따른 초기화 함수 가져오기
3. UNINIT으로 초기화
4. 필드 수정
5. SPT에 페이지를 추가

/* 페이지 구조체를 생성하고 적절한 초기화 함수를 설정*/
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;

	/* 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. */

		/* TODO: Insert the page into the spt. */
		// 1. 페이지 생성
		struct page *p = (struct page *)malloc(sizeof(struct page));
		// 2. 타입에 따른 초기화 함수 가져오기
		bool (*page_initializer)(struct page *, enum vm_type, void *);
		switch (VM_TYPE(type))
		{
		case VM_ANON:
			page_initializer = anon_initializer;
			break;
		case VM_FILE:
			page_initializer = file_backed_initializer;
			break;
		}
		// 3. uninit 타입의 페이지로 초기화
		// uninit_new -> uninit 타입으로 초기화해주는 함수
		uninit_new(p, upage, init, type, aux, page_initializer);

		// 4. 필드 수정
		p->writable = writable;

		// 5. 페이지 spt 추가
		return spt_insert_page(spt, p);
	}
err:
	return false;
}

uninit_initialize 구현

VM_UNINIT 페이지에 첫번째 페이지 폴트 발생시 이 함수가 호출.
페이지를 실제 사용 가능 상태로 바꾸는 역할을 수행한다.

/* Initalize the page on first fault */
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; // lazy_load_segment
	void *aux = uninit->aux;						 // lazy_load_arg

	/* TODO: You may need to fix this function. */
	return uninit->page_initializer(page, uninit->type, kva) &&
				 (init ? init(page, aux) : true);
}

load_segment 함수 구현

• 프로세스가 실행될때 실행파일을 현재 스레드로 로드하는 함수인 Load 함수에서 호출
• 파일의 내용 upage 에 로드하는 함수
• 내용을 로드시 lazy_load_segment를 넘겨주어야 하며, 같이 필요한 정보도 넘겨주어야 함

위 사진에 AUX로 묶어놓은 저 정보를 다 넘겨주면 된다.

static bool
load_segment(struct file *file, off_t ofs, uint8_t *upage,
						 uint32_t read_bytes, uint32_t zero_bytes, bool writable)
{
	ASSERT((read_bytes + zero_bytes) % PGSIZE == 0); // read_bytes + zero_bytes가 페이지 크기(PGSIZE)의 배수인지 확인
	ASSERT(pg_ofs(upage) == 0);											 // upage가 페이지 정렬되어 있는지 확인
	ASSERT(ofs % PGSIZE == 0)												 // ofs가 페이지 정렬되어 있는지 확인;

	while (read_bytes > 0 || zero_bytes > 0) // read_bytes와 zero_bytes가 0보다 큰 동안 루프를 실행
	{
		/* Do calculate how to fill this page.
		 * We will read PAGE_READ_BYTES bytes from FILE
		 * and zero the final PAGE_ZERO_BYTES bytes. */
		size_t page_read_bytes = read_bytes < PGSIZE ? read_bytes : PGSIZE; // 최대로 읽을 수 있는 크기는 PGSIZE
		size_t page_zero_bytes = PGSIZE - page_read_bytes;

		/* TODO: Set up aux to pass information to the lazy_load_segment. */
		// loading을 위해 필요한 정보를 포함하는 구조체를 만들어야 합니다.
		struct lazy_load_arg *lazy_load_arg = (struct lazy_load_arg *)malloc(sizeof(struct lazy_load_arg));
		lazy_load_arg->file = file;									 // 내용이 담긴 파일 객체
		lazy_load_arg->ofs = ofs;										 // 이 페이지에서 읽기 시작할 위치
		lazy_load_arg->read_bytes = page_read_bytes; // 이 페이지에서 읽어야 하는 바이트 수
		lazy_load_arg->zero_bytes = page_zero_bytes; // 이 페이지에서 read_bytes만큼 읽고 공간이 남아 0으로 채워야 하는 바이트 수
		// vm_alloc_page_with_initializer를 호출하여 대기 중인 객체를 생성합니다.
		if (!vm_alloc_page_with_initializer(VM_ANON, upage, writable, lazy_load_segment, lazy_load_arg))
			return false;

		/* Advance. */
		// 다음 반복을 위하여 읽어들인 만큼 값을 갱신합니다.
		read_bytes -= page_read_bytes;
		zero_bytes -= page_zero_bytes;
		upage += PGSIZE;
		ofs += page_read_bytes;
	}
	return true;
}

Lazy_load_segment

• 실행 파일의 내용을 페이지로 로딩하는 함수, 첫번째 페이지 fault가 발생시 호출
• 물리 프레임에 내용을 채우는 작업만 수행하면 끝

bool lazy_load_segment(struct page *page, void *aux)
{
	/* TODO: Load the segment from the file */
	/* TODO: This called when the first page fault occurs on address VA. */
	/* TODO: VA is available when calling this function. */

	struct lazy_load_arg *lazy_load_arg = (struct lazy_load_arg *)aux;

	// 1) 파일의 position을 ofs으로 지정한다.
	file_seek(lazy_load_arg->file, lazy_load_arg->ofs);
	// 2) 파일을 read_bytes만큼 물리 프레임에 읽어 들인다.
	if (file_read(lazy_load_arg->file, page->frame->kva, lazy_load_arg->read_bytes) != (int)(lazy_load_arg->read_bytes))
	{
		palloc_free_page(page->frame->kva);
		return false;
	}
	// 3) 다 읽은 지점부터 zero_bytes만큼 0으로 채운다.
	memset(page->frame->kva + lazy_load_arg->read_bytes, 0, lazy_load_arg->zero_bytes);

	return true;
}

vm_try_handle_fault

마지막으로 페이지 폴드 발생시 핸들러 함수를 수정한다.

/* Return true on success */
bool vm_try_handle_fault(struct intr_frame *f UNUSED, void *addr UNUSED,
												 bool user UNUSED, bool write UNUSED, bool not_present UNUSED)
{
	struct supplemental_page_table *spt UNUSED = &thread_current()->spt;
	struct page *page = NULL;
	if (addr == NULL)
		return false;

	if (is_kernel_vaddr(addr))
		return false;

	if (not_present) // 접근한 메모리의 physical page가 존재하지 않은 경우
	{
		/* TODO: Validate the fault */
		// 페이지 폴트가 스택 확장에 대한 유효한 경우인지를 확인한다.
		void *rsp = f->rsp; // user access인 경우 rsp는 유저 stack을 가리킨다.
		if (!user)					// kernel access인 경우 thread에서 rsp를 가져와야 한다.
			rsp = thread_current()->rsp;

		page = spt_find_page(spt, addr);
		if (page == NULL)
			return false;
		if (write == 1 && page->writable == 0) // write 불가능한 페이지에 write 요청한 경우
			return false;
		return vm_do_claim_page(page);
	}
	return fals