1
/* 进程状态 */
2
typedef enum {
3
    PROC_RUNNING,     /* 正在运行 */
4
    PROC_READY,       /* 就绪 */
5
    PROC_BLOCKED,     /* 阻塞 */
6
    PROC_ZOMBIE,      /* 僵尸态 */
7
    PROC_EXITED       /* 已退出 */
8
} process_state_t;
9

10
/* 用户空间布局常量 */
11
#define USER_STACK_TOP    0xBFFFF000   /* 用户栈顶部 (3GB - 4KB) */
12
#define USER_STACK_SIZE   (64 * 1024)  /* 用户栈大小 64KB */
13
#define USER_CODE_BASE    0x08048000   /* 用户代码段起始地址 */
14

15
/* 进程结构 */
16
typedef struct process {
17
    pid_t pid;                      /* 进程ID */
18
    char name[32];                  /* 进程名 */
19
    process_state_t state;          /* 进程状态 */
20

21
    /* 内存管理 */
22
    uint32_t *page_dir;             /* 页目录 */
23
    uint32_t user_stack_top;        /* 用户栈顶 */
24
    uint32_t kernel_stack_top;      /* 内核栈顶 */
25

26
    /* 线程管理 */
27
    task_t *main_thread;            /* 主线程 */
28
    struct list_node thread_list;   /* 线程链表 */
29
    int thread_count;               /* 线程数量 */
30

31
    /* 父子进程关系 */
32
    struct process *parent;         /* 父进程 */
33
    struct list_node children;      /* 子进程链表 */
34
    struct list_node sibling;       /* 兄弟进程链表 */
35

36
    /* 退出状态 */
37
    int exit_code;                  /* 退出码 */
38
    int refcount;                   /* 引用计数 */
39
} process_t;

1
static void fork_child_entry(void)
2
{
3
    process_t *proc = current_process();
4
    vga_printf("[Fork-Child] pid=%u running\n", proc ? proc->pid : 0);
5
    process_exit(0);
6
}

1
int sys_fork_impl(void)
2
{
3
    process_t *parent = current_process();
4
    task_t *parent_task = current_task();
5

6
    if (!parent_task) return -1;
7

8
    /* 创建子进程（新的 process_t 结构） */
9
    process_t *child = process_create("forked", fork_child_entry,
10
                                      parent_task->priority);
11
    if (!child) return -1;
12

13
    /* 设置父进程关系 */
14
    child->parent = parent;
15

16
    vga_printf("[Fork] Created child pid=%u from parent pid=%u\n",
17
               child->pid, parent ? parent->pid : 0);
18

19
    /* 返回子进程 PID 给父进程 */
20
    return (int)child->pid;
21
}

1
int sys_exec_impl(const char *path)
2
{
3
    if (!path) return -1;
4

5
    /* 打开程序文件 */
6
    int fd = fs_open(path, FS_OPEN_READ);
7
    if (fd < 0) {
8
        vga_printf("[Exec] File not found: %s\n", path);
9
        return -1;
10
    }
11

12
    /* 读取程序到临时缓冲区 */
13
    char buf[4096];
14
    memset(buf, 0, sizeof(buf));
15
    ssize_t size = fs_read(fd, buf, sizeof(buf));
16
    fs_close(fd);
17

18
    if (size <= 0) {
19
        vga_printf("[Exec] Failed to read program\n");
20
        return -1;
21
    }
22

23
    vga_printf("[Exec] Loaded %d bytes from %s\n", (int)size, path);
24

25
    /* 映射加载地址的页面 */
26
    uint32_t load_addr = EXEC_LOAD_ADDR;  // 0x08048000
27
    for (uint32_t a = load_addr; a < load_addr + (uint32_t)size; a += 4096) {
28
        vmm_map_page_default(a);
29
    }
30

31
    /* 复制程序到加载地址 */
32
    memcpy((void *)load_addr, buf, size);
33

34
    /* 映射用户栈 */
35
    uint32_t stack_bottom = EXEC_STACK_TOP - EXEC_STACK_SIZE;
36
    for (uint32_t a = stack_bottom; a < EXEC_STACK_TOP; a += 4096) {
37
        vmm_map_page_default(a);
38
    }
39

40
    /* 跳转到用户空间执行 */
41
    switch_to_usermode(load_addr, EXEC_STACK_TOP);
42

43
    /* 不应到达 */
44
    return -1;
45
}

1
void process_exit(int exit_code)
2
{
3
    process_t *proc = current_process();
4

5
    if (proc == NULL) {
6
        /* 内核线程退出 */
7
        task_exit(exit_code);
8
        return;
9
    }
10

11
    /* 设置退出状态 */
12
    proc->exit_code = exit_code;
13
    proc->state = PROC_ZOMBIE;
14

15
    vga_printf("[Process] Process %u exiting with code %d\n",
16
               proc->pid, exit_code);
17

18
    /* 退出主线程 */
19
    task_exit(exit_code);
20
}

1
process_t *process_create(const char *name, void (*entry)(void), int priority)
2
{
3
    process_t *proc;
4
    task_t *thread;
5

6
    /* 分配进程结构 */
7
    proc = (process_t *)kmalloc(sizeof(process_t));
8
    if (proc == NULL) {
9
        vga_printf("[Process] Failed to allocate process structure\n");
10
        return NULL;
11
    }
12
    memset(proc, 0, sizeof(process_t));
13

14
    /* 分配进程ID */
15
    proc->pid = next_pid++;
16

17
    /* 设置进程名 */
18
    if (name != NULL) {
19
        strncpy(proc->name, name, sizeof(proc->name) - 1);
20
        proc->name[sizeof(proc->name) - 1] = '\0';
21
    } else {
22
        sprintf(proc->name, "process-%u", proc->pid);
23
    }
24

25
    proc->state = PROC_READY;
26
    proc->refcount = 1;
27

28
    /* 创建页目录 */
29
    proc->page_dir = create_user_page_dir();
30
    if (proc->page_dir == NULL) {
31
        vga_printf("[Process] Failed to create page directory\n");
32
        kfree(proc);
33
        return NULL;
34
    }
35

36
    /* 分配用户栈 */
37
    proc->user_stack_top = alloc_user_stack();
38

39
    /* 分配内核栈 */
40
    uint32_t kernel_stack = (uint32_t)kmalloc_aligned(KERNEL_STACK_SIZE);
41
    if (kernel_stack == 0) {
42
        vga_printf("[Process] Failed to allocate kernel stack\n");
43
        kfree(proc);
44
        return NULL;
45
    }
46
    proc->kernel_stack_top = kernel_stack + KERNEL_STACK_SIZE;
47

48
    /* 设置 TSS 内核栈 */
49
    tss_set_kernel_stack(proc->kernel_stack_top);
50

51
    /* 创建主线程 */
52
    thread = task_create_user_stub(proc->pid, proc->name, entry,
53
                                    (void *)proc->user_stack_top, priority);
54
    if (thread == NULL) {
55
        vga_printf("[Process] Failed to create main thread\n");
56
        kfree(proc);
57
        return NULL;
58
    }
59

60
    proc->main_thread = thread;
61
    proc->thread_count = 1;
62
    thread->owner = proc;
63

64
    /* 添加到进程链表 */
65
    process_list.count++;
66

67
    vga_printf("[Process] Created process '%s' (pid=%u)\n",
68
               proc->name, proc->pid);
69

70
    return proc;
71
}