[PintOS] User Program - System Call2 (Project 2, TIL)

KAIST PintOS 강의 및 Instruction, 한양대 PintOS Slides를 참고하며 학습한 내용을 정리하였습니다.

학습 도중 작성한 내용이라 틀린 내용이 있을 수 있습니다.

---

디버깅

fork() 함수 구현하는 데서 시간을 너무 많이 썼다. 위 짤처럼 버그를 고치면, 다른 데서 버그가 났고, 그 버그를 고치면 이전 테스트 케이스가 통과가 안 되는 일이 엄청 많았기 때문이다. 무한 버그의 굴레 끝에 'ALL PASSED' 문구를 봤을 때의 감동을 아직도 잊지 못 하겠다(짜릿해).

프로세스 계층 구조 개요

Process의 정보에 부모와 자식 field를 추가하여 이를 관리하는 함수를 제작한다. 이때, project1에서 사용되었던 semaphore 개념이 사용된다. Process 관련 system call에는 fork(), exit(), exec(), wait()이 있다. 하나하나 만들어가며 유의해야 할 점, 알아야 할 점을 정리한다.

 

exec

이 함수는 현재 process를 입력 받은 실행 파일로 변경하는 함수이다. 새로운 process를 생성하는 것은 아니며, process가 현재 갖고 있는 context를 실행하고자 하는 파일로 변경하는 느낌이다. fork와 자주 함께 쓰이는 시스템 콜이다.

구현

• 인자로 받은 cmd_line의 주소 유효성 확인(check_address()) 
  • 인자의 저장된 위치는 '유저 영역'이어야만 함
• palloc_get_page() 함수와 strlcpy() 함수를 이용해 cmd_line_copy 변수로 복사
  • cmd_line_copy 변수 생성 이유 : caller vs load의 race condition 방지하기 위해
• 이후 process_exec() 함수를 호출하여 cmd_line의 프로세스를 load()
  • 이는 stack에 쌓임
• 예외 처리
  • 메모리 할당 실패 ➡️ exit(-1)
  • process_exec() return -1 ➡️ exit(-1)

int exec(const char *cmd_line)
{
	check_address(cmd_line);

	char *cmd_line_copy;
	cmd_line_copy = palloc_get_page(0);
	if (cmd_line_copy == NULL) // 예외 처리
		exit(-1);
	strlcpy(cmd_line_copy, cmd_line, PGSIZE);

	if (process_exec(cmd_line_copy) == -1) // 예외 처리
		exit(-1); 
}

 

fork

CMU, Introduction to Computer System, spring 2009

Pintos Instruction에서....

%RBX, %RSP, %RBP,  %R12 - %R15를 제외한 나머지 레지스터값은 복제할 필요가 없다. 반드시 자식 프로세스의 process id를 반환해라. 그렇지 않으면 유효한 pid가 아니다. 자식 프로세스에서, 리턴값은 반드시 0이어야 한다. 자식 프로세스는 반드시 부모 프로세스로부터 파일 디스크립터, 가상 메모리 공간 등을 포함한 자원을 복사해와야 한다.

부모 프로세스는 자식 프로세스가 성공적으로 복제된 것을 알고 나서 fork로부터 리턴해야 한다. 즉, 만약 자식 프로세스가 자원을 복제하는데 실패하면 부모 프로세스의 fork() 호출은 반드시 TID_ERROR를 반환해야 한다. 이 템플릿은 threads/mmu.c 내에 있는 pml4_for_each() 를 사용해 전체 user memory 공간을 복제하는데, 대응하는 페이지 테이블 구조체를 포함한다. 하지만 빈 부분(pte_for_each_func에서)을 채워야 한다.

 

fork 시스템 콜은 현재 process와 완전히 동일한 process를 하나 더 만드는 시스템 콜이다. 동일하게 만든다는 의미를 쉽게 생각하면, 부모 process의 context를 자식이 알고 있기 때문에 자식 process는 main() 함수에서부터 다시 시작해야 하는 것이 아니라 부모 process가 마지막으로 실행한 코드부터 실행할 수 있다는 것이다. Pintos에서는 하나 더 만든 process를 '자식 process'라고 한다. 이렇게 완전히 동일한 process를 어떻게 구분할 수 있을까? fork 함수의 return 값으로 pintos에서는 구분한다.

process_fork() 함수의 return value
pid 값에 담기거나 TID_ERROR 값이 return 되는데, 이 값은 아래 범위에 해당할 때 다음과 같은 뜻을 갖는다.
1. 음수 : fork가 정상적으로 완료되지 않아 자식 process가 만들어지지 않았음을 의미
2. 0 : 새로 만들어진 자식 process는 0을 return 받음으로써 자식 process임을 확인
3. 양수 : 자식 process가 정상적으로 만들어졌을 때, 부모 process가 pid 값을 return 받음

CMU, Introduction to Computer System, spring 2009

output
linux> ./fork
parent: x=0
child : x=2

만약 각각의 process에서 코드가 실행되면, fork() 함수를 만났을 때, 자식 process에서는 0이 return 되고, 이후 부모 process에서는 pid가 return 되며, 각각의 코드가 실행된다.

 

부모 process의 context를 복사해온다는 것은 무엇일까? fork라는 시스템 콜이 호출되면 user 프로그램에서 syscall_handler() 로 진입하게 된다. thread 구조체 내에 있는 interrupt frame(if)은 context switching이 발생할 때마다 값이 바뀌게 된다. 즉, syscall_hanlder()로 user context(a.k.a 부모 process)의 interrupt frame을 전달한다. thread_create() 함수를 통해 자식 process가 생성될 때 부모 context를 복사해올 수 있는 것이다.

그런데, fork 과정 중에 context switching으로 인해 부모 process의 interrupt frame이 바뀌게 되면 문제가 발생한다. 자식 process를 생성할 때 현재 thread의 interrupt frame을 가져오도록 구현한다면 context switching으로 인해 가져와야 하는 자신의 부모 process interrupt frame을 가져오지 못할 수 있기 때문이다(문맥이 다르기 때문에 자식 process 코드는 엉뚱한 곳에서부터 실행될 수 있다!).

이를 해결하기 위해서 interrupt frame을 저장하는 추가 변수를 만들어 syscall_hanlder에 진입할 때마다 user context의 interrupt frame을 저장해둔다. 이렇게 하면 부모 process의 문맥을 가져와야 할 때, 저장된 interrupt frame을 가져오기에 현재 thread의 interrupt frame을 가져오는 것보다 정확하다. 이 과정은 __do_fork() 함수에서 확인할 수 있다.

process_fork() 구현

정리하면 1. 부모 process는 현재 실행 중인 user process이고 2. interrupt frame은 system call 호출로 인해 바뀌었다 또한, _if.rsp는 kernel stack에 위치!

위에서 언급한 것 처럼 thread 구조체에 parent_if field를 추가하고, 자식 process를 담아줄 리스트 field를 추가한다.

struct thread {
	...
	struct list child_list;             /* 자식 프로세스를 담아줄 리스트*/
	struct list_elem child_elem;		/* child_list에 담아줄 elem */ 
	...
	/* Owned by thread.c. */
	struct intr_frame tf;               /* Information for switching */
	unsigned magic;                     /* Detects stack overflow. */
	struct intr_frame parent_if;         /* 유저 스택의 정보를 인터럽트 프레임 안에 넣어서, 커널 스택으로 넘겨주기 위함 */ //변경사항 - 자식에게 넘겨줄 intr_frame
};

 

부모 process가 thread_create() 함수를 통해 자식 process를 생성한 후, 자식 process가 정상적으로 로드될 때까지 기다려야 한다. 이때, semaphore가 사용된다. 자식 process의 fork_sema에 대해 sema_down()을 호출하여, 자식 process가 정상 생성될 때까지 대기한다. 정상 생성 후 자식 process는 sema_up()을 호출해 자신의 semaphore를 해제함으로써 부모 process가 continue되도록 한다.

 

tid_t process_fork(const char *name, struct intr_frame *if_ UNUSED) {
    /* Clone current thread to new thread.*/
    struct thread *curr = thread_current();
    
    memcpy(&curr->parent_if, if_, sizeof(struct intr_frame)); // 부모 process if_ 복사 -> 자식 process 사용 예정
    
    tid_t pid = thread_create(name, PRI_DEFAULT, __do_fork, curr); // __do_fork 함수를 자식 process 생성 시 실행함수로 지정
    if (pid == TID_ERROR)
        return TID_ERROR;
    
    struct thread *child = get_child(pid); // 생성된 자식 process의 thread 구조체 할당
    sema_down(&child->fork_sema);          // 자식 process 로딩 완료 전까지 부모 process 대기
    
    if (child->exit_status == -1)
        return TID_ERROR;
    
    return pid;
}

 

__do_fork()

Pintos 내 hint

/* TODO: Your code goes here.
 * TODO: Hint) To duplicate the file object, use `file_duplicate`
 * TODO:           in include/filesys/file.h. Note that parent should not return
 * TODO:           from the fork() until this function successfully duplicates
 * TODO:           the resources of parent.*/

 

자식 process의 생성 이후 부모 process가 가진 것과 동일한 FDT(File Descriptor Table)가 생성되어야 한다. 주어진 Hint에서 알 수 있는 것과 같이 file_duplicate() 함수를 사용하면 file을 쉽게 복사할 수 있다.

static void __do_fork(void *aux){
    ...
    /* FDT 복사 */
    for (int i = 0; i < FDT_COUNT_LIMIT; i++) {
        struct file *file = parent->fdt[i];
        if (file == NULL)
            continue;
        if (file > 2)
            file = file_duplicate(file);
        current->fdt[i] = file;
    }
    current->next_fd = parent->next_fd;

    sema_up(&current->fork_sema); // 로드가 완료될 때까지 기다리고 있던 부모 대기 해제
    process_init();
    ...
   }

CMU

마지막으로 fork_sema를 sema_up()하여 부모 process의 대기가 끝나도록 한다.

wait

부모 프로세스는 자식 프로세스가 종료될 때까지 멈춰있어야 한다. 부모 프로세스가 wait(자식_프로세스_id)를 호출하면 wait 함수의 리턴 값으로 자식 프로세스의 exit status를 받게 된다(비정상 종료 시 exit status는 -1). 부모 프로세스는 이를 통해 자식 프로세스의 종료 여부를 알 수 있게 된다. 추후 자식 프로세스 종료 시 자식 자원 반환 할 때 신호로 사용된다.

현재는 while(), for 등으로 대기 상태를 모사 해두었을텐데 이는 당연히 필요 없어진다. wait() 함수는 사용자에게 제공되는 인터페이스(API)역할을 하며, process_wait() 함수는 실제로 자식 프로세스가 종료될 때까지 기다리는 로직을 구현한다. 즉, 두 함수를 구분(캡슐화)하여야 한다.

구현

wait 구현

• wait 함수의 인자로 받은 pid를 process_wait() 함수로 넘김

process_wait()

• 현재 실행 중인 thread를 가져옴
• 인자로 받은 pid에 해당하는 thread를 가져옴
  • 예외 처리 : 해당하는 자식 프로세스가 없는 경우 -1 반환
• wait_sema를 사용해 자식 process의 종료를 기다림
  • 이 동안 현재 thread(부모)는 대기 상태가 됨
• 자식 process가 종료된 경우 부모 process의 자식 목록에서 제거
• free_sema를 사용해 자식 프로세스의 자원을 해제할 수 있도록 semaphore로 신호를 보냄
• 자식 프로세스의 exit_status 반환

이렇게 process_wait() 함수에서 프로세스 간 동기화가 가능하다. 한양대 핀토스 PPT 자료에는 semaphore를 통해 동기화를 구현하라고 되어 있어서 이렇게 했는데, 조건변수로도 가능할 것 같다. 다만, 신호가 손실된다던지, thread가 조건을 검사하고 조건 변수에서 대기하려고 할 때 다른 thread가 실행된다든지 하는 race condition 상황을 적절하게 처리해줘야 하기에 난이도가 훨씬 높을 것이다.

int wait(int pid)
{
	return process_wait(pid);
}

int process_wait(tid_t child_tid UNUSED) {
    struct thread *cur = thread_current();
    struct thread *child = get_child_process(child_tid);
    if (child == NULL)
        return -1;
    sema_down(&child->wait_sema);
    int exit_status = child->exit_status;
    list_remove(&child->child_elem);
    sema_up(&child->free_sema);
    return exit_status;
}

Exit

이 시스템 콜은 현재 프로세스의 exit status를 현재 thread의 exit_stauts에 할당 후 exit된 process의 할당되어 있던 자원을 모두 해제해준다. thread_exit() 함수가 구현되어 있기에 쉽게 만들 수 있다.

void exit(int status) {
    struct thread *curr = thread_current();
    curr->exit_status = status;
    printf("%s: exit(%d)\n", curr->name, status);  // process termination message
    thread_exit();
}