int practice (int i)

void halt (void)

void exit (int status)

pid_t exec (const char *cmd_line)

int wait (pid_t pid)

while (token = strtok_r(cli, " ", &cli))
{
	// token就是分隔好的字符串
}

// 将参数压入栈
void process_push_args(const char *cli, void **if_esp)
{
    void *esp = *if_esp;
    int argc = 0;
    char *argv[64];
    int args_size = 0;

    unsigned int cli_size = strlen(cli) + 1;
    char *cli_copy = malloc(cli_size);
    strlcpy(cli_copy, cli, cli_size);

    // argv[...][...]
    char *token = NULL;
    while (token = strtok_r(cli_copy, " ", &cli_copy))
    {
        int size = strlen(token) + 1;
        esp -= size;
        argv[argc] = esp;
        strlcpy(esp, token, size);
        args_size += size;
        argc++;
    }
    // stack-align
    args_size = args_size + sizeof(char *) * (argc + 1) + sizeof(char **) + sizeof(int);
    int temp = args_size % 0x10;
    if (temp > 0)
    {
        int align_size = 0x10 - temp;
        esp -= align_size;
        memset(esp, 0, align_size);
    }
    // argv end
    esp -= 0x04;
    *(char **)esp = 0;
    // argv[0]...
    for (int i = argc - 1; i >= 0; i--)
    {
        esp -= sizeof(char *);
        *(char **)esp = argv[i];
    }
    // argv ptr
    esp -= 0x04;
    *(char ***)esp = (esp + 0x04);
    // argc
    esp -= 0x04;
    *(int *)esp = argc;
    // return address
    esp -= 0x04;
    *(int *)esp = 0;

    *if_esp = esp;
}

// debug 打印堆栈中的参数信息
void process_debug_print_argument_stack(void)
{
    void *esp = 0xbfffffc0;
    const int offset = 0xfc0;
    const int show_size = 1 << 6;

    void *upage = pg_round_down(esp);

    printf("(DEBUG): Print Argument Stack\n");
    hex_dump((uintptr_t)upage + offset, upage + offset, show_size, true);
    printf("(DEBUG): end\n");
}

bool is_validity(uint32_t *return_ptr, const void *uaddr)
{
	// 检查是否是用户的内存空间，检查是否为空指针
    if (!is_user_vaddr(uaddr) || (pagedir_get_page(process_current()->pagedir, uaddr) == NULL))
    {
        syscall_exception_exit(return_ptr);
        return false;
    }

    return true;
}

#define SYSCALL_COUNT 31
static void (*syscall_list[SYSCALL_COUNT])(uint32_t *return_ptr, uint32_t *args_stack);

// ...

static void syscall_handler(struct intr_frame *f UNUSED)
{
    uint32_t *args_stack = ((uint32_t *)f->esp);
    uint32_t *return_ptr = &f->eax;
    // 判断syscall_type的地址是否合法
    is_validity(return_ptr, args_stack);
    // 判断第一个参数地址是否合法
    is_validity(return_ptr, args_stack + 1);

    int syscall_type = args_stack[0];
    if (syscall_type < 0 || syscall_type > SYSCALL_COUNT)
    {
        syscall_exception_exit(return_ptr);
    }
    syscall_list[syscall_type](return_ptr, args_stack);
}

struct thread_node
{
    struct list_elem elem;      // 给list用的
    tid_t current_tid;          // 当前线程tid
    tid_t parent_tid;           // 父线程tid
    int ret_status;             // 线程返回值
    struct semaphore exit_sema; // 退出信号量
    struct semaphore load_sema; // 加载信号量
    bool is_already_wait;       // 是否已经等待过
    bool is_load_success;       // 是否加载成功
};

// threads/start.s
// line 150

// orl $CR0_PE | CR0_PG | CR0_WP | CR0_EM, %eax
orl $CR0_PE | CR0_PG | CR0_WP, %eax

// threads/interrupt.h
#define FPU_SIZE 108
struct intr_frame
{
	// ...
    uint8_t fp_regs[FPU_SIZE]; // 添加浮点寄存器
    // ...
}

// threads/intr-stubs.s
.func intr_entry
intr_entry:
	/* 新加的保存fpu状态 */
    subl $FPU_SIZE, %esp
    fsave (%esp)
    
	pushl %ds
	pushl %es
	pushl %fs
	pushl %gs
	pushal

	cld
	mov $SEL_KDSEG, %eax
	mov %eax, %ds
	mov %eax, %es
	leal 56(%esp), %ebp

	pushl %esp
.globl intr_handler
	call intr_handler
	addl $4, %esp
.endfunc

.globl intr_exit
.func intr_exit
intr_exit:
	popal
	popl %gs
	popl %fs
	popl %es
	popl %ds
    /* 新加的恢复fpu状态 */
    frstor (%esp)
    addl $FPU_SIZE, %esp
	addl $12, %esp
	iret
.endfunc

// threads/switch.h
#define FPU_SIZE 108
// ...
struct switch_threads_frame
{
	// ...
    uint8_t fp_regs[FPU_SIZE]; // fpu状态
    // ...
};
// ...
// 因为加了108字节的fpu状态，所以就+108
#define SWITCH_CUR 128
#define SWITCH_NEXT 132

// threads/switch.s
.globl switch_threads
.func switch_threads
switch_threads:
	/* 新加的保存fpu状态 */
	subl $FPU_SIZE, %esp
    fsave (%esp)
	pushl %ebx
	pushl %ebp
	pushl %esi
	pushl %edi

.globl thread_stack_ofs
	mov thread_stack_ofs, %edx
	
	movl SWITCH_CUR(%esp), %eax
	movl %esp, (%eax,%edx,1)

	movl SWITCH_NEXT(%esp), %ecx
	movl (%ecx,%edx,1), %esp

	popl %edi
	popl %esi
	popl %ebp
	popl %ebx
	/* 恢复fpu状态 */
	frstor (%esp)
    addl $FPU_SIZE, %esp
    
    ret
.endfunc

.globl switch_entry
.func switch_entry
switch_entry:
	/* 初始化fpu */
	finit

	addl $8, %esp
	pushl %eax
.globl thread_switch_tail
	call thread_switch_tail
	addl $4, %esp
	ret
.endfunc

// userprog/process.c
static void start_process(void *cli_)
{
    // ...
	// 加在最后，导入fpu状态
    asm("fsave (%0)" : : "g"(&if_.fp_regs));
    /* Start the user process by simulating a return from an
       interrupt, implemented by intr_exit (in
       threads/intr-stubs.S).  Because intr_exit takes all of its
       arguments on the stack in the form of a `struct intr_frame',
       we just point the stack pointer (%esp) to our stack frame
       and jump to it. */
    asm volatile("movl %0, %%esp; jmp intr_exit" : : "g"(&if_) : "memory");
    NOT_REACHED();
}

// lib/float.h

static inline void fpu_push(int num)
{
    unsigned char fpu[108];
    // 内联asm获取fpu状态
    asm("fsave %0;" : : "m"(fpu));
    // 获取栈顶
    int status_word = fpu[4];
    // 将数字压入
    fpu[28 + status_word * 10] = (float)num;
    // 确保status_word在0-7中循环
    if (status_word == 7)
    {
        status_word = 0;
    }
    else
    {
        ++status_word;
    }
    fpu[4] = status_word;
    // 存入fpu
    asm("frstor %0;" : : "m"(fpu));
}

// 差不多就不写注释了
static inline int fpu_pop(void)
{
    int val;
    unsigned char fpu[108];
    asm("fsave %0;" : : "m"(fpu));
    int status_word = fpu[4];
    if (status_word == 0)
    {
        status_word = 7;
    }
    else
    {
        status_word--;
    }
    val = fpu[28 + status_word * 10];
    fpu[4] = status_word;
    asm("frstor %0;" : : "m"(fpu));
    return val;
}