lunaix-os/kernel/process.c

   1 #include <klibc/string.h>
   2 #include <lunaix/clock.h>
   3 #include <lunaix/common.h>
   4 #include <lunaix/mm/pmm.h>
   5 #include <lunaix/mm/region.h>
   6 #include <lunaix/mm/vmm.h>
   7 #include <lunaix/process.h>
   8 #include <lunaix/spike.h>
   9 #include <lunaix/status.h>
  10 #include <lunaix/syscall.h>
  11 #include <lunaix/syslog.h>
  12
  13 LOG_MODULE("PROC")
  14
  15 void*
  16 __dup_pagetable(pid_t pid, uintptr_t mount_point)
  17 {
  18     void* ptd_pp = pmm_alloc_page(pid, PP_FGPERSIST);
  19     vmm_set_mapping(PD_REFERENCED, PG_MOUNT_1, ptd_pp, PG_PREM_RW, VMAP_NULL);
  20
  21     x86_page_table* ptd = PG_MOUNT_1;
  22     x86_page_table* pptd = (x86_page_table*)(mount_point | (0x3FF << 12));
  23
  24     size_t kspace_l1inx = L1_INDEX(KERNEL_MM_BASE);
  25
  26     for (size_t i = 0; i < PG_MAX_ENTRIES - 1; i++) {
  27
  28         x86_pte_t ptde = pptd->entry[i];
  29         // 空或者是未在内存中的L1页表项直接照搬过去。
  30         // 内核地址空间直接共享过去。
  31         if (!ptde || i >= kspace_l1inx || !(ptde & PG_PRESENT)) {
  32             ptd->entry[i] = ptde;
  33             continue;
  34         }
  35
  36         // 复制L2页表
  37         void* pt_pp = pmm_alloc_page(pid, PP_FGPERSIST);
  38         vmm_set_mapping(
  39           PD_REFERENCED, PG_MOUNT_2, pt_pp, PG_PREM_RW, VMAP_NULL);
  40
  41         x86_page_table* ppt = (x86_page_table*)(mount_point | (i << 12));
  42         x86_page_table* pt = PG_MOUNT_2;
  43
  44         for (size_t j = 0; j < PG_MAX_ENTRIES; j++) {
  45             x86_pte_t pte = ppt->entry[j];
  46             pmm_ref_page(pid, PG_ENTRY_ADDR(pte));
  47             pt->entry[j] = pte;
  48         }
  49
  50         ptd->entry[i] = (uintptr_t)pt_pp | PG_PREM_RW;
  51     }
  52
  53     ptd->entry[PG_MAX_ENTRIES - 1] = NEW_L1_ENTRY(T_SELF_REF_PERM, ptd_pp);
  54
  55     return ptd_pp;
  56 }
  57
  58 void
  59 __del_pagetable(pid_t pid, uintptr_t mount_point)
  60 {
  61     x86_page_table* pptd = (x86_page_table*)(mount_point | (0x3FF << 12));
  62
  63     // only remove user address space
  64     for (size_t i = 0; i < L1_INDEX(KERNEL_MM_BASE); i++) {
  65         x86_pte_t ptde = pptd->entry[i];
  66         if (!ptde || !(ptde & PG_PRESENT)) {
  67             continue;
  68         }
  69
  70         x86_page_table* ppt = (x86_page_table*)(mount_point | (i << 12));
  71
  72         for (size_t j = 0; j < PG_MAX_ENTRIES; j++) {
  73             x86_pte_t pte = ppt->entry[j];
  74             // free the 4KB data page
  75             if ((pte & PG_PRESENT)) {
  76                 pmm_free_page(pid, PG_ENTRY_ADDR(pte));
  77             }
  78         }
  79         // free the L2 page table
  80         pmm_free_page(pid, PG_ENTRY_ADDR(ptde));
  81     }
  82     // free the L1 directory
  83     pmm_free_page(pid, PG_ENTRY_ADDR(pptd->entry[PG_MAX_ENTRIES - 1]));
  84 }
  85
  86 void*
  87 vmm_dup_vmspace(pid_t pid)
  88 {
  89     return __dup_pagetable(pid, PD_REFERENCED);
  90 }
  91
  92 __DEFINE_LXSYSCALL(pid_t, fork)
  93 {
  94     return dup_proc();
  95 }
  96
  97 __DEFINE_LXSYSCALL(pid_t, getpid)
  98 {
  99     return __current->pid;
 100 }
 101
 102 __DEFINE_LXSYSCALL(pid_t, getppid)
 103 {
 104     return __current->parent->pid;
 105 }
 106
 107 __DEFINE_LXSYSCALL(pid_t, getpgid)
 108 {
 109     return __current->pgid;
 110 }
 111
 112 __DEFINE_LXSYSCALL2(int, setpgid, pid_t, pid, pid_t, pgid)
 113 {
 114     struct proc_info* proc = pid ? get_process(pid) : __current;
 115
 116     if (!proc) {
 117         __current->k_status = LXINVL;
 118         return -1;
 119     }
 120
 121     pgid = pgid ? pgid : proc->pid;
 122
 123     struct proc_info* gruppenfuhrer = get_process(pgid);
 124
 125     if (!gruppenfuhrer || proc->pgid == proc->pid) {
 126         __current->k_status = LXINVL;
 127         return -1;
 128     }
 129
 130     llist_delete(&proc->grp_member);
 131     llist_append(&gruppenfuhrer->grp_member, &proc->grp_member);
 132
 133     proc->pgid = pgid;
 134     return 0;
 135 }
 136
 137 void
 138 init_proc(struct proc_info* pcb)
 139 {
 140     memset(pcb, 0, sizeof(*pcb));
 141
 142     pcb->pid = alloc_pid();
 143     pcb->created = clock_systime();
 144     pcb->state = PROC_CREATED;
 145     pcb->pgid = pcb->pid;
 146 }
 147
 148 void
 149 __mark_region(uintptr_t start_vpn, uintptr_t end_vpn, int attr)
 150 {
 151     for (size_t i = start_vpn; i < end_vpn; i++) {
 152         x86_pte_t* curproc = &PTE_MOUNTED(PD_REFERENCED, i);
 153         x86_pte_t* newproc = &PTE_MOUNTED(PD_MOUNT_1, i);
 154         cpu_invplg(newproc);
 155
 156         if (attr == REGION_RSHARED) {
 157             // 如果读共享，则将两者的都标注为只读，那么任何写入都将会应用COW策略。
 158             cpu_invplg(curproc);
 159             *curproc = *curproc & ~PG_WRITE;
 160             *newproc = *newproc & ~PG_WRITE;
 161         } else {
 162             // 如果是私有页，则将该页从新进程中移除。
 163             *newproc = 0;
 164         }
 165     }
 166 }
 167
 168 pid_t
 169 dup_proc()
 170 {
 171     struct proc_info pcb;
 172     init_proc(&pcb);
 173     pcb.mm = __current->mm;
 174     pcb.intr_ctx = __current->intr_ctx;
 175     pcb.parent = __current;
 176
 177     region_copy(&__current->mm.regions, &pcb.mm.regions);
 178
 179     setup_proc_mem(&pcb, PD_REFERENCED);
 180
 181     // 根据 mm_region 进一步配置页表
 182     if (!__current->mm.regions) {
 183         goto not_copy;
 184     }
 185
 186     struct mm_region *pos, *n;
 187     llist_for_each(pos, n, &pcb.mm.regions->head, head)
 188     {
 189         // 如果写共享，则不作处理。
 190         if ((pos->attr & REGION_WSHARED)) {
 191             continue;
 192         }
 193
 194         uintptr_t start_vpn = PG_ALIGN(pos->start) >> 12;
 195         uintptr_t end_vpn = PG_ALIGN(pos->end) >> 12;
 196         __mark_region(start_vpn, end_vpn, pos->attr);
 197     }
 198
 199 not_copy:
 200     vmm_unmount_pd(PD_MOUNT_1);
 201
 202     // 正如同fork，返回两次。
 203     pcb.intr_ctx.registers.eax = 0;
 204
 205     push_process(&pcb);
 206
 207     return pcb.pid;
 208 }
 209
 210 extern void __kernel_end;
 211
 212 void
 213 setup_proc_mem(struct proc_info* proc, uintptr_t usedMnt)
 214 {
 215     // copy the entire kernel page table
 216     pid_t pid = proc->pid;
 217     void* pt_copy = __dup_pagetable(pid, usedMnt);
 218
 219     vmm_mount_pd(PD_MOUNT_1, pt_copy); // 将新进程的页表挂载到挂载点#2
 220
 221     // copy the kernel stack
 222     for (size_t i = KSTACK_START >> 12; i <= KSTACK_TOP >> 12; i++) {
 223         volatile x86_pte_t* ppte = &PTE_MOUNTED(PD_MOUNT_1, i);
 224
 225         /*
 226             This is a fucking nightmare, the TLB caching keep the rewrite to PTE
 227            from updating. Even the Nightmare Moon the Evil is far less nasty
 228            than this. It took me hours of debugging to figure this out.
 229
 230             In the name of Celestia our glorious goddess, I will fucking HATE
 231            the TLB for the rest of my LIFE!
 232         */
 233         cpu_invplg(ppte);
 234
 235         x86_pte_t p = *ppte;
 236         void* ppa = vmm_dup_page(pid, PG_ENTRY_ADDR(p));
 237         pmm_free_page(pid, PG_ENTRY_ADDR(p));
 238         *ppte = (p & 0xfff) | (uintptr_t)ppa;
 239     }
 240
 241     // 我们不需要分配内核的区域，因为所有的内核代码和数据段只能通过系统调用来访问，任何非法的访问
 242     // 都会导致eip落在区域外面，从而segmentation fault.
 243
 244     // 定义用户栈区域，但是不分配实际的物理页。我们会在Page fault
 245     // handler里面实现动态分配物理页的逻辑。（虚拟内存的好处！）
 246     // FIXME: 这里应该放到spawn_proc里面。
 247     // region_add(proc, USTACK_END, USTACK_SIZE, REGION_PRIVATE |
 248     // REGION_RW);
 249
 250     // 至于其他的区域我们暂时没有办法知道，因为那需要知道用户程序的信息。我们留到之后在处理。
 251     proc->page_table = pt_copy;
 252 }