1 #include "param.h" 2 #include "types.h" 3 #include "defs.h" 4 #include "x86.h" 5 #include "memlayout.h" 6 #include "mmu.h" 7 #include "proc.h" 8 #include "elf.h" 9 10 extern char data[]; // defined by kernel.ld 11 pde_t *kpgdir; // for use in scheduler() 12 13 // Set up CPU's kernel segment descriptors. 14 // Run once on entry on each CPU. 15 void 16 seginit(void) 17 { 18 struct cpu *c; 19 20 // Map "logical" addresses to virtual addresses using identity map. 21 // Cannot share a CODE descriptor for both kernel and user 22 // because it would have to have DPL_USR, but the CPU forbids 23 // an interrupt from CPL=0 to DPL=3. 24 c = &cpus[cpunum()]; 25 c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0); 26 c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0); 27 c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER); 28 c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER); 29 30 // Map cpu and proc -- these are private per cpu. 31 c->gdt[SEG_KCPU] = SEG(STA_W, &c->cpu, 8, 0); 32 33 lgdt(c->gdt, sizeof(c->gdt)); 34 loadgs(SEG_KCPU << 3); 35 36 // Initialize cpu-local storage. 37 cpu = c; 38 proc = 0; 39 } 40 41 // Return the address of the PTE in page table pgdir 42 // that corresponds to virtual address va. If alloc!=0, 43 // create any required page table pages. 44 static pte_t * 45 walkpgdir(pde_t *pgdir, const void *va, int alloc) 46 { 47 pde_t *pde; 48 pte_t *pgtab; 49 50 pde = &pgdir[PDX(va)]; 51 if(*pde & PTE_P){ 52 pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); 53 } else { 54 if(!alloc || (pgtab = (pte_t*)kalloc()) == 0) 55 return 0; 56 // Make sure all those PTE_P bits are zero. 57 memset(pgtab, 0, PGSIZE); 58 // The permissions here are overly generous, but they can 59 // be further restricted by the permissions in the page table 60 // entries, if necessary. 61 *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U; 62 } 63 return &pgtab[PTX(va)]; 64 } 65 66 // Create PTEs for virtual addresses starting at va that refer to 67 // physical addresses starting at pa. va and size might not 68 // be page-aligned. 69 static int 70 mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm) 71 { 72 char *a, *last; 73 pte_t *pte; 74 75 a = (char*)PGROUNDDOWN((uint)va); 76 last = (char*)PGROUNDDOWN(((uint)va) + size - 1); 77 for(;;){ 78 if((pte = walkpgdir(pgdir, a, 1)) == 0) 79 return -1; 80 if(*pte & PTE_P) 81 panic("remap"); 82 *pte = pa | perm | PTE_P; 83 if(a == last) 84 break; 85 a += PGSIZE; 86 pa += PGSIZE; 87 } 88 return 0; 89 } 90 91 // There is one page table per process, plus one that's used when 92 // a CPU is not running any process (kpgdir). The kernel uses the 93 // current process's page table during system calls and interrupts; 94 // page protection bits prevent user code from using the kernel's 95 // mappings. 96 // 97 // setupkvm() and exec() set up every page table like this: 98 // 99 // 0..KERNBASE: user memory (text+data+stack+heap), mapped to 100 // phys memory allocated by the kernel 101 // KERNBASE..KERNBASE+EXTMEM: mapped to 0..EXTMEM (for I/O space) 102 // KERNBASE+EXTMEM..data: mapped to EXTMEM..V2P(data) 103 // for the kernel's instructions and r/o data 104 // data..KERNBASE+PHYSTOP: mapped to V2P(data)..PHYSTOP, 105 // rw data + free physical memory 106 // 0xfe000000..0: mapped direct (devices such as ioapic) 107 // 108 // The kernel allocates physical memory for its heap and for user memory 109 // between V2P(end) and the end of physical memory (PHYSTOP) 110 // (directly addressable from end..P2V(PHYSTOP)). 111 112 // This table defines the kernel's mappings, which are present in 113 // every process's page table. 114 static struct kmap { 115 void *virt; 116 uint phys_start; 117 uint phys_end; 118 int perm; 119 } kmap[] = { 120 { (void*)KERNBASE, 0, EXTMEM, PTE_W}, // I/O space 121 { (void*)KERNLINK, V2P(KERNLINK), V2P(data), 0}, // kern text+rodata 122 { (void*)data, V2P(data), PHYSTOP, PTE_W}, // kern data+memory 123 { (void*)DEVSPACE, DEVSPACE, 0, PTE_W}, // more devices 124 }; 125 126 // Set up kernel part of a page table. 127 pde_t* 128 setupkvm(void) 129 { 130 pde_t *pgdir; 131 struct kmap *k; 132 133 if((pgdir = (pde_t*)kalloc()) == 0) 134 return 0; 135 memset(pgdir, 0, PGSIZE); 136 if (P2V(PHYSTOP) > (void*)DEVSPACE) 137 panic("PHYSTOP too high"); 138 for(k = kmap; k < &kmap[NELEM(kmap)]; k++) 139 if(mappages(pgdir, k->virt, k->phys_end - k->phys_start, 140 (uint)k->phys_start, k->perm) < 0) { 141 freevm(pgdir); 142 return 0; 143 } 144 return pgdir; 145 } 146 147 // Allocate one page table for the machine for the kernel address 148 // space for scheduler processes. 149 void 150 kvmalloc(void) 151 { 152 kpgdir = setupkvm(); 153 switchkvm(); 154 } 155 156 // Switch h/w page table register to the kernel-only page table, 157 // for when no process is running. 158 void 159 switchkvm(void) 160 { 161 lcr3(V2P(kpgdir)); // switch to the kernel page table 162 } 163 164 // Switch TSS and h/w page table to correspond to process p. 165 void 166 switchuvm(struct proc *p) 167 { 168 if(p == 0) 169 panic("switchuvm: no process"); 170 if(p->kstack == 0) 171 panic("switchuvm: no kstack"); 172 if(p->pgdir == 0) 173 panic("switchuvm: no pgdir"); 174 175 pushcli(); 176 cpu->gdt[SEG_TSS] = SEG16(STS_T32A, &cpu->ts, sizeof(cpu->ts)-1, 0); 177 cpu->gdt[SEG_TSS].s = 0; 178 cpu->ts.ss0 = SEG_KDATA << 3; 179 cpu->ts.esp0 = (uint)p->kstack + KSTACKSIZE; 180 // setting IOPL=0 in eflags *and* iomb beyond the tss segment limit 181 // forbids I/O instructions (e.g., inb and outb) from user space 182 cpu->ts.iomb = (ushort) 0xFFFF; 183 ltr(SEG_TSS << 3); 184 lcr3(V2P(p->pgdir)); // switch to process's address space 185 popcli(); 186 } 187 188 // Load the initcode into address 0 of pgdir. 189 // sz must be less than a page. 190 void 191 inituvm(pde_t *pgdir, char *init, uint sz) 192 { 193 char *mem; 194 195 if(sz >= PGSIZE) 196 panic("inituvm: more than a page"); 197 mem = kalloc(); 198 memset(mem, 0, PGSIZE); 199 mappages(pgdir, 0, PGSIZE, V2P(mem), PTE_W|PTE_U); 200 memmove(mem, init, sz); 201 } 202 203 // Load a program segment into pgdir. addr must be page-aligned 204 // and the pages from addr to addr+sz must already be mapped. 205 int 206 loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz) 207 { 208 uint i, pa, n; 209 pte_t *pte; 210 211 if((uint) addr % PGSIZE != 0) 212 panic("loaduvm: addr must be page aligned"); 213 for(i = 0; i < sz; i += PGSIZE){ 214 if((pte = walkpgdir(pgdir, addr+i, 0)) == 0) 215 panic("loaduvm: address should exist"); 216 pa = PTE_ADDR(*pte); 217 if(sz - i < PGSIZE) 218 n = sz - i; 219 else 220 n = PGSIZE; 221 if(readi(ip, P2V(pa), offset+i, n) != n) 222 return -1; 223 } 224 return 0; 225 } 226 227 // Allocate page tables and physical memory to grow process from oldsz to 228 // newsz, which need not be page aligned. Returns new size or 0 on error. 229 int 230 allocuvm(pde_t *pgdir, uint oldsz, uint newsz) 231 { 232 char *mem; 233 uint a; 234 235 if(newsz >= KERNBASE) 236 return 0; 237 if(newsz < oldsz) 238 return oldsz; 239 240 a = PGROUNDUP(oldsz); 241 for(; a < newsz; a += PGSIZE){ 242 mem = kalloc(); 243 if(mem == 0){ 244 cprintf("allocuvm out of memory\n"); 245 deallocuvm(pgdir, newsz, oldsz); 246 return 0; 247 } 248 memset(mem, 0, PGSIZE); 249 if(mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0){ 250 cprintf("allocuvm out of memory (2)\n"); 251 deallocuvm(pgdir, newsz, oldsz); 252 kfree(mem); 253 return 0; 254 } 255 } 256 return newsz; 257 } 258 259 // Deallocate user pages to bring the process size from oldsz to 260 // newsz. oldsz and newsz need not be page-aligned, nor does newsz 261 // need to be less than oldsz. oldsz can be larger than the actual 262 // process size. Returns the new process size. 263 int 264 deallocuvm(pde_t *pgdir, uint oldsz, uint newsz) 265 { 266 pte_t *pte; 267 uint a, pa; 268 269 if(newsz >= oldsz) 270 return oldsz; 271 272 a = PGROUNDUP(newsz); 273 for(; a < oldsz; a += PGSIZE){ 274 pte = walkpgdir(pgdir, (char*)a, 0); 275 if(!pte) 276 a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE; 277 else if((*pte & PTE_P) != 0){ 278 pa = PTE_ADDR(*pte); 279 if(pa == 0) 280 panic("kfree"); 281 char *v = P2V(pa); 282 kfree(v); 283 *pte = 0; 284 } 285 } 286 return newsz; 287 } 288 289 // Free a page table and all the physical memory pages 290 // in the user part. 291 void 292 freevm(pde_t *pgdir) 293 { 294 uint i; 295 296 if(pgdir == 0) 297 panic("freevm: no pgdir"); 298 deallocuvm(pgdir, KERNBASE, 0); 299 for(i = 0; i < NPDENTRIES; i++){ 300 if(pgdir[i] & PTE_P){ 301 char * v = P2V(PTE_ADDR(pgdir[i])); 302 kfree(v); 303 } 304 } 305 kfree((char*)pgdir); 306 } 307 308 // Clear PTE_U on a page. Used to create an inaccessible 309 // page beneath the user stack. 310 void 311 clearpteu(pde_t *pgdir, char *uva) 312 { 313 pte_t *pte; 314 315 pte = walkpgdir(pgdir, uva, 0); 316 if(pte == 0) 317 panic("clearpteu"); 318 *pte &= ~PTE_U; 319 } 320 321 // Given a parent process's page table, create a copy 322 // of it for a child. 323 pde_t* 324 copyuvm(pde_t *pgdir, uint sz) 325 { 326 pde_t *d; 327 pte_t *pte; 328 uint pa, i, flags; 329 char *mem; 330 331 if((d = setupkvm()) == 0) 332 return 0; 333 for(i = 0; i < sz; i += PGSIZE){ 334 if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0) 335 panic("copyuvm: pte should exist"); 336 if(!(*pte & PTE_P)) 337 panic("copyuvm: page not present"); 338 pa = PTE_ADDR(*pte); 339 flags = PTE_FLAGS(*pte); 340 if((mem = kalloc()) == 0) 341 goto bad; 342 memmove(mem, (char*)P2V(pa), PGSIZE); 343 if(mappages(d, (void*)i, PGSIZE, V2P(mem), flags) < 0) 344 goto bad; 345 } 346 return d; 347 348 bad: 349 freevm(d); 350 return 0; 351 } 352 353 //PAGEBREAK! 354 // Map user virtual address to kernel address. 355 char* 356 uva2ka(pde_t *pgdir, char *uva) 357 { 358 pte_t *pte; 359 360 pte = walkpgdir(pgdir, uva, 0); 361 if((*pte & PTE_P) == 0) 362 return 0; 363 if((*pte & PTE_U) == 0) 364 return 0; 365 return (char*)P2V(PTE_ADDR(*pte)); 366 } 367 368 // Copy len bytes from p to user address va in page table pgdir. 369 // Most useful when pgdir is not the current page table. 370 // uva2ka ensures this only works for PTE_U pages. 371 int 372 copyout(pde_t *pgdir, uint va, void *p, uint len) 373 { 374 char *buf, *pa0; 375 uint n, va0; 376 377 buf = (char*)p; 378 while(len > 0){ 379 va0 = (uint)PGROUNDDOWN(va); 380 pa0 = uva2ka(pgdir, (char*)va0); 381 if(pa0 == 0) 382 return -1; 383 n = PGSIZE - (va - va0); 384 if(n > len) 385 n = len; 386 memmove(pa0 + (va - va0), buf, n); 387 len -= n; 388 buf += n; 389 va = va0 + PGSIZE; 390 } 391 return 0; 392 } 393 394 //PAGEBREAK! 395 // Blank page. 396 //PAGEBREAK! 397 // Blank page. 398 //PAGEBREAK! 399 // Blank page. 400 401