syscall.c File Reference

#include "userprog/syscall.h"
#include <stdio.h>
#include <syscall-nr.h>
#include "threads/interrupt.h"
#include "threads/thread.h"
#include "threads/loader.h"
#include "userprog/gdt.h"
#include "threads/flags.h"
#include "intrinsic.h"
#include "filesys/filesys.h"
#include "filesys/file.h"
#include "threads/vaddr.h"
#include "threads/palloc.h"
#include "lib/stdio.h"
#include "threads/synch.h"
#include "vm/vm.h"

Include dependency graph for syscall.c:

Macros
#define	MSR_STAR   0xc0000081 /* Segment selector msr */
#define	MSR_LSTAR   0xc0000082 /* Long mode SYSCALL target */
#define	MSR_SYSCALL_MASK   0xc0000084 /* Mask for the eflags */

Typedefs
typedef int	pid_t

Functions
void	syscall_entry (void)
void	syscall_handler (struct intr_frame *)
void	get_argument (void *rsp, int argc, void *argv[])
void	halt (void)
	핀토스 자체를 종료시키는 시스템 콜 More...
void	exit (int status)
	현재 프로세스를 종료시키는 시스템 콜 More...
pid_t	fork (const char *thread_name, struct intr_frame *f)
	부모 프로세스로 부터 자식 프로세스를 복제한다. More...
int	exec (const char *file)
	cmd_line으로 들어온 실행 파일을 실행한다. More...
int	wait (tid_t pid)
	pid에 해당하는 자식 프로세스가 종료될 때까지 기다린다. More...
bool	create (const char *file, unsigned initial_size)
	파일을 생성하는 시스템 콜 More...
bool	remove (const char *file)
	파일을 샂게하는 시스템 콜 More...
int	open (const char *file)
	파일을 열 때 사용하는 시스템 콜 More...
int	filesize (int fd)
	파일의 크기를 알려주는 시스템 콜 More...
int	read (int fd, void *buffer, unsigned size)
	열린 파일의 데이터를 읽는 시스템 콜 More...
int	write (int fd, const void *buffer, unsigned size)
	열린 파일에 데이터를 쓰는 시스템 콜 More...
void	seek (int fd, unsigned position)
	열린 파일의 위치를 이동하는 시스템 콜 More...
unsigned	tell (int fd)
	열린 파일의 위치를 알려주는 시스템 콜 More...
void	close (int fd)
	열린 파일을 닫는 시스템 콜 More...
void *	mmap (void *addr, size_t length, int writable, int fd, off_t offset)
	열린 파일을 가상 주소 공간에 매핑한다. More...
void	munmap (void *addr)
	mmap으로 매핑된 주소를 해제한다. More...
static int	fdt_add_fd (struct file *f)
	fd table에 해당 파일 저장, fd 생성 More...
static struct file *	fdt_get_file (int fd)
	fd table에서 param fd 검색 More...
static void	fdt_remove_fd (int fd)
	fd table에서 param fd 제거 More...
static void	check_address (void *addr)
	주소 값이 유효한 주소 영역인지 확인 More...
void	syscall_init (void)
void	syscall_handler (struct intr_frame *f UNUSED)
static void	check_buffer (void *buffer, unsigned size, bool writable)

Macro Definition Documentation

MSR_LSTAR

#define MSR_LSTAR   0xc0000082 /* Long mode SYSCALL target */

MSR_STAR

#define MSR_STAR   0xc0000081 /* Segment selector msr */

MSR_SYSCALL_MASK

#define MSR_SYSCALL_MASK   0xc0000084 /* Mask for the eflags */

Typedef Documentation

pid_t

typedef int pid_t

Function Documentation

check_address()

static void check_address ( void *  addr )

static

주소 값이 유효한 주소 영역인지 확인

Null 포인터
매핑되지 않은 가상 메모리에 대한 포인터
커널 가상 주소 공간에 대한 포인터(KERN_BASE)

Parameters

addr

                          {
    struct thread *curr = thread_current();
    if (!is_user_vaddr(addr) || pml4_get_page(curr -> pml4, addr) == NULL || addr == NULL) // 유저 영역인지  NULL 포인터인지 확인
        exit(-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_buffer()

static void check_buffer ( void *  buffer, unsigned  size, bool  writable  )

static

                                                         {
    // struct page* page = check_address(buffer + size);
    for (int i = 0; i < size; i++) {
        struct page* page = check_address(buffer + i); // 하나씩 다 확인
 
        if(page == NULL)
            exit(-1);
        if(!writable && page->writable == false) // true : writable, false : read-only
            exit(-1);
    }
    // if(page == NULL)
    //  exit(-1);
    // if(!writable && page->writable == false) // true : writable, false : read-only
    //  exit(-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

close()

void close

(

int

fd

)

열린 파일을 닫는 시스템 콜

파일을 닫고 fd를 제거한다.

Parameters

fd

              {
    struct file *target_file = fdt_get_file(fd);
 
    if (fd <= STDOUT_FILENO || target_file == NULL || target_file <= 2)
        return;
    
    fdt_remove_fd(fd); // fd table에서 해당 fd값을 제거한다.
 
    file_close(target_file); // 열었던 파일을 닫는다.
}

Here is the call graph for this function:

Here is the caller graph for this function:

create()

bool create	(	const char *	file,
		unsigned	initial_size
	)

파일을 생성하는 시스템 콜

filesys_create (const char *name, off_t initial_size)

Parameters

file	생성할 파일의 이름 및 경로 정보
initial_size	생성할 파일의 크기

Returns

true 성공

false 실패

                                               {
    check_address(file);
    return filesys_create(file, initial_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

exec()

int exec

(

const char *

file

)

cmd_line으로 들어온 실행 파일을 실행한다.

Parameters

file	실행하려는 파일 이름

Returns

int 성공 시 0, 실패 시 -1

                           {
    check_address(file);
 
    int size = strlen(file) + 1; // 파일 사이즈(NULL 포함하기 위해 +1)
    char *fn_copy = palloc_get_page(PAL_ZERO);
 
    if (fn_copy == NULL)// 메모리 할당 불가 시
        exit(-1);
    strlcpy(fn_copy, file, size);
 
    if (process_exec(fn_copy) == -1) // [process_exec] 'load (file_name, &_if);' -> load 실패 시
        return -1;
    
    return 0;
}

Here is the call graph for this function:

exit()

void exit

(

int

status

)

현재 프로세스를 종료시키는 시스템 콜

종료 시 출력 : "${프로세스 명}: exit(${프로세스 상태})\n"
process_exit()에 존재

Parameters

status

정상 종료 시, 0

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

Here is the call graph for this function:

Here is the caller graph for this function:

fdt_add_fd()

static int fdt_add_fd ( struct file *  f )

static

fd table에 해당 파일 저장, fd 생성

Hanyang Univ. process_add_file 각색

Parameters

f	새로 fd를 생성하려는 파일 객체(*file)

Returns

int 성공 시 fd, 실패 시 -1(STDERR_FILENO)

                           {
    struct thread *curr = thread_current();
    struct file **fdt = curr->fdt;
 
    // fd가 제한 범위를 넘지 않고 fdt의 인덱스 위치와 일치 시
    while (curr->next_fd < FDCOUNT_LIMIT && fdt[curr->next_fd]) {
        curr->next_fd++;
    }
 
    // fdt가 가득 찼을 때 return -1
    if (curr->next_fd >= FDCOUNT_LIMIT)
        return -1;
 
    fdt[curr->next_fd] = f; // fdt에 해당 fd 새로 넣어줌
    return curr->next_fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fdt_get_file()

static struct file * fdt_get_file ( int  fd )

static

fd table에서 param fd 검색

Hanyang Univ. process_get_file 각색

Parameters

fd

Returns

struct file* 성공 시 찾은 fd에 대한 파일 객체, 실패 시 NULL

                     {
    struct thread *curr = thread_current();
    if (fd < STDIN_FILENO || fd >= FDCOUNT_LIMIT) { // 실패
        return NULL;
    }
    return curr->fdt[fd]; // 성공
}

Here is the call graph for this function:

Here is the caller graph for this function:

fdt_remove_fd()

static void fdt_remove_fd ( int  fd )

static

fd table에서 param fd 제거

Hanyang Univ. process_close_file 각색

Parameters

fd

                      {
    struct thread *curr = thread_current();
 
    if (fd < STDIN_FILENO || fd >= FDCOUNT_LIMIT) // 실패
        return;
    
    curr->fdt[fd] = NULL; // 성공
}

Here is the call graph for this function:

Here is the caller graph for this function:

filesize()

int filesize

(

int

fd

)

파일의 크기를 알려주는 시스템 콜

Parameters

fd

Returns

int 성공 시 파일 크기, 실패 시 -1

                 {
    struct file *target_file = fdt_get_file(fd);
    if (target_file == NULL)
        return -1;
    return file_length(target_file);
}

Here is the call graph for this function:

fork()

pid_t fork	(	const char *	thread_name,
		struct intr_frame *	f
	)

부모 프로세스로 부터 자식 프로세스를 복제한다.

Parameters

thread_name	새로 생성될 자식 프로세스의 이름
f	부모의 인터럽트 프레임

Returns

pid_t 생성된 자식 프로세스의 pid

                                                           {
    check_address(thread_name);
    return process_fork(thread_name, f);
}

Here is the call graph for this function:

get_argument()

void get_argument	(	void *	rsp,
		int	argc,
		void *	argv[]
	)

halt()

void halt

(

void

)

핀토스 자체를 종료시키는 시스템 콜

           {
    power_off();
}

Here is the call graph for this function:

mmap()

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

열린 파일을 가상 주소 공간에 매핑한다.

Parameters

addr
length
writable
fd
offset

Returns

void*

                                                                          {
 
    /* Return NULL의 경우 
     * CASE 1. `addr` 가 0인 경우
     * CASE 2. `addr` 가 커널 가상 주소인 경우
     * CASE 3. `addr` 가 page-aligned 되지 않은 경우
     * CASE 4. 기존에 매핑된 페이지 집합(stack, 페이지)과 겹치는 경우
     * CASE 5. 읽으려는 파일의 offset 위치가 PGSIZE 보다 큰 경우
     * CASE 6. 읽으려는 파일의 길이가 0보다 작거나 같은 경우
     * CASE 7. STDIN, STDOUT 인 경우
     * CASE 8. 파일 객체가 존재하지 않는 경우
     * CASE 9. fd로 열린 파일의 길이가 0인 경우 */
 
    // CASE 1 - 6
    if (addr == NULL || is_kernel_vaddr(addr) || is_kernel_vaddr(pg_round_up(addr)) || pg_round_down(addr) != addr || spt_find_page(&thread_current()->spt, addr) \
        || offset > PGSIZE \
        || (long) length <= 0) // ? 형 변환 안하면 통과 못함 (Input : 음수)
        return NULL;
        
    /* mmap-kernel TC
     * 
     * kernel = (void *) 0x8004000000 - 0x1000;
     * CHECK (mmap (kernel, -0x8004000000 + 0x1000, 0, handle, 0) == MAP_FAILED,
     * "try to mmap over kernel 2"); */
 
    struct file *file = fdt_get_file(fd);
 
    // CASE 7 - 9
    if (fd <= STDOUT_FILENO || file == NULL || file_length(file) == 0)
        return NULL;
    
    // do_mmap의 4번째 인자가 파일 객체이므로 fd로 부터 파일 객체를 얻은 값을 넣어준다.
    return do_mmap(addr, length, writable, file, offset);
}

Here is the call graph for this function:

munmap()

void munmap

(

void *

addr

)

mmap으로 매핑된 주소를 해제한다.

Parameters

addr

                        {
    do_munmap(addr);
}

Here is the call graph for this function:

open()

int open

(

const char *

file

)

파일을 열 때 사용하는 시스템 콜

Parameters

file	파일의 이름 및 경로 정보

Returns

int 성공 시 fd, 실패 시 -1

                       {
    check_address(file);
    lock_acquire(&filesys_lock);
    struct file *target_file = filesys_open(file);
 
    if (target_file == NULL) {
        return -1;
    }
    int fd = fdt_add_fd(target_file); // fdt : file data table
 
    // fd table이 가득 찼다면
    if (fd == -1) {
        file_close(target_file);
    }
    lock_release(&filesys_lock);
    return fd;
}

Here is the call graph for this function:

read()

int read	(	int	fd,
		void *	buffer,
		unsigned	size
	)

열린 파일의 데이터를 읽는 시스템 콜

Parameters

fd
buffer	읽은 데이터를 저장할 버퍼의 주소 값
length	읽을 데이터 크기

Returns

int

                                          {
    int read_bytes = -1;
 
    if(fd == STDIN_FILENO){ // fd 0 reads from the keyboard using input_getc()._gitbook
        int i;
        unsigned char *buf = buffer;
            
        for (i = 0; i < size; i++)
        {
            char c = input_getc();
            *buf++ = c;
            if (c == '\0')
                break;
        }
        return i;
 
    }
    else{
        struct file *file = fdt_get_file(fd);
        if (file != NULL && fd != STDOUT_FILENO){ // STDOUT_FILENO 
            lock_acquire(&filesys_lock); // 파일을 읽는 동안은 접근 못하게 락 걸어줌
            read_bytes = file_read(file, buffer, size);
            lock_release(&filesys_lock); // 락 해제
        }
    }
    return read_bytes;
}

Here is the call graph for this function:

remove()

bool remove

(

const char *

file

)

파일을 샂게하는 시스템 콜

Parameters

file	제거할 파일의 이름 및 경로 정보

Returns

true 성공

false 실패

                        {
    check_address(file);
    return filesys_remove(file);
}

Here is the call graph for this function:

seek()

void seek	(	int	fd,
		unsigned	position
	)

열린 파일의 위치를 이동하는 시스템 콜

Parameters

fd
position	현재 위치(offset)를 기준으로 이동할 거리

                                {
    struct file *target_file = fdt_get_file(fd);
 
    if (fd <= STDOUT_FILENO || target_file == NULL)
        return;
    
    file_seek(target_file, position);
}

Here is the call graph for this function:

syscall_entry()

void syscall_entry

(

void

)

Here is the caller graph for this function:

syscall_handler() [1/2]

void syscall_handler

(

struct intr_frame *

)

syscall_handler() [2/2]

void syscall_handler

(

struct intr_frame *f

UNUSED

)

                                              {
    // TODO: Your implementation goes here.
    struct thread *curr = thread_current();
    switch (f->R.rax) // 시스템 콜 번호에 따라 분기
    {
    case SYS_HALT:
        halt ();
        break;
    case SYS_EXIT:
        exit (f->R.rdi);
        break;
    case SYS_FORK:
        f->R.rax = fork (f->R.rdi, f);
        break;
    case SYS_EXEC:
        if (exec (f->R.rdi) == -1)
            exit (-1);
        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_REMOVE:
        f->R.rax = remove (f->R.rdi);
        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:
        check_buffer(f->R.rsi, f->R.rdx, 0);
        f->R.rax = read (f->R.rdi, f->R.rsi, f->R.rdx);
        break;
    case SYS_WRITE:
        check_buffer(f->R.rsi, f->R.rdx, 1);
        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;
    case SYS_MMAP:
        f->R.rax = mmap(f->R.rdi, f->R.rsi, f->R.rdx, f->R.r10, f->R.r8);
        break;
    case SYS_MUNMAP:
        munmap(f->R.rdi);
        break;
    default:
        exit (-1);
        break;
    }
    // printf ("system call!\n");
    // thread_exit ();
}

Here is the call graph for this function:

syscall_init()

void syscall_init

(

void

)

                    {
    write_msr(MSR_STAR, ((uint64_t)SEL_UCSEG - 0x10) << 48  |
            ((uint64_t)SEL_KCSEG) << 32);
    write_msr(MSR_LSTAR, (uint64_t) syscall_entry);
 
    /* The interrupt service rountine should not serve any interrupts
     * until the syscall_entry swaps the userland stack to the kernel
     * mode stack. Therefore, we masked the FLAG_FL. */
    write_msr(MSR_SYSCALL_MASK,
            FLAG_IF | FLAG_TF | FLAG_DF | FLAG_IOPL | FLAG_AC | FLAG_NT);
    
    /*------------------------- [P2] System Call --------------------------*/   
    lock_init(&filesys_lock); // 파일 읽고 쓰기에 필요한 락 초기화 _defined "userprog/syscall.h"
}

Here is the call graph for this function:

Here is the caller graph for this function:

tell()

unsigned tell

(

int

fd

)

열린 파일의 위치를 알려주는 시스템 콜

Parameters

fd

Returns

unsigned 성공 시 파일의 위치(offset), 실패 시 -1

             {
    struct file *target_file = fdt_get_file(fd);
 
    if (fd <= STDOUT_FILENO || target_file == NULL)
        return;
 
    file_tell(target_file);
}

Here is the call graph for this function:

wait()

int wait

(

tid_t

pid

)

pid에 해당하는 자식 프로세스가 종료될 때까지 기다린다.

Parameters

pid	기다리려는 자식 프로세스의 pid

Returns

int 성공 시 자식 프로세스의 종료 상태, 실패 시 -1

                    {
    process_wait(pid);
}

Here is the call graph for this function:

write()

int write	(	int	fd,
		const void *	buffer,
		unsigned	size
	)

열린 파일에 데이터를 쓰는 시스템 콜

Parameters

fd
buffer
size

Returns

int

                                                  {
    int write_bytes = -1;
 
    if (fd == STDOUT_FILENO){
        putbuf (buffer, size);
        return size;
    }
    else {
        struct file *file = fdt_get_file(fd);
        if (file != NULL && fd != STDIN_FILENO){ // STDIN_FILENO
            lock_acquire(&filesys_lock); // 파일을 쓰는 동안은 접근 못하게 락 걸어줌
            write_bytes = file_write(file, buffer, size);
            lock_release(&filesys_lock); // 락 해제
        }
    }
    return write_bytes;
}

Here is the call graph for this function:

Here is the caller graph for this function: