PintOS Project2 : User Programs

 

---

🚫 PintOS를 실행시키기 위한 준비 중 마주친 에러

 

pintOS 가상 머신에 파일을 넣기 위해서 먼저 파일 시스템 파티션이 있는 모의 디스크를 만들어야 한다. 

pintos-mkdisk filesys.dsk 10 
pintos --fs-disk filesys.dsk -p tests/userprog/args-single:args-single -- -q -f run 'args-single onearg'

 

위의 코드는 파일 시스템 파티션으로 어떻게 디스크를 생성하고, 파일 시스템의 형식을 만들고, args-single이라는 이름의 프로그램을 어떻게 새 디스크에 만들고, onearg 라는 인자를 전달해서 실행하는지에 대한 요약 코드이다.

 

이 코드를 실행하게 되면 kernel panic을 마주하게 된다.

Kernel PANIC at ../../threads/vaddr.h:87 in vtop(): assertion 
`is_kernel_vaddr (vaddr)' failed.

 

backtrace 결과

Call stack: 0x800421874b 0x80042072c0 0x800420a92f 0x8004214d12 0x8004209704 0x8004209b22 0x800420762b
Translation of call stack:
0x000000800421874b: debug_panic (lib/kernel/debug.c:32)
0x00000080042072c0: thread_yield (threads/thread.c:340)
0x000000800420a92f: sema_up (threads/synch.c:124)
0x0000008004214d12: interrupt_handler (devices/disk.c:526)
0x0000008004209704: intr_handler (threads/interrupt.c:353)
0x0000008004209b22: intr_entry (threads/intr-stubs.o:?)
0x000000800420762b: kernel_thread (threads/thread.c:456)

 

이 오류는 프로젝트 1에서 prioirty scheduling을 위해 sema_up 함수에서 thread_yield 함수를 호출한 것이 문제였다.

파일 시스템에서 sema_up을 호출할 때 externel interrupt를 끄지 않아서 assert가 발생한 문제라고 한다.

 

그래서 thread.c에서 thread_try_yield() 함수를 생성해주고 sema_up() 부분도 수정해주면 에러 해결!

/* thread.c */

void thread_try_yield(void){
	if(!list_empty(&ready_list) && thread_current() != idle_thread && !(intr_context()))
		thread_yield();
}

/* synch.c */

void
sema_up (struct semaphore *sema) {
	enum intr_level old_level;

	ASSERT (sema != NULL);

	old_level = intr_disable ();

	if (!list_empty (&sema->waiters))
	{
		list_sort(&sema->waiters, cmp_priority, NULL);
		//sema->waiters에 있는 맨 앞 쓰레드를 깨운다.
		thread_unblock (list_entry (list_pop_front (&sema->waiters),
				struct thread, elem));			
	}

	sema->value++;

	intr_set_level (old_level);	
	
	//cpu 양보
	thread_try_yield();
}

 

---

Argument passing

user프로그램이 실행되기 전에 프로그램에 대한 인자를 설정해야 한다.

 

es) "/bin/ls -l foo bar" 인자 처리하기

 

1. 명령어로 단어를 분할한다. /bin/ls, -l , foo, bar

2. 각 문자열의 주소 + 경계조건을 위한 널포인터를 스택에 오른쪽에서 왼쪽 순서로 푸시한다.

    ->  argv[0] 이 가장 낮은 가상 주소를 가진다.

    -> 최고의 성능을 위해 첫 번째 푸시 전에 스택 포인터를 8의 배수로 정렬한다.

3. %rsi가 argv 주소( argv[0]의 주소)를 가리키게 하고, %rdi를 argc로 설정한다.

4. 마지막으로 가짜 return address를 푸시한다.

    -> entry 함수는 절대 반환하지 않지만, 해당 스택 프레임은 다른 스택 프레임들과 같은 구조를 가져야 한다.

 

스택 포인터는 0x4747ffb8로 초기화된다.

Address	Name	Data	Type
0x4747fffc	argv[3][...]	'bar\0'	char[4]
0x4747fff8	argv[2][...]	'foo\0'	char[4]
0x4747fff5	argv[1][...]	'-l\0'	char[3]
0x4747ffed	argv[0][...]	'/bin/ls\0'	char[8]
0x4747ffe8	word-align	0	uint8_t[]
0x4747ffe0	argv[4]	0	char *
0x4747ffd8	argv[3]	0x4747fffc	char *
0x4747ffd0	argv[2]	0x4747fff8	char *
0x4747ffc8	argv[1]	0x4747fff5	char *
0x4747ffc0	argv[0]	0x4747ffed	char *
0x4747ffb8	return address	0	void (*) ()

 

RDI: 4 | RSI: 0x4747ffc0

 

 

argument passing 인자 전달

코드의 흐름

init.c → int main(void) → run_actions(argv) → run_task(char **argv) → process_create_initd(task) → thread_create (file_name, PRI_DEFAULT, initd, fn_copy) → initd→process_exec → load, do_iret

 

1. process_create_initd()

👉🏻 command line을 parsing 해서 file_name을 찾는다.

 

- 인자로 들어오는 file_name이 실행 시 입력된 command line이다.

- 이 command line을 parsing해서 파일 이름을 찾는다.

- parsing해서 얻어낸 파일 이름이 thread_create 함수의 첫 번째 인자로 들어가야 한다.

tid_t
process_create_initd (const char *file_name) {
	char *fn_copy;
	tid_t tid;

	/* Make a copy of FILE_NAME.
	 * Otherwise there's a race between the caller and load(). */
	fn_copy = palloc_get_page (0);	//file_name의 복사본
	if (fn_copy == NULL)
		return TID_ERROR;
	strlcpy (fn_copy, file_name, PGSIZE);

	//Argument Pasing
	//command_line을 parsing해서 file_name 찾는다.
	char *save_ptr;
	strtok_r (file_name, " ", &save_ptr);
	//~Argument Pasing
	
	/* Create a new thread to execute FILE_NAME. */
	tid = thread_create (file_name, PRI_DEFAULT, initd, fn_copy);
	if (tid == TID_ERROR)
		palloc_free_page (fn_copy);
	return tid;
}

 

2. process_exec()

 

👉🏻 인자로 들어오는 f_name을 parsing 하고 user_stack에 매개변수들을 push 한다.

 

- parsing 한 인자들을 담을 parse 배열의 길이는 64로 지정한다.

- strtok_r 함수를 활용해 parsing 한 결과를 count와 parse에 담아두고, 아래에서 새로 선언한 argument_stack 함수를 호출할 때 전달한다.

- hex_dump() 함수를 사용하여 결과를 확인한다. (메모리의 내용을 16진수 형식으로 출력해 줘서 스택에 저장된 값들을 확인할 수 있다.)

int
process_exec (void *f_name) {
	char *file_name = f_name;
	bool success;

	/* We cannot use the intr_frame in the thread structure.
	 * This is because when current thread rescheduled,
	 * it stores the execution information to the member. */
	struct intr_frame _if;
	_if.ds = _if.es = _if.ss = SEL_UDSEG;
	_if.cs = SEL_UCSEG;
	_if.eflags = FLAG_IF | FLAG_MBS;

	/* We first kill the current context */
	process_cleanup ();

	// Argument Passing ~
    	int argc = 0;
    	char *argv[64];		//parssing한 인자를 담을 배열
        char *token, *save_ptr;
    
	for (token = strtok_r(file_name, " ", &save_ptr); token != NULL; token = strtok_r(NULL, " ", &save_ptr))
    	{   
		argv[argc++] = token;
	}	
    	// ~ Argument Passing
		
	/* And then load the binary */
	success = load (file_name, &_if);

	// Argument Passing ~
    	argument_stack(argv, argc, &_if); // 함수 내부에서 argv와 rsp의 값을 직접 변경하기 위해 주소 전달
    
	hex_dump(_if.rsp, _if.rsp, USER_STACK - (uint64_t)_if.rsp, true); // user stack을 16진수로 프린트
    	// ~ Argument Passing

	/* If load failed, quit. */
	palloc_free_page (file_name);
	if (!success)
		return -1;

	/* Start switched process. */
	do_iret (&_if);
	NOT_REACHED ();
}

 

3. argument_stack()

 

👉🏻 process_exec() 함수에서 parsing 한 프로그램 름과 인자를 스택에 저장하기 위해 사용할 함수를 새로 선언한다.

 

1. 프로그램 이름, 인자 문자열 push

스택은 아래 방향으로 커지므로 스택에 인자를 추가할 때 오른쪽-> 왼쪽 방향으로 push

 

2. word-align(8의 배수)로 맞춰주기

각 문자열을 push 하고 나서 8byte 단위로 정렬하기 위해 padding을 추가한다.

 

3. 인자 문자열 종료를 나타내는 0 push

정렬하고 나서 0을 push 한다. (인자 문자열들의 종료를 의미한다)

 

4. 각 인자 문자열의 주소 push

인자 문자열 push 하면서 argv에 담아둔 각 문자열의 주소를 push 한다.

 

5. fake return address

다음 인스트럭션의 주소를 push 해야 하는데, 지금은 프로세스를 생성하는 거라서 반환 주소가 없다. 그래서 fake return address로 0을 추가한다.

 

void argument_stack(char **argv, int argc, struct intr_frame *if_)
{
	char *arg_address[128];

	// 프로그램 이름, 인자 문자열 push
	for(int i = argc - 1; i >= 0; i--)
	{
		int arg_i_len = strlen(argv[i]) +1;	//sential(\0) 포함
		if_->rsp -= arg_i_len;			//인자 크기만큼 스택을 늘려줌
		memcpy(if_->rsp, argv[i], arg_i_len);	//늘려준 공간에 해당 인자를 복사
		arg_address[i] = (char *)if_->rsp;	//arg_address에 위 인자를 복사해준 주소값을 저장
	}

	// word-align(8의 배수)로 맞춰주기
	if(if_->rsp % 8 != 0)
	{	
		int padding = if_->rsp % 8;
		if_->rsp -= padding;
		memset(if_->rsp, 0, padding);
	}

	// 인자 문자열 종료를 나타내는 0 push
	if_->rsp -= 8; 	
	memset(if_->rsp, 0, 8);

	// 각 인자 문자열의 주소 push
	for(int i = argc-1; i >= 0; i--)
	{
		if_->rsp -= 8;
		memcpy(if_->rsp, &arg_address[i], 8);
	}

	// fake return address
	if_->rsp -= 8;
	memset(if_->rsp, 0, 8);

	//rdi 에는 인자의 개수, rsi에는 argv 첫 인자의 시작 주소 저장
	if_->R.rdi = argc;
	if_->R.rsi = if_->rsp + 8;	//fake return address + 8
}

 

 

4. process_wait

argument passing 테스트를 하려면 일단 wait를 흉내라도 내야 해서 임시방편으로 반복문을 추가한다.

10억으로 하면 너무 빨리 끝나버리고 100억으로 하면 time out이 떠서 업다운게임한 결과 30억으로 하니 잘되었다.

int
process_wait (tid_t child_tid UNUSED) {
	/* XXX: Hint) The pintos exit if process_wait (initd), we recommend you
	 * XXX:       to add infinite loop here before
	 * XXX:       implementing the process_wait. */
	for(int i = 0; i < 3000000000; i++);
	return -1;
}

 

Test 결과

---

User Memory Access

 

커널은 종종 사용자 프로그램이 제공한 포인터를 통해 메모리에 접근해야 한다.

그러나 사용자가 잘못된 주소 포인터를 전달할 수 있으므로, 커널은 이를 매우 신중하게 처리해야 한다.

-> null 포인터,

-> 매핑되지 않은 가상 메모리를 가리키는 포인터 

-> 커널 가상 주소 공간(KERN_BASE 이상)

 

check_address

user 프로그램이 잘못된 포인터를 전달하면 exit을 호출한다.

void check_address(void *file_addr)
{
	struct thread *t = thread_current();
	if(file_addr == "\0" || file_addr == NULL || !is_user_vaddr(file_addr) || pml4_get_page(t->pml4, file_addr) == NULL)
		exit(-1);
}

 

 

File System

System Calls 중에는 File System과 관련된 호출이 많은데, Pintos에서 이미 구현되어 있는 File System을 제공해주기 때문에 filesys.h 또는 file.h에서 적절한 함수를 찾아서 사용하면 된다.

 

File System 코드를 실행하는 동안에는 한 번에 하나의 프로세스만 실행되도록 동기화를 사용해야 한다.

file 관련된 코드가 실행되기 전에 syscall.c에서 새로 만든 filesys_lock을 acquire한 후에 접근하도록 해야 한다.

이후 프로젝트에서 동기화로 인한 문제가 발생하므로 lock을 걸어줘야 하는 부분에 잘 걸어줘야 한다..

 

syscall.h에서 filesys_lock을 전역으로 새로 선언하고 syscall_init에서 초기화한다.

/* userprog/syscall.h */

#ifndef USERPROG_SYSCALL_H
#define USERPROG_SYSCALL_H

void syscall_init (void);
struct lock filesys_lock;

#endif /* userprog/syscall.h */

/* userprog/syscall.c */

void syscall_init(void)
{
...

    lock_init(&filesys_lock);
}

 

System Calls 구현

유저 프로그램이 시스템 콜을 보내면 시스템 콜 핸들러가 시스템 콜 번호를 받아오고, 어떤 시스템 콜 인자들을 받아오고, 그에 알맞은 액션을 취하도록 구현해야 한다.

 

시스템 콜 핸들러인 syscall_handler()가 제어권을 얻으면, 시스템 콜 번호가 %rax에 있으며, 인자값들은 순서대로 전달된다. (%rdi, %rsi, %rdx, %r10, %r8 and %r9)

호출자의 레지스터는 struct intr_frame으로 전달되어 접근할 수 있다.(struct infr_frame은 커널 스택에 있다.)

 

유저 프로그램의 프로토타입은 include/lib/user/syscall.h 담겨 있다. (이곳에 헤더 파일과 다른 include/lib/user에 있는 파일들은 유저 프로그램에서만 사용된다.) 

 

-> user/syscall.c 에서 syscall_handler()를 구현해서 시스템 콜 번호, 인자들을 받아와서 그에 알맞은 액션을 취하도록 시스템 콜 함수를 구현해야 한다.

 

void
syscall_handler (struct intr_frame *f UNUSED) 
{
	frame = f;
	int sys_num = f->R.rax;	 //시스템 콜 번호
	switch(sys_num)
	{
		case SYS_HALT:
			halt();
			break;
		case SYS_EXIT:	
			exit(f->R.rdi);
			break;
		case SYS_FORK:
			f->R.rax = fork(f->R.rdi);
			break;
		case SYS_EXEC:
			f->R.rax = exec(f->R.rdi);
			break;
		case SYS_WAIT:
			f->R.rax = wait(f->R.rdi);
			break;
		case SYS_CREATE:
			f->R.rax = create(f->R.rdi, f->R.rsi);
			break;
		case SYS_OPEN:
			f->R.rax = open(f->R.rdi);
			break;
		case SYS_FILESIZE:
			f->R.rax = filesize(f->R.rdi);
			break;
		case SYS_READ:
			f->R.rax = read(f->R.rdi, f->R.rsi, f->R.rdx);
			break;
		case SYS_WRITE:
			f->R.rax = write(f->R.rdi, f->R.rsi, f->R.rdx);
			break;	
		case SYS_SEEK:
			seek(f->R.rdi, f->R.rsi);
			break;	
		case SYS_TELL:
			f->R.rax = tell(f->R.rdi);
			break;	
		case SYS_CLOSE:
			close(f->R.rdi);
			break;	

		default:
			break;
	}
	//printf ("system call!\n");
	//thread_exit ();
}

 

1. halt

src/include/threads/init.h에 선언된 power_off()를 호출하면서 핀토스를 종료한다.

-> #include "threads/init.h" 추가해야 됨

교착 상태 등에 대한 일부 정보를 잃게 되므로 거의 사용하지 않는 것이 좋다.

void halt (void) 
{	
    power_off();
}

 

2. exit

 

현재 동작 중인 유저 프로그램을 종료시키고, 커널로 상태를 반환한다.

만약 프로세스의 부모가 wait 상태라면 , wait에 들어갈 상태를 반환할 것이다.

일반적으로 상태가 0이면 성공, 0이 아닌 수는 에러를 가리킨다.

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

 

 

3. create

file을 이름으로 하고 크기가 inital_size인 새로운 파일을 생성한다.

성공적으로 파일 생성하면 true, 실패 false 반환한다.

 

주어진 포인터 유효한 주소값을 가지는지 확인하기 위해  check_address() 함수를 생성하였다.

만일 유효한 주소값이면 filesys_create()로 파일 생성하도록 하였다.

bool create (const char *file, unsigned initial_size)
{	
	check_address(file);
	return filesys_create (file, initial_size);
}

 

4. remove

file이라는 파일을 삭제한다.

bool remove (const char *file)
{
	check_address(file);
	return filesys_remove(file);
}

 

 

5.  close()

- 열린 파일을 닫는다.

- 실행을 마치거나 종료되는 프로세스는 암묵적으로 이 함수를 호출하여 열린 파일 디스크립터들을 닫는다.

 

열린 파일을 닫으려면 파일 디스크립터에 해당 파일이 있는지 확인 후 파일 디스크립터 테이블에서 제거하고 해당 파일을 file_close() 하여 닫아주고 메모리를 해제한다.

 

void close (int fd)
{
	struct file_descrpitor *curr_fd = find_file_descriptor(fd);
   	 //파일 디스크립터를 찾지 못한 경우 함수 종료
	if(curr_fd == NULL) return NULL;
    	//파일 디스크립터가 연결된 리스트에서 해당 파일 디스크립터를 제거한다.
	list_remove(&curr_fd->fd_elem);
    	//파일 닫는다.
	file_close(curr_fd->file);
    	//파일디스크립터 해제
	free(curr_fd);
}

 

그리고 꼭 헤더파일을 추가해야한다!!!! (헤더파일 추가 안해서 계속 에러남)

#include "filesys/file.h"
#include "filesys/filesys.h"

 

5-2 . find_file_descriptor

파일 디스크립터 목록에서 주어진 파일 디스크립터 번호(fd)를 가진 파일 디스크립터를 찾는 함수를 만들어준다.

 

현재 파일 디스크립터의 번호와 주어진 파일 디스크립터 번호를 비교하여 일치하는지 확인하고 일치하다면 해당 파일 디스크립터의 포인터를 반환한다. 못 찾았다면 NULL을 반환하고 함수를 종료한다. 

struct file_descrpitor *find_file_descriptor(int fd)
{
	struct list *fd_list = &thread_current()->fd_list;
	if(list_empty(fd_list)) return NULL;

	struct file_descrpitor *file_descriptor;
	struct list_elem *cur_fd_elem = list_begin(fd_list);

	while(cur_fd_elem != list_end(&fd_list))
	{
		file_descriptor = list_entry(cur_fd_elem, struct file_descrpitor, fd_elem);

		if(file_descriptor->fd_num == fd)
		{
			return file_descriptor;	
		}			
		file_descriptor = list_next(cur_fd_elem);
	}
	return NULL;
}

---

🥲 헤맸던 점

 

close 부분에서 많은 시간이 걸렸다.

왜냐하면 처음에 find_file_descriptor() 함수 안의 코드들을 close 안에서 작성해주면서 만약 현재 파일 디스크립터 번호가 주어진 파일 디스크립터 번호인지 확인하는 조건문 안에서 삭제하고 파일 닫는 부분으로 구현 했는데 자꾸 안됐다. 자꾸 유저 프로그램이 끝나지 않는 에러가 생겼는데 그 이유가 break문을 안적어줘서....였다.

 

그리고 open을 하면서 현재 파일 파일 디스크립터에 동적 할당을 해줬는데 close 부분에서 메모리 할당 해제하는 부분을 안적어놔서 추가해줬다.

---

 

6. read

- fd로부터 열린 파일의 크기를 읽고 버퍼에 담는다. 실제로 읽은 파일의 크기를 반환하며 실패시 -1을 반환한다.

- fd가 0이면 input_getc() 를 이용해서 키보드 입력을 읽어온다.

 

주어진 파일 디스크립터 번호와 일치하는 파일 디스크립터를 찾아 그 파일을 읽어들이면된다.

int read (int fd, void *buffer, unsigned length)
{
	check_buffer(buffer);
	
	int byte = 0;
	char *ptr = (char *)buffer;
	if(fd == 0)
	{
		for(int i = 0; i < length; i++)
		{
			*ptr++ = input_getc();
			byte ++;
		}
	}
	else
	{
		lock_acquire(&filesys_lock);
		struct file_descriptor *curr_fd = find_file_descriptor(fd);
		if(curr_fd == NULL) return -1;
		byte = file_read(curr_fd->file, buffer, length);
		lock_release(&filesys_lock);
	}
	return byte;
}

 

6-2. filesize

 

열려있는 파일의 크기를 반환한다.(byte 단위로)

int filesize (int fd)
{
	struct file_descriptor *curr_fd = find_file_descriptor(fd);
	if(curr_fd == NULL) return -1;
	return file_length(curr_fd->file);
}

 

7. write

fd가 1(표준 출력)이면 콘솔에 출력을 해줬다면 이제는열린 파일 fd로 버퍼에 담긴 size만큼 출력해야 된다.

read와 상당히 유사해서 file_write() 함수로 수정해주면 된다.

int write (int fd, const void *buffer, unsigned length)
{
	check_buffer(buffer);
	int byte = 0;
	if(fd == 1)
	{
		putbuf(buffer, length);
		byte = length;
	}else
	{
		struct file_descriptor *curr_fd = find_file_descriptor(fd);
		if(curr_fd == NULL) return NULL;
		lock_acquire(&filesys_lock);
		byte = file_write(curr_fd->file, buffer, length);
		lock_release(&filesys_lock);

	}
	return byte;
}

 

8. open()

file 을 열기 위해서는 시스템 콜 open() 함수를 구현해야 한다.

open을 구현하기 위해서는 

1. file이 유효한 주소값인지를 검증해야 한다.

2. filesys_open를 호출해서 파일을 open한다.

3. process_add_file 함수를 호출해서 파일 디스크립터 테이블에 파일을 추가하고 fd를 반환한다.

4. 파일디스크립터 테이블에 추가할 수 없는 경우(fd == -1)인 경우엔 파일을 닫고 -1을 리턴한다.

5. 오픈한 파일의 fd를 반환한다.

int open (const char *file)
{
	check_address(file);
	struct file *file_open = filesys_open(file);
	if(file_open == NULL)
		return -1;

	int	fd = process_add_file(file_open);
	if(fd == -1)
		file_close(file_open);

	return fd;
}

 

8-2 process_add_file()

현재 스레드의 파일디스크립터에 현재 파일을 추가한다.

해당 파일의 파일 디스크립터 번호를 반환한다.

int process_add_file(struct file *file)
{
	struct thread *curr = thread_current();
	struct file_descriptor *cur_fd = malloc(sizeof(struct file_descriptor));
	struct list *fd_list = &thread_current()->fd_list;
	
	cur_fd->file = file;
	cur_fd->fd_num = (curr->last_create_fd)++;	
	
	list_push_back(fd_list, &cur_fd->fd_elem);

	return cur_fd->fd_num; 
}