1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
tid_t process_create_initd(const char *file_name)
{
    char *fn_copy;
	tid_t tid;
    char *save_ptr;

	fn_copy = palloc_get_page (0);
	if (fn_copy == NULL)
		return TID_ERROR;
	strlcpy (fn_copy, file_name, PGSIZE);

    file_name = strtok_r (file_name, " ", &save_ptr);
    tid = thread_create (file_name, PRI_DEFAULT, initd, fn_copy);

	if (tid == TID_ERROR)
		palloc_free_page (fn_copy);
	return tid;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
int process_exec (void *f_name) {
	char *file_name = f_name;
	bool success;
    char *arg_list[128];
    char *token, *save_ptr;
    int token_count = 0;

    token = strtok_r(file_name, " ", &save_ptr);
    arg_list[token_count] = token;

    while(token!=NULL){
        token = strtok_r(NULL, " ", &save_ptr);
        token_count++;
        arg_list[token_count] = token;
    }

	struct intr_frame _if;
	_if.ds = _if.es = _if.ss = SEL_UDSEG;
	_if.cs = SEL_UCSEG;
	_if.eflags = FLAG_IF | FLAG_MBS;

	process_cleanup ();

	success = load (file_name, &_if);

	if (!success) {
        palloc_free_page (file_name);
        return -1;
    }
    argument_stack(arg_list, token_count, &_if);
	do_iret (&_if);
	NOT_REACHED ();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void argument_stack(char **argv, int argc, struct intr_frame *if_){
    char *arg_address[128];

    for(int i = argc - 1; i >= 0; i--){
        int argv_with_senti_len = strlen(argv[i]) + EOL;
        if_->rsp -= (argv_with_senti_len);
        memcpy(if_->rsp, argv[i], argv_with_senti_len);
        arg_address[i] = if_->rsp;
    }
    while(if_->rsp % SAU != 0){
        if_->rsp--;
        memset(if_->rsp, 0, sizeof(uint8_t));
    }

    for(int j = argc; j >= 0; j--){
        if_->rsp -= SAU;
        if(j == argc){
            memset(if_->rsp, 0, sizeof(char **));
        } else{
            memcpy(if_->rsp, &arg_address[j], sizeof(char **));
        }
    }

    if_->rsp -= sizeof(void *);
    memset(if_->rsp, 0, sizeof(void *));

    if_->R.rdi = argc;
    if_->R.rsi = if_->rsp + SAU;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
struct page* check_address(void *addr) {
    struct thread *curr = thread_current();

    if(!is_user_vaddr(addr) || addr == NULL){
		exit(-1);
	}

	#ifdef VM
	if(pml4_get_page (&thread_current()->pml4, addr) == NULL)
		if (spt_find_page(&thread_current()->spt, addr) == NULL)
			exit(-1);
	#endif
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
void syscall_handler (struct intr_frame *f UNUSED) {

    thread_current()->rsp_stack = f->rsp;

    int sys_number = f -> R.rax;
    switch(sys_number){
        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:
            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:
            exit(-1);
            break;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void halt(void){
    power_off();
}

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

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

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
struct thread {

	tid_t tid;
	enum thread_status status;
	char name[16];
	int priority;

    int64_t wakeup_tick;

    struct list_elem elem;


    int init_priority;
    struct lock *wait_on_lock;
    struct list donations;
    struct list_elem donation_elem;

    int exit_status;

    struct intr_frame parent_if;

    struct list child_list;
    struct list_elem child_elem;

    struct semaphore wait_sema;
    struct semaphore fork_sema;
    struct semaphore free_sema;

    struct file **fd_table;
    int fd_idx;

    int stdin_count;
    int stdout_count;

    struct file *running;

#ifdef USERPROG
	uint64_t *pml4;
#endif
#ifdef VM
	struct supplemental_page_table spt;
#endif

	struct intr_frame tf;
	unsigned magic;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static void init_thread(struct thread *t, const char *name, int priority) {
    ASSERT(t != NULL);
    ASSERT(PRI_MIN <= priority && priority <= PRI_MAX);
    ASSERT(name != NULL);

    memset(t, 0, sizeof *t);
    t->status = THREAD_BLOCKED;
    strlcpy(t->name, name, sizeof t->name);
    t->tf.rsp = (uint64_t) t + PGSIZE - sizeof(void *);
    t->priority = priority;
    t->magic = THREAD_MAGIC;

    t -> init_priority = priority;
    list_init(&t->donations);
    t -> wait_on_lock = NULL;

    list_init(&t->child_list);

    sema_init(&t->wait_sema, 0);
    sema_init(&t->fork_sema, 0);
    sema_init(&t->free_sema, 0);

    t->exit_status = 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
tid_t thread_create(const char *name, int priority, thread_func *function, void *aux) {
    struct thread *t;

    struct thread *now_running = thread_current();

    tid_t tid;

    ASSERT(function != NULL);

    t = palloc_get_page(PAL_ZERO);
    if (t == NULL)
        return TID_ERROR;

    init_thread(t, name, priority);
    tid = t->tid = allocate_tid();

    list_push_back(&now_running->child_list,&t->child_elem); // parent child 리스트에 생성한 child를 담는다

    t->fd_table = palloc_get_multiple(PAL_ZERO, FDT_PAGES);
    if(t->fd_table == NULL)
        return TID_ERROR;

    t->fd_table[0] = 1;
    t->fd_table[1] = 2;
    t->fd_idx = 2;

    t->stdin_count = 1;
    t->stdout_count = 1;

    t->tf.rip = (uintptr_t) kernel_thread;
    t->tf.R.rdi = (uint64_t) function;
    t->tf.R.rsi = (uint64_t) aux;
    t->tf.ds = SEL_KDSEG;
    t->tf.es = SEL_KDSEG;
    t->tf.ss = SEL_KDSEG;
    t->tf.cs = SEL_KCSEG;
    t->tf.eflags = FLAG_IF;

    thread_unblock(t);
    if (cmp_priority(&t->elem, &now_running->elem, 0)) {
            thread_yield();
    }
    return tid;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct thread *get_child(int pid){

    struct thread *curr = thread_current();
    struct list *child_list = &curr->child_list;
    struct list_elem *e;
    if (list_empty(child_list)) return NULL;
    for (e = list_begin (child_list); e != list_end (child_list); e = list_next (e)){
        struct thread *t = list_entry(e, struct thread, child_elem);
        if (t->tid == pid){
            return t;
        }
    }
    return NULL;
}

1
2
3
4
5
void remove_child(struct thread *cp)
  {
  	list_remove(&cp->child_elem);
  	free(*cp);
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 int exec(const *cmd_line)
  {
  	struct thread *curr = thread_current();
  	tid_t pid = process_create_initd(cmd_line);

  	struct thread *child = get_child_process(pid);
  	int result = process_wait(child);
  	list_push_back(&curr->children_list, &child->child_elem);

  	if (result = 1)
  	{
  		return pid;
  	}
  	else
  	{
  		return -1;
  	}
  }

1
2
3
int wait(tid_t pid){
    return process_wait(pid);
}

1
2
3
4
5
6
7
struct thread{
    ...
    struct file **fd_table;
    int fd_idx;
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
tid_t thread_create(const char *name, int priority, thread_func *function, void *aux){

    ...

    t->fd_table = palloc_get_multiple(PAL_ZERO, FDT_PAGES);
    if(t->fd_table == NULL)
        return TID_ERROR;

    t->fd_table[0] = 1;
    t->fd_table[1] = 2;
    t->fd_idx = 2; // idx 2로 초기화

    //count 초기화
    t->stdin_count = 1;
    t->stdout_count = 1;

    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int add_file_to_fdt(struct file *file) {
    struct thread *curr = thread_current();
    struct file **fdt = curr->fd_table;

    while (curr->fd_idx < FDCOUNT_LIMIT && fdt[curr->fd_idx])
    {
        curr->fd_idx++;
    }

    if (curr->fd_idx >= FDCOUNT_LIMIT)
        return -1;

    fdt[curr->fd_idx] = file;
    return curr->fd_idx;
}

1
2
3
4
5
6
7
8
9
static struct file *find_file_by_fd(int fd) {
    if (fd < 0 || fd >= FDCOUNT_LIMIT){
        return NULL;
    }

    struct thread *curr = thread_current();

    return curr->fd_table[fd];
}

1
2
3
4
5
6
7
void remove_file_from_fdt(int fd) {
    struct thread *cur = thread_current();
    if (fd < 0 || fd >= FDCOUNT_LIMIT){
        return;
    }
    cur->fd_table[fd] = NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void process_exit (void) {
	struct thread *curr = thread_current ();

    for (int i=0; i<FDCOUNT_LIMIT; i++)
    {
        close(i);
    }
    palloc_free_multiple(curr->fd_table, FDT_PAGES);
    file_close(curr->running);

    sema_up(&curr->wait_sema);
    sema_down(&curr->free_sema);

    process_cleanup ();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int open(const char *file){
    check_address(file);
    lock_acquire(&filesys_lock);

    struct file *file_obj = filesys_open(file);

    if (file_obj == NULL){
        return -1;
    }

    int fd = add_file_to_fdt(file_obj);

    if(fd == -1){
        file_close(file_obj);
    }

    lock_release(&filesys_lock);
    return fd;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int read(int fd, void *buffer, unsigned size){
    check_address(buffer);
    int read_count;

    struct file *file_obj = find_file_by_fd(fd);
    unsigned char *buf = buffer;

    if (file_obj == NULL){
        return -1;
    }

    if(file_obj == STDIN){
        char key;
        for (int read_count = 0; read_count < size; read_count++){
            key = input_getc();
            *buf++ = key;
            if (key == '\0'){
                break;
            }
        }
    }else if (file_obj == STDOUT){
        return -1;
    } else {
        lock_acquire(&filesys_lock);
        read_count = file_read(file_obj, buffer, size);
        lock_release(&filesys_lock);
    }

    return read_count;
}

1
2
3
4
5
6
7
8
int filesize(int fd){
    struct file *file_obj = find_file_by_fd(fd);

    if (file_obj == NULL){
        return -1;
    }
    return file_length(file_obj);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int write(int fd, void *buffer, unsigned size){
    check_address(buffer);
    int read_count;
    struct file *file_obj = find_file_by_fd(fd);

    if (file_obj == NULL){
        return -1;
    }

    if(file_obj == STDOUT){
        putbuf(buffer, size);
        read_count = size;
    } else if (file_obj == STDIN){
        return -1;
    } else{
        lock_acquire(&filesys_lock);
        read_count = file_write(file_obj, buffer, size);
        lock_release(&filesys_lock);
    }
    return read_count;
}

1
2
3
4
tid_t fork (const char *thread_name, struct intr_frame *f) {
    check_address(thread_name);
    return process_fork(thread_name, f);
}

1
2
3
4
5
6
7
void seek(int fd, unsigned position){
    struct file *file_obj = find_file_by_fd(fd);
    if (fd < 2){
        return;
    }
    file_seek(file_obj, position);
}

1
2
3
4
5
6
7
unsigned tell(int fd){
    struct file *file_obj = find_file_by_fd(fd);
    if (fd < 2){
        return;
    }
    return file_tell(file_obj);
}

1
2
3
4
5
6
7
8
9
void close(int fd){
    if (fd <= 1) return;
    struct file *file_obj = find_file_by_fd(fd);

    if (file_obj == NULL){
        return;
    }
    remove_file_from_fdt(fd);
}