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

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

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

---

들어가기 전에

레지스터 역할 정리

1. %rax : system call number 저장 ▶️ 운영체제가 어떤 시스템 호출을 수행할지 결정하는 데 사용됨
2. %rdi, %rsi, %r10, % r8, %r9 : system call arguments 전달에 사용(호출에 따라 일부만 사용될 수 있으며, 순서대로 할당됨)
3. %rcx : syscall 명령어 사용 시 %rcx 레지스터에 복귀 주소가 저장됨(일반적인 함수 호출 시에는 스택에 저장!) ⬅️ 운영체제에서 자동 처리
4. %r11 : syscall 명령어 사용 시 현재 process state를 나타내는 리플래그(RFLAGS 레지스터 값)가 저장됨. 시스템 호출 간 process state를 보존하는 목적으로 사용됨 ⬅️ 운영체제에서 자동 처리

Exception 처리

Exception(예외)이란 코드 실행 중에 어떤 이벤트가 발생하는 것을 말한다. 즉, 정상 흐름을 방해하는 것으로 page fault 혹은 0으로 나누는 행위(divide by zero)와 같은 오류(내부 인터럽트)를 들 수 있다. 이러한 예외 처리는 운영 체제에서 담당한다. Project1에서는 외부 인터럽트를 운영 체제가 타이머와 I/O interrupts로 처리하는 것을 다루었다. Project2에서는 user program이 예외 처리 메커니즘으로 운영 체제에 서비스(halt, exit, open 등)를 요청하는 것을 구현하며 System Call이라고 한다.

x86-64 아키텍처에서의 System Call

x86-64 아키텍처에서 시스템 호출을 위한 명령어인 syscall이 도입되었다. 이 명령어를 통해 system call handler를 빠르게 호출할 수 있다. syscall 명령어 사용 시 system call number와 추가 arguments는 레지스터에 설정되어 있어야 한다(참고 : Linux system call table 정리).

System Call Handling

syscall_handler()가 호출되면, system call number는 %rax, 여타 arguments는 순서대로 %rdi, %rsi, %rdx, %r10, %r8, %r9 순서대로 할당된다. x86-64 convention에 따라 함수 반환 값은 RAX 레지스터에 위치되며, return 값이 있는 시스템 호출은 intr_frame의 rax 멤버(%rax)를 수정하는 것을 알 수 있다.

💡 x86-64 아키텍쳐에서는 syscall 명령어를 통해 system call을 위한 syscall_handler를 빠르게 호출할 수 있고, system call number와 arguments는 정해진 레지스터에 설정되어 전달된다. 시스템 호출 결과는 RAX 레지스터에 return 되며 이는 intr_frame의 %rax 수정으로 이루어진다.

코드로 살펴보기

main() 함수의 msg()에서 vmsg() 내 어떤 system call을 호출하면(halt() 가정)

1️⃣ syscall.c에서 halt() 함수 호출

void
halt (void) {
	syscall0 (SYS_HALT);
	NOT_REACHED ();
}

2️⃣ syscall0 (SYS_HALT);

/* Invokes syscall NUMBER, passing no arguments, and returns the
   return value as an `int'. */
#define syscall0(NUMBER) ( \
		syscall(((uint64_t) NUMBER), 0, 0, 0, 0, 0, 0))

/* System call numbers. */
enum {
	/* Projects 2 and later. */
	SYS_HALT,                   /* Halt the operating system. */
	SYS_EXIT,                   /* Terminate this process. */
	SYS_FORK,                   /* Clone current process. */
	SYS_EXEC,                   /* Switch current process. */
	SYS_WAIT,                   /* Wait for a child process to die. */
	SYS_CREATE,                 /* Create a file. */
	SYS_REMOVE,                 /* Delete a file. */
	SYS_OPEN,                   /* Open a file. */
	SYS_FILESIZE,               /* Obtain a file's size. */
	SYS_READ,                   /* Read from a file. */
	SYS_WRITE,                  /* Write to a file. */
	SYS_SEEK,                   /* Change position in a file. */
	SYS_TELL,                   /* Report current position in a file. */
	SYS_CLOSE,                  /* Close a file. */
    ...
    }

syscall0 (SYS_HALT); 는 syscall0 (3); 이라는 것으로 결국 #define에 따라 syscall(3, 0, 0, 0, 0, 0, 0)이 호출된다.

3️⃣ syscall()

__attribute__((always_inline))
static __inline int64_t syscall (uint64_t num_, uint64_t a1_, uint64_t a2_,
		uint64_t a3_, uint64_t a4_, uint64_t a5_, uint64_t a6_) {
	int64_t ret;
	/* system call arguments를 binding 함 */
	register uint64_t *num asm ("rax") = (uint64_t *) num_;
	register uint64_t *a1 asm ("rdi") = (uint64_t *) a1_;
	register uint64_t *a2 asm ("rsi") = (uint64_t *) a2_;
	register uint64_t *a3 asm ("rdx") = (uint64_t *) a3_;
	register uint64_t *a4 asm ("r10") = (uint64_t *) a4_;
	register uint64_t *a5 asm ("r8") = (uint64_t *) a5_;
	register uint64_t *a6 asm ("r9") = (uint64_t *) a6_;

	__asm __volatile(
			"mov %1, %%rax\n"
			"mov %2, %%rdi\n"
			"mov %3, %%rsi\n"
			"mov %4, %%rdx\n"
			"mov %5, %%r10\n"
			"mov %6, %%r8\n"
			"mov %7, %%r9\n"
			"syscall\n"
			: "=a" (ret)
			: "g" (num), "g" (a1), "g" (a2), "g" (a3), "g" (a4), "g" (a5), "g" (a6)
			: "cc", "memory");
	return ret;
}

• system call arguments 중 인자로 사용될 값 중 첫 번째 값(num_)이 'rax'에 binding 되는 것을 확인할 수 있음
• 나머지 인자는 순서대로 rdi, rsi, rdx ,..., r9에 binding 됨
• __asm __volatile 로 항상 명시된 순서대로 작동하도록 함
• mov 명령어로 미리 정의된 레지스터에 할당
• syscall 명령어로 실제 system call이 수행됨(이제야 CPU는 커널 모드 전환)
• syscall 결과는 ret 변수에 담겨 caller에 반환됨

4️⃣ "syscall\n"

#include "threads/loader.h"

.text
.globl syscall_entry
.type syscall_entry, @function
syscall_entry:
	movq %rbx, temp1(%rip)
	movq %r12, temp2(%rip)     /* callee saved registers */
	movq %rsp, %rbx            /* Store userland rsp    */
	movabs $tss, %r12
	movq (%r12), %r12
	movq 4(%r12), %rsp         /* Kernel Stack 진입! */
	/* Now we are in the kernel stack */
	push $(SEL_UDSEG)      /* if->ss */
	push %rbx              /* if->rsp */
	push %r11              /* if->eflags */
	push $(SEL_UCSEG)      /* if->cs */
	push %rcx              /* if->rip */
	subq $16, %rsp         /* skip error_code, vec_no */
	push $(SEL_UDSEG)      /* if->ds */
	push $(SEL_UDSEG)      /* if->es */

movq 명령을 통해 %rsp가 kernel stack으로 이동한다. 드디어 user stack에서 kernel stack으로 진입하게 됐다! 이 명령어는  syscall-entry.S에 있다. '.S' 파일은 C언어로 작성된 프로그램에서 어셈블리 언어 코드를 포함하는 파일이다. 전처리기에서 처리되며 C언어의 전처리기 지시문(#include, #define 등)을 사용할 수 있다.

• movq 4(%r12), %rsp : r12에서 4 byte를 더한 주소로 rsp를 이동시킴(x86-64 아키텍처이므로 8바이트 단위가 되어야 할 것 같은데.. 추후에 살펴볼 예정이다 🤔)

위 과정을 거쳐서 syscall_handler() 함수로 넘어가게 되며, kernel 단의 작업을 수행할 수 있게 된다.

 

---

System Call Handler

1. User stack pointer(rsp)와 system call arguments가 유효 주소 영역(user stack)인지 확인하도록 구현
2. System call number를 이용하여 해당 system call의 서비스 루틴을 호출하도록 구현
3. User stack interrupt frame의 arguments를 kernel stack에 복사되도록 구현
4. System call return 값을 Interrupt frame의 rax에 저장되도록 구현

void check_address (void *addr)

System Call Handler 1번에 해당하는 함수를 구현한다.

• 주소 값이 유저 영역 주소 값인지 확인
• 유저 영역이 아니라면 process exit

void
check_address (void *addr){
	if (addr != NULL && is_user_vaddr(addr)){
		return; // 유효한 주소
	}
	exit (-1);      // 유효하지 않은 주소일 때 처리
}

• 처음 코드를 작성 시 exit() 함수 대신 thread_exit() 함수를 사용하였을 수도 있음
• pintos를 완전히 종료할 때 조건이 붙는 게 있기 때문에 추후 exit () 함수를 만들어 사용하게 됨

한양대 Pintos PPT에 필요한 함수로 나와 있는 'void get_argument()' 함수는 구현할 필요가 없다(system call arguments를 이미 kernel에 복사했기 때문).

# 참고

make check > log.txt 결과 확인, 그림과 같이 msg 출력이 전혀되지 않음을 알 수 있다.

System Call 각각이 잘 구현되었는지 확인('make check'를 통한 PASS, FAIL 확인)을 위해서는 main.c 의 msg가 출력되어야 한다. 위 그림에서 처럼 output 비교가 되기 때문인데, 현재 부모 process는 자식 process를 생성하고 곧바로 종료되므로 msg가 출력될 수 없다. 당연하게도 FAIL이 계속 나오게 된다.

 

halt()

System Call Handler 2, 3, 4번에 해당하는 구현내용이다.

syscall_handler (struct intr_frame *f UNUSED) {
	// TODO: Your implementation goes here.
	int syscall_number = f->R.rax; // system call number 가져오기
	switch (syscall_number){
		case SYS_HALT:
			halt();
			break;
        	...
		case SYS_WAIT:
			f->R.rax = wait(f->R.rdi); // return 값 현재 rax에 저장
			break;
	}

• f->R.rax의 system call number를 가져오고, 이 number에 맞는 함수가 실행되도록 서비스 루틴 구성
• System call return 값이 있는 경우 현재 rax에 저장

halt() 함수는 pintos라는 운영체제를 종료시키는 함수이다.

void
halt (void){
	power_off (); // pintos 완전히 종료
}

 

이렇게 매우 간단하게 구현된다.

exit()

현재 프로세스를 종료시키는 system call이다.

• Process Termination Message : "프로세스 이름: exit(status)"
• 정상 종료 시 status는 0

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

check_address()에서 유효하지 않은 주소인 경우 exit (-1)으로 process를 exit 해야하는 이유를 알 수 있다.

 

create()

입력 받은 file 위치에 initial_size 만큼 할당하는 system call이다.

bool
create (const char *file, unsigned initial_size){ // 파일 시스템 생성 시스템 콜
	check_address(file);                      // 유효한 주소인 경우
	return filesys_create(file, initial_size);  
}

*마찬가지로 create 호출 시 syscall_handler의 switch 문에서 걸리도록 case 추가 필요

---

Hierarchical Process Structure 전까지 완료하였다. 이후에는 현재 프로세스가 종료되는 것을 semaphore를 이용해 해결하여, Pintos를 발전시킨다.

 

시간이 녹는다 HURRY UP 🫠