1
typedef struct interrupt_frame
2
{
3
    /* 手动压入的段寄存器 */
4
    uint32_t gs, fs, es, ds;
5

6
    /* pusha 压入的通用寄存器 */
7
    uint32_t edi, esi, ebp, esp_dummy, ebx, edx, ecx, eax;
8

9
    /* stub 压入的：中断号和错误码 */
10
    uint32_t int_no, err_code;
11

12
    /* CPU 自动压入的 */
13
    uint32_t eip, cs, eflags;
14

15
    /* 仅在特权级变化时压入 */
16
    uint32_t useresp, ss;
17
} interrupt_frame_t;

1
void syscall_init(void)
2
{
3
    // 清空系统调用表
4
    for (int i = 0; i < SYSCALL_COUNT; i++) syscall_table[i] = NULL;
5

6
    // 注册所有系统调用
7
    syscall_table[SYS_EXIT]    = (syscall_handler_t)sys_exit;
8
    syscall_table[SYS_READ]    = (syscall_handler_t)sys_read;
9
    syscall_table[SYS_WRITE]   = (syscall_handler_t)sys_write;
10
    syscall_table[SYS_YIELD]   = (syscall_handler_t)sys_yield;
11
    syscall_table[SYS_GETPID]  = (syscall_handler_t)sys_getpid;
12
    syscall_table[SYS_SLEEP]   = (syscall_handler_t)sys_sleep;
13
    syscall_table[SYS_PUTS]    = (syscall_handler_t)sys_puts;
14
    syscall_table[SYS_GETTID]  = (syscall_handler_t)sys_gettid;
15
    syscall_table[SYS_OPEN]    = (syscall_handler_t)sys_open;
16
    syscall_table[SYS_CLOSE]   = (syscall_handler_t)sys_close;
17
    syscall_table[SYS_MKDIR]   = (syscall_handler_t)sys_mkdir_sc;
18
    syscall_table[SYS_READDIR] = (syscall_handler_t)sys_readdir_sc;
19
    syscall_table[SYS_GETCWD]  = (syscall_handler_t)sys_getcwd;
20
    syscall_table[SYS_CHDIR]   = (syscall_handler_t)sys_chdir;
21
    syscall_table[SYS_FORK]    = (syscall_handler_t)sys_fork;
22
    syscall_table[SYS_EXEC]    = (syscall_handler_t)sys_exec;
23
    syscall_table[SYS_WAIT]    = (syscall_handler_t)sys_wait;
24
    syscall_table[SYS_UPTIME]  = (syscall_handler_t)sys_uptime;
25
    syscall_table[SYS_GETCHAR] = (syscall_handler_t)sys_getchar;
26
    syscall_table[SYS_PS]      = (syscall_handler_t)sys_ps;
27

28
    // 注册系统调用中断处理程序到 IDT
29
    register_interrupt_handler(0x80, syscall_handler);
30

31
    vga_printf("[Syscall] Initialized (%d syscalls)\n", SYSCALL_COUNT);
32
}

1
void syscall_handler(interrupt_frame_t *frame)
2
{
3
    // 从寄存器中提取参数
4
    uint32_t num = frame->eax;    // 系统调用号
5
    uint32_t a1 = frame->ebx;     // 第一个参数
6
    uint32_t a2 = frame->ecx;     // 第二个参数
7
    uint32_t a3 = frame->edx;     // 第三个参数
8
    int ret = -1;                 // 默认返回值（错误）
9

10
    // 检查调用号是否合法，并调用对应的函数
11
    if (num < SYSCALL_COUNT && syscall_table[num])
12
        ret = syscall_table[num](a1, a2, a3);
13

14
    // 将返回值写回 eax，用户程序可以通过 eax 获取返回值
15
    frame->eax = (uint32_t)ret;
16
}

1
int sys_write(int fd, const void *buf, uint32_t count)
2
{
3
    // 特殊处理标准输出（fd=1）和标准错误（fd=2）
4
    if (fd == 1 || fd == 2) {
5
        const char *str = (const char *)buf;
6
        for (uint32_t i = 0; i < count; i++)
7
            vga_putc(str[i]);
8
        return (int)count;
9
    }
10

11
    // 普通文件写入
12
    return (int)fs_write(fd, buf, count);
13
}

1
int sys_read(int fd, void *buf, uint32_t count)
2
{
3
    return (int)fs_read(fd, buf, count);
4
}

1
int sys_getpid(void)
2
{
3
    process_t *proc = current_process();
4
    return proc ? (int)proc->pid : 0;
5
}
6

7
int sys_gettid(void)
8
{
9
    task_t *t = current_task();
10
    return t ? (int)t->tid : 0;
11
}
12

13
int sys_fork(void)
14
{
15
    return sys_fork_impl();
16
}
17

18
int sys_exec(const char *path)
19
{
20
    return sys_exec_impl(path);
21
}
22

23
int sys_wait(int *status)
24
{
25
    return sys_wait_impl(status);
26
}

1
static void syscall_test_task(void *arg)
2
{
3
    (void)arg;
4

5
    vga_printf("\n--- System Call Test ---\n\n");
6

7
    /* 测试进程/线程 ID */
8
    int pid = sys_getpid();
9
    int tid = sys_gettid();
10
    vga_printf("sys_getpid() = %d\n", pid);
11
    vga_printf("sys_gettid() = %d\n", tid);
12

13
    /* 测试 uptime */
14
    int up = sys_uptime();
15
    vga_printf("sys_uptime() = %d seconds\n", up);
16

17
    /* 测试 puts */
18
    vga_printf("sys_puts(): ");
19
    sys_puts("Hello from syscall!\n");
20

21
    /* 测试 write(stdout) */
22
    const char *msg = "sys_write(1, ...): works!\n";
23
    sys_write(1, msg, strlen(msg));
24

25
    /* 测试文件操作 */
26
    vga_printf("\n--- File Syscalls ---\n");
27

28
    sys_mkdir_sc("/test", FS_PERM_READ | FS_PERM_WRITE);
29
    vga_printf("Created /test directory\n");
30

31
    int fd = sys_open("/test/data.txt", FS_OPEN_WRITE | FS_OPEN_CREATE);
32
    if (fd >= 0) {
33
        const char *data = "Syscall file content\n";
34
        sys_write(fd, data, strlen(data));
35
        sys_close(fd);
36
        vga_printf("Wrote to /test/data.txt\n");
37
    }
38

39
    fd = sys_open("/test/data.txt", FS_OPEN_READ);
40
    if (fd >= 0) {
41
        char buf[64];
42
        memset(buf, 0, 64);
43
        int n = sys_read(fd, buf, 63);
44
        sys_close(fd);
45
        vga_printf("Read %d bytes: %s", n, buf);
46
    }
47

48
    /* 测试 yield */
49
    vga_printf("\nTesting yield (3 times)...\n");
50
    for (int i = 0; i < 3; i++) {
51
        vga_printf("  Before yield %d\n", i);
52
        sys_yield();
53
        vga_printf("  After yield %d\n", i);
54
    }
55

56
    vga_printf("\n=== All Syscall Tests Passed ===\n");
57
    while (1) schedule_yield();
58
}