lunaix-os/kernel/process.c

   1 #include <lunaix/process.h>
   2 #include <lunaix/mm/vmm.h>
   3 #include <lunaix/mm/region.h>
   4 #include <lunaix/clock.h>
   5 #include <lunaix/syslog.h>
   6 #include <lunaix/common.h>
   7 #include <lunaix/syscall.h>
   8 #include <lunaix/spike.h>
   9
  10 LOG_MODULE("PROC")
  11
  12 void* __dup_pagetable(pid_t pid, uintptr_t mount_point) {
  13     void* ptd_pp = pmm_alloc_page(pid, PP_FGPERSIST);
  14     x86_page_table* ptd = vmm_fmap_page(pid, PG_MOUNT_1, ptd_pp, PG_PREM_RW);
  15     x86_page_table* pptd = (x86_page_table*) (mount_point | (0x3FF << 12));
  16
  17     for (size_t i = 0; i < PG_MAX_ENTRIES - 1; i++)
  18     {
  19         x86_pte_t ptde = pptd->entry[i];
  20         if (!ptde || !(ptde & PG_PRESENT)) {
  21             ptd->entry[i] = ptde;
  22             continue;
  23         }
  24
  25         x86_page_table* ppt = (x86_page_table*) (mount_point | (i << 12));
  26         void* pt_pp = pmm_alloc_page(pid, PP_FGPERSIST);
  27         x86_page_table* pt = vmm_fmap_page(pid, PG_MOUNT_2, pt_pp, PG_PREM_RW);
  28
  29         for (size_t j = 0; j < PG_MAX_ENTRIES; j++)
  30         {
  31             x86_pte_t pte = ppt->entry[j];
  32             pmm_ref_page(pid, pte & ~0xfff);
  33             pt->entry[j] = pte;
  34         }
  35
  36         ptd->entry[i] = (uintptr_t)pt_pp | PG_PREM_RW;
  37     }
  38
  39     ptd->entry[PG_MAX_ENTRIES - 1] = NEW_L1_ENTRY(T_SELF_REF_PERM, ptd_pp);
  40
  41     return ptd_pp;
  42 }
  43
  44 void* dup_pagetable(pid_t pid) {
  45     return __dup_pagetable(pid, PD_REFERENCED);
  46 }
  47
  48 __DEFINE_LXSYSCALL(void, fork) {
  49     dup_proc();
  50 }
  51
  52 __DEFINE_LXSYSCALL(pid_t, getpid) {
  53     return __current->pid;
  54 }
  55
  56 __DEFINE_LXSYSCALL(pid_t, getppid) {
  57     return __current->parent->pid;
  58 }
  59
  60 void dup_proc() {
  61     pid_t pid = alloc_pid();
  62
  63     struct proc_info pcb = (struct proc_info) {
  64         .created = clock_systime(),
  65         .pid = pid,
  66         .mm = __current->mm,
  67         .intr_ctx = __current->intr_ctx,
  68         .parent = __current
  69     };
  70
  71     setup_proc_mem(&pcb, PD_MOUNT_1);    //挂载点#1是当前进程的页表
  72
  73     // 根据 mm_region 进一步配置页表
  74     if (__current->mm.regions) {
  75         struct mm_region *pos, *n;
  76         llist_for_each(pos, n, &__current->mm.regions->head, head) {
  77             region_add(&pcb, pos->start, pos->end, pos->attr);
  78
  79             // 如果写共享，则不作处理。
  80             if ((pos->attr & REGION_WSHARED)) {
  81                 continue;
  82             }
  83
  84             uintptr_t start_vpn = PG_ALIGN(pos->start) >> 12;
  85             uintptr_t end_vpn = PG_ALIGN(pos->end) >> 12;
  86             for (size_t i = start_vpn; i < end_vpn; i++)
  87             {
  88                 x86_pte_t *curproc = &((x86_page_table*)(PD_MOUNT_1 | ((i & 0xffc00) << 2)))->entry[i & 0x3ff];
  89                 x86_pte_t *newproc = &((x86_page_table*)(PD_MOUNT_2 | ((i & 0xffc00) << 2)))->entry[i & 0x3ff];
  90
  91                 if (pos->attr == REGION_RSHARED) {
  92                     // 如果读共享，则将两者的都标注为只读，那么任何写入都将会应用COW策略。
  93                     *curproc = *curproc & ~PG_WRITE;
  94                     *newproc = *newproc & ~PG_WRITE;
  95                 }
  96                 else {
  97                     // 如果是私有页，则将该页从新进程中移除。
  98                     *newproc = 0;
  99                 }
 100             }
 101         }
 102     }
 103
 104     vmm_unmount_pd(PD_MOUNT_2);
 105
 106     // 正如同fork，返回两次。
 107     pcb.intr_ctx.registers.eax = 0;
 108     __current->intr_ctx.registers.eax = pid;
 109
 110     push_process(&pcb);
 111 }
 112
 113 extern void __kernel_end;
 114
 115 void setup_proc_mem(struct proc_info* proc, uintptr_t usedMnt) {
 116     // copy the entire kernel page table
 117     pid_t pid = proc->pid;
 118     void* pt_copy = __dup_pagetable(pid, usedMnt);
 119
 120     vmm_mount_pd(PD_MOUNT_2, pt_copy);   // 将新进程的页表挂载到挂载点#2
 121
 122     // copy the kernel stack
 123     for (size_t i = KSTACK_START >> 12; i <= KSTACK_TOP >> 12; i++)
 124     {
 125         x86_pte_t *ppte = &((x86_page_table*)(PD_MOUNT_2 | ((i & 0xffc00) << 2)))->entry[i & 0x3ff];
 126         void* ppa = vmm_dup_page(pid, PG_ENTRY_ADDR(*ppte));
 127         *ppte = (*ppte & 0xfff) | (uintptr_t)ppa;
 128     }
 129
 130     // 我们不需要分配内核的区域，因为所有的内核代码和数据段只能通过系统调用来访问，任何非法的访问
 131     // 都会导致eip落在区域外面，从而segmentation fault.
 132
 133     // 定义用户栈区域，但是不分配实际的物理页。我们会在Page fault handler里面实现动态分配物理页的逻辑。（虚拟内存的好处！）
 134     // FIXME: 这里应该放到spawn_proc里面。
 135     // region_add(proc, USTACK_END, USTACK_SIZE, REGION_PRIVATE | REGION_RW);
 136
 137     // 至于其他的区域我们暂时没有办法知道，因为那需要知道用户程序的信息。我们留到之后在处理。
 138
 139     proc->page_table = pt_copy;
 140 }