summaryrefslogtreecommitdiff
path: root/vm.c
diff options
context:
space:
mode:
Diffstat (limited to 'vm.c')
-rw-r--r--vm.c523
1 files changed, 255 insertions, 268 deletions
diff --git a/vm.c b/vm.c
index 46d18fc..1fe64d2 100644
--- a/vm.c
+++ b/vm.c
@@ -6,81 +6,86 @@
#include "proc.h"
#include "elf.h"
-// The mappings from logical to linear are one to one (i.e.,
-// segmentation doesn't do anything).
-// There is one page table per process, plus one that's used
-// when a CPU is not running any process (kpgdir).
-// A user process uses the same page table as the kernel; the
-// page protection bits prevent it from using anything other
-// than its memory.
-//
-// setupkvm() and exec() set up every page table like this:
-// 0..640K : user memory (text, data, stack, heap)
-// 640K..1M : mapped direct (for IO space)
-// 1M..kernend : mapped direct (for the kernel's text and data)
-// kernend..PHYSTOP : mapped direct (kernel heap and user pages)
-// 0xfe000000..0 : mapped direct (devices such as ioapic)
-//
-// The kernel allocates memory for its heap and for user memory
-// between kernend and the end of physical memory (PHYSTOP).
-// The virtual address space of each user program includes the kernel
-// (which is inaccessible in user mode). The user program addresses
-// range from 0 till 640KB (USERTOP), which where the I/O hole starts
-// (both in physical memory and in the kernel's virtual address
-// space).
-
-#define USERTOP 0xA0000
+extern char data[]; // defined in data.S
-static uint kerntext; // Linker starts kernel at 1MB
-static uint kerntsz;
-static uint kerndata;
-static uint kerndsz;
-static uint kernend;
-static uint freesz;
static pde_t *kpgdir; // for use in scheduler()
-// return the address of the PTE in page table pgdir
-// that corresponds to linear address va. if create!=0,
+// Allocate one page table for the machine for the kernel address
+// space for scheduler processes.
+void
+kvmalloc(void)
+{
+ kpgdir = setupkvm();
+}
+
+// Set up CPU's kernel segment descriptors.
+// Run once at boot time on each CPU.
+void
+seginit(void)
+{
+ struct cpu *c;
+
+ // Map virtual addresses to linear addresses using identity map.
+ // Cannot share a CODE descriptor for both kernel and user
+ // because it would have to have DPL_USR, but the CPU forbids
+ // an interrupt from CPL=0 to DPL=3.
+ c = &cpus[cpunum()];
+ c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
+ c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
+ c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
+ c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
+
+ // Map cpu, and curproc
+ c->gdt[SEG_KCPU] = SEG(STA_W, &c->cpu, 8, 0);
+
+ lgdt(c->gdt, sizeof(c->gdt));
+ loadgs(SEG_KCPU << 3);
+
+ // Initialize cpu-local storage.
+ cpu = c;
+ proc = 0;
+}
+
+// Return the address of the PTE in page table pgdir
+// that corresponds to linear address va. If create!=0,
// create any required page table pages.
static pte_t *
walkpgdir(pde_t *pgdir, const void *va, int create)
{
- uint r;
pde_t *pde;
pte_t *pgtab;
pde = &pgdir[PDX(va)];
- if (*pde & PTE_P) {
- pgtab = (pte_t*) PTE_ADDR(*pde);
- } else if (!create || !(r = (uint) kalloc()))
- return 0;
- else {
- pgtab = (pte_t*) r;
-
+ if(*pde & PTE_P){
+ pgtab = (pte_t*)PTE_ADDR(*pde);
+ } else {
+ if(!create || (pgtab = (pte_t*)kalloc()) == 0)
+ return 0;
// Make sure all those PTE_P bits are zero.
memset(pgtab, 0, PGSIZE);
-
// The permissions here are overly generous, but they can
// be further restricted by the permissions in the page table
// entries, if necessary.
- *pde = PADDR(r) | PTE_P | PTE_W | PTE_U;
+ *pde = PADDR(pgtab) | PTE_P | PTE_W | PTE_U;
}
return &pgtab[PTX(va)];
}
-// create PTEs for linear addresses starting at la that refer to
+// Create PTEs for linear addresses starting at la that refer to
// physical addresses starting at pa. la and size might not
// be page-aligned.
static int
mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
{
- char *first = PGROUNDDOWN(la);
- char *last = PGROUNDDOWN(la + size - 1);
- char *a = first;
- while(1){
- pte_t *pte = walkpgdir(pgdir, a, 1);
+ char *a, *last;
+ pte_t *pte;
+
+ a = PGROUNDDOWN(la);
+ last = PGROUNDDOWN(la + size - 1);
+ for(;;){
+ pte = walkpgdir(pgdir, a, 1);
if(pte == 0)
- return 0;
+ return -1;
if(*pte & PTE_P)
panic("remap");
*pte = pa | perm | PTE_P;
@@ -89,292 +94,274 @@ mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
a += PGSIZE;
pa += PGSIZE;
}
- return 1;
+ return 0;
}
-// Set up CPU's kernel segment descriptors.
-// Run once at boot time on each CPU.
-void
-ksegment(void)
+// The mappings from logical to linear are one to one (i.e.,
+// segmentation doesn't do anything).
+// There is one page table per process, plus one that's used
+// when a CPU is not running any process (kpgdir).
+// A user process uses the same page table as the kernel; the
+// page protection bits prevent it from using anything other
+// than its memory.
+//
+// setupkvm() and exec() set up every page table like this:
+// 0..640K : user memory (text, data, stack, heap)
+// 640K..1M : mapped direct (for IO space)
+// 1M..end : mapped direct (for the kernel's text and data)
+// end..PHYSTOP : mapped direct (kernel heap and user pages)
+// 0xfe000000..0 : mapped direct (devices such as ioapic)
+//
+// The kernel allocates memory for its heap and for user memory
+// between kernend and the end of physical memory (PHYSTOP).
+// The virtual address space of each user program includes the kernel
+// (which is inaccessible in user mode). The user program addresses
+// range from 0 till 640KB (USERTOP), which where the I/O hole starts
+// (both in physical memory and in the kernel's virtual address
+// space).
+static struct kmap {
+ void *p;
+ void *e;
+ int perm;
+} kmap[] = {
+ {(void*)USERTOP, (void*)0x100000, PTE_W}, // I/O space
+ {(void*)0x100000, data, 0 }, // kernel text, rodata
+ {data, (void*)PHYSTOP, PTE_W}, // kernel data, memory
+ {(void*)0xFE000000, 0, PTE_W}, // device mappings
+};
+
+// Set up kernel part of a page table.
+pde_t*
+setupkvm(void)
{
- struct cpu *c;
+ pde_t *pgdir;
+ struct kmap *k;
- // Map virtual addresses to linear addresses using identity map.
- // Cannot share a CODE descriptor for both kernel and user
- // because it would have to have DPL_USR, but the CPU forbids
- // an interrupt from CPL=0 to DPL=3.
- c = &cpus[cpunum()];
- c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
- c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
- c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
- c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
+ if((pgdir = (pde_t*)kalloc()) == 0)
+ return 0;
+ memset(pgdir, 0, PGSIZE);
+ k = kmap;
+ for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
+ if(mappages(pgdir, k->p, k->e - k->p, (uint)k->p, k->perm) < 0)
+ return 0;
- // map cpu, and curproc
- c->gdt[SEG_KCPU] = SEG(STA_W, &c->cpu, 8, 0);
+ return pgdir;
+}
- lgdt(c->gdt, sizeof(c->gdt));
- loadgs(SEG_KCPU << 3);
-
- // Initialize cpu-local storage.
- cpu = c;
- proc = 0;
+// Turn on paging.
+void
+vmenable(void)
+{
+ uint cr0;
+
+ switchkvm(); // load kpgdir into cr3
+ cr0 = rcr0();
+ cr0 |= CR0_PG;
+ lcr0(cr0);
}
-// Switch h/w page table and TSS registers to point to process p.
+// Switch h/w page table register to the kernel-only page table,
+// for when no process is running.
+void
+switchkvm(void)
+{
+ lcr3(PADDR(kpgdir)); // switch to the kernel page table
+}
+
+// Switch TSS and h/w page table to correspond to process p.
void
switchuvm(struct proc *p)
{
pushcli();
-
- // Setup TSS
cpu->gdt[SEG_TSS] = SEG16(STS_T32A, &cpu->ts, sizeof(cpu->ts)-1, 0);
cpu->gdt[SEG_TSS].s = 0;
cpu->ts.ss0 = SEG_KDATA << 3;
cpu->ts.esp0 = (uint)proc->kstack + KSTACKSIZE;
ltr(SEG_TSS << 3);
-
- if (p->pgdir == 0)
- panic("switchuvm: no pgdir\n");
-
+ if(p->pgdir == 0)
+ panic("switchuvm: no pgdir");
lcr3(PADDR(p->pgdir)); // switch to new address space
popcli();
}
-// Switch h/w page table register to the kernel-only page table, for when
-// no process is running.
+// Load the initcode into address 0 of pgdir.
+// sz must be less than a page.
void
-switchkvm()
+inituvm(pde_t *pgdir, char *init, uint sz)
{
- lcr3(PADDR(kpgdir)); // Switch to the kernel page table
+ char *mem;
+
+ if(sz >= PGSIZE)
+ panic("inituvm: more than a page");
+ mem = kalloc();
+ memset(mem, 0, PGSIZE);
+ mappages(pgdir, 0, PGSIZE, PADDR(mem), PTE_W|PTE_U);
+ memmove(mem, init, sz);
}
-// Set up kernel part of a page table.
-pde_t*
-setupkvm(void)
+// Load a program segment into pgdir. addr must be page-aligned
+// and the pages from addr to addr+sz must already be mapped.
+int
+loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
{
- pde_t *pgdir;
-
- // Allocate page directory
- if (!(pgdir = (pde_t *) kalloc()))
- return 0;
- memset(pgdir, 0, PGSIZE);
- // Map IO space from 640K to 1Mbyte
- if (!mappages(pgdir, (void *)USERTOP, 0x60000, USERTOP, PTE_W))
- return 0;
- // Map kernel text read-only
- if (!mappages(pgdir, (void *) kerntext, kerntsz, kerntext, 0))
- return 0;
- // Map kernel data read/write
- if (!mappages(pgdir, (void *) kerndata, kerndsz, kerndata, PTE_W))
- return 0;
- // Map dynamically-allocated memory read/write (kernel stacks, user mem)
- if (!mappages(pgdir, (void *) kernend, freesz, PADDR(kernend), PTE_W))
- return 0;
- // Map devices such as ioapic, lapic, ...
- if (!mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
- return 0;
- return pgdir;
-}
+ uint i, pa, n;
+ pte_t *pte;
-// return the physical address that a given user address
-// maps to. the result is also a kernel logical address,
-// since the kernel maps the physical memory allocated to user
-// processes directly.
-char*
-uva2ka(pde_t *pgdir, char *uva)
-{
- pte_t *pte = walkpgdir(pgdir, uva, 0);
- if (pte == 0) return 0;
- uint pa = PTE_ADDR(*pte);
- return (char *)pa;
+ if((uint)addr % PGSIZE != 0)
+ panic("loaduvm: addr must be page aligned");
+ for(i = 0; i < sz; i += PGSIZE){
+ if((pte = walkpgdir(pgdir, addr+i, 0)) == 0)
+ panic("loaduvm: address should exist");
+ pa = PTE_ADDR(*pte);
+ if(sz - i < PGSIZE)
+ n = sz - i;
+ else
+ n = PGSIZE;
+ if(readi(ip, (char*)pa, offset+i, n) != n)
+ return -1;
+ }
+ return 0;
}
-// allocate sz bytes more memory for a process starting at the
-// given user address; allocates physical memory and page
-// table entries. addr and sz need not be page-aligned.
-// it is a no-op for any parts of the requested memory
-// that are already allocated.
+// Allocate page tables and physical memory to grow process from oldsz to
+// newsz, which need not be page aligned. Returns new size or 0 on error.
int
-allocuvm(pde_t *pgdir, char *addr, uint sz)
+allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
- if (addr + sz > (char*)USERTOP)
+ char *mem;
+ uint a;
+
+ if(newsz > USERTOP)
return 0;
- char *first = PGROUNDDOWN(addr);
- char *last = PGROUNDDOWN(addr + sz - 1);
- char *a;
- for(a = first; a <= last; a += PGSIZE){
- pte_t *pte = walkpgdir(pgdir, a, 0);
- if(pte == 0 || (*pte & PTE_P) == 0){
- char *mem = kalloc();
- if(mem == 0){
- // XXX clean up?
- return 0;
- }
- memset(mem, 0, PGSIZE);
- mappages(pgdir, a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
+ if(newsz < oldsz)
+ return oldsz;
+
+ a = PGROUNDUP(oldsz);
+ for(; a < newsz; a += PGSIZE){
+ mem = kalloc();
+ if(mem == 0){
+ cprintf("allocuvm out of memory\n");
+ deallocuvm(pgdir, newsz, oldsz);
+ return 0;
}
+ memset(mem, 0, PGSIZE);
+ mappages(pgdir, (char*)a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
}
- return 1;
+ return newsz;
}
-// deallocate some of the user pages, in response to sbrk()
-// with a negative argument. if addr is not page-aligned,
-// then only deallocates starting at the next page boundary.
+// Deallocate user pages to bring the process size from oldsz to
+// newsz. oldsz and newsz need not be page-aligned, nor does newsz
+// need to be less than oldsz. oldsz can be larger than the actual
+// process size. Returns the new process size.
int
-deallocuvm(pde_t *pgdir, char *addr, uint sz)
+deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
- if (addr + sz > (char*)USERTOP)
- return 0;
- char *first = (char*) PGROUNDUP((uint)addr);
- char *last = PGROUNDDOWN(addr + sz - 1);
- char *a;
- for(a = first; a <= last; a += PGSIZE){
- pte_t *pte = walkpgdir(pgdir, a, 0);
+ pte_t *pte;
+ uint a, pa;
+
+ if(newsz >= oldsz)
+ return oldsz;
+
+ a = PGROUNDUP(newsz);
+ for(; a < oldsz; a += PGSIZE){
+ pte = walkpgdir(pgdir, (char*)a, 0);
if(pte && (*pte & PTE_P) != 0){
- uint pa = PTE_ADDR(*pte);
+ pa = PTE_ADDR(*pte);
if(pa == 0)
- panic("deallocuvm");
- kfree((void *) pa);
+ panic("kfree");
+ kfree((char*)pa);
*pte = 0;
}
}
- return 1;
+ return newsz;
}
-// free a page table and all the physical memory pages
+// Free a page table and all the physical memory pages
// in the user part.
void
freevm(pde_t *pgdir)
{
- uint i, j, da;
-
- if (!pgdir)
- panic("freevm: no pgdir\n");
- for (i = 0; i < NPDENTRIES; i++) {
- da = PTE_ADDR(pgdir[i]);
- if (da != 0) {
- pte_t *pgtab = (pte_t*) da;
- for (j = 0; j < NPTENTRIES; j++) {
- if (pgtab[j] != 0) {
- uint pa = PTE_ADDR(pgtab[j]);
- uint va = PGADDR(i, j, 0);
- if (va < USERTOP) // user memory
- kfree((void *) pa);
- pgtab[j] = 0;
- }
- }
- kfree((void *) da);
- pgdir[i] = 0;
- }
- }
- kfree((void *) pgdir);
-}
-
-int
-loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
-{
- uint i, pa, n;
- pte_t *pte;
-
- if ((uint)addr % PGSIZE != 0)
- panic("loaduvm: addr must be page aligned\n");
- for (i = 0; i < sz; i += PGSIZE) {
- if (!(pte = walkpgdir(pgdir, addr+i, 0)))
- panic("loaduvm: address should exist\n");
- pa = PTE_ADDR(*pte);
- if (sz - i < PGSIZE) n = sz - i;
- else n = PGSIZE;
- if(readi(ip, (char *)pa, offset+i, n) != n)
- return 0;
+ uint i;
+
+ if(pgdir == 0)
+ panic("freevm: no pgdir");
+ deallocuvm(pgdir, USERTOP, 0);
+ for(i = 0; i < NPDENTRIES; i++){
+ if(pgdir[i] & PTE_P)
+ kfree((char*)PTE_ADDR(pgdir[i]));
}
- return 1;
+ kfree((char*)pgdir);
}
-void
-inituvm(pde_t *pgdir, char *addr, char *init, uint sz)
-{
- uint i, pa, n, off;
- pte_t *pte;
-
- for (i = 0; i < sz; i += PGSIZE) {
- if (!(pte = walkpgdir(pgdir, (void *)(i+addr), 0)))
- panic("inituvm: pte should exist\n");
- off = (i+(uint)addr) % PGSIZE;
- pa = PTE_ADDR(*pte);
- if (sz - i < PGSIZE) n = sz - i;
- else n = PGSIZE;
- memmove((char *)pa+off, init+i, n);
- }
-}
-
-// given a parent process's page table, create a copy
+// Given a parent process's page table, create a copy
// of it for a child.
pde_t*
copyuvm(pde_t *pgdir, uint sz)
{
- pde_t *d = setupkvm();
+ pde_t *d;
pte_t *pte;
uint pa, i;
char *mem;
- if (!d) return 0;
- for (i = 0; i < sz; i += PGSIZE) {
- if (!(pte = walkpgdir(pgdir, (void *)i, 0)))
- panic("copyuvm: pte should exist\n");
- if(*pte & PTE_P){
- pa = PTE_ADDR(*pte);
- if (!(mem = kalloc()))
- return 0;
- memmove(mem, (char *)pa, PGSIZE);
- if (!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
- return 0;
- }
+ if((d = setupkvm()) == 0)
+ return 0;
+ for(i = 0; i < sz; i += PGSIZE){
+ if((pte = walkpgdir(pgdir, (void*)i, 0)) == 0)
+ panic("copyuvm: pte should exist");
+ if(!(*pte & PTE_P))
+ panic("copyuvm: page not present");
+ pa = PTE_ADDR(*pte);
+ if((mem = kalloc()) == 0)
+ goto bad;
+ memmove(mem, (char*)pa, PGSIZE);
+ if(mappages(d, (void*)i, PGSIZE, PADDR(mem), PTE_W|PTE_U) < 0)
+ goto bad;
}
return d;
-}
-// Gather information about physical memory layout.
-// Called once during boot.
-// Really should find out how much physical memory
-// there is rather than assuming PHYSTOP.
-void
-pminit(void)
-{
- extern char end[];
- struct proghdr *ph;
- struct elfhdr *elf = (struct elfhdr*)0x10000; // scratch space
-
- if (elf->magic != ELF_MAGIC || elf->phnum != 2)
- panic("pminit: need a text and data segment\n");
-
- ph = (struct proghdr*)((uchar*)elf + elf->phoff);
- kernend = ((uint)end + PGSIZE) & ~(PGSIZE-1);
- kerntext = ph[0].va;
- kerndata = ph[1].va;
- kerntsz = ph[0].memsz;
- kerndsz = ph[1].memsz;
- freesz = PHYSTOP - kernend;
-
- kinit((char *)kernend, freesz);
+bad:
+ freevm(d);
+ return 0;
}
-// Allocate one page table for the machine for the kernel address
-// space for scheduler processes.
-void
-kvmalloc(void)
+//PAGEBREAK!
+// Map user virtual address to kernel physical address.
+char*
+uva2ka(pde_t *pgdir, char *uva)
{
- kpgdir = setupkvm();
+ pte_t *pte;
+
+ pte = walkpgdir(pgdir, uva, 0);
+ if((*pte & PTE_P) == 0)
+ return 0;
+ if((*pte & PTE_U) == 0)
+ return 0;
+ return (char*)PTE_ADDR(*pte);
}
-// Turn on paging.
-void
-vmenable(void)
+// Copy len bytes from p to user address va in page table pgdir.
+// Most useful when pgdir is not the current page table.
+// uva2ka ensures this only works for PTE_U pages.
+int
+copyout(pde_t *pgdir, uint va, void *p, uint len)
{
- uint cr0;
-
- switchkvm(); // load kpgdir into cr3
- cr0 = rcr0();
- cr0 |= CR0_PG;
- lcr0(cr0);
+ char *buf, *pa0;
+ uint n, va0;
+
+ buf = (char*)p;
+ while(len > 0){
+ va0 = (uint)PGROUNDDOWN(va);
+ pa0 = uva2ka(pgdir, (char*)va0);
+ if(pa0 == 0)
+ return -1;
+ n = PGSIZE - (va - va0);
+ if(n > len)
+ n = len;
+ memmove(pa0 + (va - va0), buf, n);
+ len -= n;
+ buf += n;
+ va = va0 + PGSIZE;
+ }
+ return 0;
}
-