syscall.h File Reference

#include <stdbool.h>
#include <debug.h>
#include <stddef.h>

Include dependency graph for syscall.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PID_ERROR   ((pid_t) -1)
#define	MAP_FAILED   ((void *) NULL)
#define	READDIR_MAX_LEN   14
#define	EXIT_SUCCESS   0 /* Successful execution. */
#define	EXIT_FAILURE   1 /* Unsuccessful execution. */

Typedefs
typedef int	pid_t
typedef int	off_t

Functions
void	halt (void) NO_RETURN
	핀토스 자체를 종료시키는 시스템 콜 More...
void	exit (int status) NO_RETURN
	현재 프로세스를 종료시키는 시스템 콜 More...
pid_t	fork (const char *thread_name)
int	exec (const char *file)
	cmd_line으로 들어온 실행 파일을 실행한다. More...
int	wait (pid_t)
	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 length)
	열린 파일의 데이터를 읽는 시스템 콜 More...
int	write (int fd, const void *buffer, unsigned length)
	열린 파일에 데이터를 쓰는 시스템 콜 More...
void	seek (int fd, unsigned position)
	열린 파일의 위치를 이동하는 시스템 콜 More...
unsigned	tell (int fd)
	열린 파일의 위치를 알려주는 시스템 콜 More...
void	close (int fd)
	열린 파일을 닫는 시스템 콜 More...
int	dup2 (int oldfd, int newfd)
void *	mmap (void *addr, size_t length, int writable, int fd, off_t offset)
	열린 파일을 가상 주소 공간에 매핑한다. More...
void	munmap (void *addr)
	mmap으로 매핑된 주소를 해제한다. More...
bool	chdir (const char *dir)
bool	mkdir (const char *dir)
bool	readdir (int fd, char name[READDIR_MAX_LEN+1])
bool	isdir (int fd)
int	inumber (int fd)
int	symlink (const char *target, const char *linkpath)
static void *	get_phys_addr (void *user_addr)
static long long	get_fs_disk_read_cnt (void)
static long long	get_fs_disk_write_cnt (void)

Macro Definition Documentation

EXIT_FAILURE

#define EXIT_FAILURE   1 /* Unsuccessful execution. */

EXIT_SUCCESS

#define EXIT_SUCCESS   0 /* Successful execution. */

MAP_FAILED

#define MAP_FAILED   ((void *) NULL)

PID_ERROR

#define PID_ERROR   ((pid_t) -1)

READDIR_MAX_LEN

#define READDIR_MAX_LEN   14

Typedef Documentation

off_t

typedef int off_t

pid_t

typedef int pid_t

Function Documentation

chdir()

bool chdir

(

const char *

dir

)

                        {
    return syscall1 (SYS_CHDIR, dir);
}

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:

dup2()

int dup2	(	int	oldfd,
		int	newfd
	)

                           {
    return syscall2 (SYS_DUP2, oldfd, newfd);
}

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:

Here is the caller 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:

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:

Here is the caller graph for this function:

fork()

pid_t fork

(

const char *

thread_name

)

                              {
    return (pid_t) syscall1 (SYS_FORK, thread_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_fs_disk_read_cnt()

static long long get_fs_disk_read_cnt ( void  )

inlinestatic

                            {
    long long read_cnt;
    asm volatile ("movq $0, %rdx");
    asm volatile ("movq $1, %rcx");
    asm volatile ("int $0x43");
    asm volatile ("\t movq %%rax, %0": "=r" (read_cnt));
    return read_cnt;
}

get_fs_disk_write_cnt()

static long long get_fs_disk_write_cnt ( void  )

inlinestatic

                             {
    long long write_cnt;
    asm volatile ("movq $0, %rdx");
    asm volatile ("movq $1, %rcx");
    asm volatile ("int $0x44");
    asm volatile ("\t movq %%rax, %0": "=r" (write_cnt));
    return write_cnt;
}

get_phys_addr()

static void * get_phys_addr ( void *  user_addr )

inlinestatic

                                                    {
    void* pa;
    asm volatile ("movq %0, %%rax" ::"r"(user_addr));
    asm volatile ("int $0x42");
    asm volatile ("\t movq %%rax, %0": "=r" (pa));
    return pa;
}

halt()

void halt

(

void

)

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

           {
    power_off();
}

Here is the call graph for this function:

Here is the caller graph for this function:

inumber()

int inumber

(

int

fd

)

                 {
    return syscall1 (SYS_INUMBER, fd);
}

isdir()

bool isdir

(

int

fd

)

               {
    return syscall1 (SYS_ISDIR, fd);
}

mkdir()

bool mkdir

(

const char *

dir

)

                        {
    return syscall1 (SYS_MKDIR, dir);
}

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:

Here is the caller graph for this function:

munmap()

void munmap

(

void *

addr

)

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

Parameters

addr

                        {
    do_munmap(addr);
}

Here is the call graph for this function:

Here is the caller 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:

Here is the caller 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:

Here is the caller graph for this function:

readdir()

bool readdir	(	int	fd,
		char	name[READDIR_MAX_LEN+1]
	)

                                                 {
    return syscall2 (SYS_READDIR, fd, name);
}

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:

Here is the caller 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:

Here is the caller graph for this function:

symlink()

int symlink	(	const char *	target,
		const char *	linkpath
	)

                                                   {
    return syscall2 (SYS_SYMLINK, target, linkpath);
}

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:

Here is the caller 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:

Here is the caller 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: