From 8d774afb2d45592d85725474a704ac99b0624d2c Mon Sep 17 00:00:00 2001
From: Robert Morris <rtm@csail.mit.edu>
Date: Tue, 31 Aug 2010 15:39:25 -0400
Subject: no more pminit, or ELF header at 0x10000 kinit() knows about end and
 PHYSTOP map all of kernel read/write (rather than r/o instructions) thanks,
 austin

---
 vm.c | 45 ++++-----------------------------------------
 1 file changed, 4 insertions(+), 41 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 46d18fc..8a57ca9 100644
--- a/vm.c
+++ b/vm.c
@@ -17,8 +17,8 @@
 // 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)
+//   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
@@ -31,12 +31,6 @@
 
 #define USERTOP  0xA0000
 
-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
@@ -161,14 +155,8 @@ setupkvm(void)
   // 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))
+  // Map kernel and free memory pool
+  if (!mappages(pgdir, (void *)0x100000, PHYSTOP-0x100000, 0x100000, PTE_W))
     return 0;
   // Map devices such as ioapic, lapic, ...
   if (!mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
@@ -333,31 +321,6 @@ copyuvm(pde_t *pgdir, uint sz)
   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);
-}
-
 // Allocate one page table for the machine for the kernel address
 // space for scheduler processes.
 void
-- 
cgit v1.2.3


From dd645ef11911596d73d128c1da53579678c56aee Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Tue, 31 Aug 2010 21:49:49 -0400
Subject: Cleanup if allocuvm fails to alloc.  Add a test.

---
 vm.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 8a57ca9..95eeca8 100644
--- a/vm.c
+++ b/vm.c
@@ -195,7 +195,8 @@ allocuvm(pde_t *pgdir, char *addr, uint sz)
     if(pte == 0 || (*pte & PTE_P) == 0){
       char *mem = kalloc();
       if(mem == 0){
-        // XXX clean up?
+        cprintf("allocuvm out of memory\n");
+        deallocuvm(pgdir, addr, sz);
         return 0;
       }
       memset(mem, 0, PGSIZE);
-- 
cgit v1.2.3


From ba04b3e70e4f1916c777d62de53088d96b09579f Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Wed, 1 Sep 2010 00:27:12 -0400
Subject: Fix similar leak in copyuvm

---
 vm.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 95eeca8..a60c915 100644
--- a/vm.c
+++ b/vm.c
@@ -313,13 +313,17 @@ copyuvm(pde_t *pgdir, uint sz)
     if(*pte & PTE_P){
       pa = PTE_ADDR(*pte);
       if (!(mem = kalloc()))
-        return 0;
+        goto bad;
       memmove(mem, (char *)pa, PGSIZE);
       if (!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
-        return 0;
+        goto bad;
     }
   }
   return d;
+
+bad:
+  freevm(d);
+  return 0;
 }
 
 // Allocate one page table for the machine for the kernel address
-- 
cgit v1.2.3


From 5efca9054f1911e206831e16c2ca5ac8c8fc7c12 Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Wed, 1 Sep 2010 00:32:27 -0400
Subject: Tab police

---
 vm.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index a60c915..c3601a4 100644
--- a/vm.c
+++ b/vm.c
@@ -244,13 +244,13 @@ freevm(pde_t *pgdir)
     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
+        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;
-	}
+          pgtab[j] = 0;
+        }
       }
       kfree((void *) da);
       pgdir[i] = 0;
@@ -287,7 +287,7 @@ inituvm(pde_t *pgdir, char *addr, char *init, uint sz)
 
   for (i = 0; i < sz; i += PGSIZE) {
     if (!(pte = walkpgdir(pgdir, (void *)(i+addr), 0)))
-	panic("inituvm: pte should exist\n");
+      panic("inituvm: pte should exist\n");
     off = (i+(uint)addr) % PGSIZE;
     pa = PTE_ADDR(*pte);
     if (sz - i < PGSIZE) n = sz - i;
-- 
cgit v1.2.3


From b0751a3e9bfce88cb07c1a540ceabf21f2d53b31 Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Wed, 1 Sep 2010 00:41:25 -0400
Subject: Space police

---
 vm.c | 56 ++++++++++++++++++++++++++++----------------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index c3601a4..2f2b238 100644
--- a/vm.c
+++ b/vm.c
@@ -44,9 +44,9 @@ walkpgdir(pde_t *pgdir, const void *va, int create)
   pte_t *pgtab;
 
   pde = &pgdir[PDX(va)];
-  if (*pde & PTE_P) {
+  if(*pde & PTE_P){
     pgtab = (pte_t*) PTE_ADDR(*pde);
-  } else if (!create || !(r = (uint) kalloc()))
+  } else if(!create || !(r = (uint) kalloc()))
     return 0;
   else {
     pgtab = (pte_t*) r;
@@ -127,7 +127,7 @@ switchuvm(struct proc *p)
   cpu->ts.esp0 = (uint)proc->kstack + KSTACKSIZE;
   ltr(SEG_TSS << 3);
 
-  if (p->pgdir == 0)
+  if(p->pgdir == 0)
     panic("switchuvm: no pgdir\n");
 
   lcr3(PADDR(p->pgdir));  // switch to new address space
@@ -149,17 +149,17 @@ setupkvm(void)
   pde_t *pgdir;
 
   // Allocate page directory
-  if (!(pgdir = (pde_t *) kalloc()))
+  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))
+  if(!mappages(pgdir, (void *)USERTOP, 0x60000, USERTOP, PTE_W))
     return 0;
   // Map kernel and free memory pool
-  if (!mappages(pgdir, (void *)0x100000, PHYSTOP-0x100000, 0x100000, PTE_W))
+  if(!mappages(pgdir, (void *)0x100000, PHYSTOP-0x100000, 0x100000, PTE_W))
     return 0;
   // Map devices such as ioapic, lapic, ...
-  if (!mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
+  if(!mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
     return 0;
   return pgdir;
 }
@@ -172,7 +172,7 @@ char*
 uva2ka(pde_t *pgdir, char *uva)
 {    
   pte_t *pte = walkpgdir(pgdir, uva, 0);
-  if (pte == 0) return 0;
+  if(pte == 0) return 0;
   uint pa = PTE_ADDR(*pte);
   return (char *)pa;
 }
@@ -185,7 +185,7 @@ uva2ka(pde_t *pgdir, char *uva)
 int
 allocuvm(pde_t *pgdir, char *addr, uint sz)
 {
-  if (addr + sz > (char*)USERTOP)
+  if(addr + sz > (char*)USERTOP)
     return 0;
   char *first = PGROUNDDOWN(addr);
   char *last = PGROUNDDOWN(addr + sz - 1);
@@ -212,7 +212,7 @@ allocuvm(pde_t *pgdir, char *addr, uint sz)
 int
 deallocuvm(pde_t *pgdir, char *addr, uint sz)
 {
-  if (addr + sz > (char*)USERTOP)
+  if(addr + sz > (char*)USERTOP)
     return 0;
   char *first = (char*) PGROUNDUP((uint)addr);
   char *last = PGROUNDDOWN(addr + sz - 1);
@@ -237,17 +237,17 @@ freevm(pde_t *pgdir)
 {
   uint i, j, da;
 
-  if (!pgdir)
+  if(!pgdir)
     panic("freevm: no pgdir\n");
-  for (i = 0; i < NPDENTRIES; i++) {
+  for(i = 0; i < NPDENTRIES; i++){
     da = PTE_ADDR(pgdir[i]);
-    if (da != 0) {
+    if(da != 0){
       pte_t *pgtab = (pte_t*) da;
-      for (j = 0; j < NPTENTRIES; j++) {
-        if (pgtab[j] != 0) {
+      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
+          if(va < USERTOP)   // user memory
             kfree((void *) pa);
           pgtab[j] = 0;
         }
@@ -265,13 +265,13 @@ 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)
+  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)))
+  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;
+    if(sz - i < PGSIZE) n = sz - i;
     else n = PGSIZE;
     if(readi(ip, (char *)pa, offset+i, n) != n)
       return 0;
@@ -285,12 +285,12 @@ 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)))
+  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;
+    if(sz - i < PGSIZE) n = sz - i;
     else n = PGSIZE;
     memmove((char *)pa+off, init+i, n);
   }
@@ -306,16 +306,16 @@ copyuvm(pde_t *pgdir, uint sz)
   uint pa, i;
   char *mem;
 
-  if (!d) return 0;
-  for (i = 0; i < sz; i += PGSIZE) {
-    if (!(pte = walkpgdir(pgdir, (void *)i, 0)))
+  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()))
+      if(!(mem = kalloc()))
         goto bad;
       memmove(mem, (char *)pa, PGSIZE);
-      if (!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
+      if(!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
         goto bad;
     }
   }
-- 
cgit v1.2.3


From d3ecf3eb44379f12b47da9d08e4d1b52cf7c2601 Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Wed, 1 Sep 2010 17:14:58 -0400
Subject: Slight simplification of copyuvm.  We could simplify other things now
 that processes are contiguous, but we'd have to think harder about the error
 paths.

---
 vm.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 2f2b238..8cfac14 100644
--- a/vm.c
+++ b/vm.c
@@ -310,14 +310,14 @@ copyuvm(pde_t *pgdir, uint sz)
   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()))
-        goto bad;
-      memmove(mem, (char *)pa, PGSIZE);
-      if(!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
-        goto bad;
-    }
+    if(!(*pte & PTE_P))
+      panic("copyuvm: page not present\n");
+    pa = PTE_ADDR(*pte);
+    if(!(mem = kalloc()))
+      goto bad;
+    memmove(mem, (char *)pa, PGSIZE);
+    if(!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
+      goto bad;
   }
   return d;
 
-- 
cgit v1.2.3


From b3cfd7fc372424d754f5478c93f6fbe756d9c80f Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Thu, 2 Sep 2010 15:18:19 -0400
Subject: Simplify freevm using deallocuvm

---
 vm.c | 25 ++++++-------------------
 1 file changed, 6 insertions(+), 19 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 8cfac14..12aebe5 100644
--- a/vm.c
+++ b/vm.c
@@ -206,8 +206,7 @@ allocuvm(pde_t *pgdir, char *addr, uint sz)
   return 1;
 }
 
-// deallocate some of the user pages, in response to sbrk()
-// with a negative argument. if addr is not page-aligned,
+// deallocate some of the user pages. if addr is not page-aligned,
 // then only deallocates starting at the next page boundary.
 int
 deallocuvm(pde_t *pgdir, char *addr, uint sz)
@@ -235,26 +234,14 @@ deallocuvm(pde_t *pgdir, char *addr, uint sz)
 void
 freevm(pde_t *pgdir)
 {
-  uint i, j, da;
+  uint i;
 
   if(!pgdir)
-    panic("freevm: no pgdir\n");
+    panic("freevm: no pgdir");
+  deallocuvm(pgdir, 0, USERTOP);
   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;
-    }
+    if(pgdir[i] & PTE_P)
+      kfree((void *) PTE_ADDR(pgdir[i]));
   }
   kfree((void *) pgdir);
 }
-- 
cgit v1.2.3


From f53e6110bed159c8541c6e0d2fc1b1ffac2d141a Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Thu, 2 Sep 2010 15:37:05 -0400
Subject: Simplify inituvm and userinit by assuming initcode fits on a page

---
 vm.c | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 12aebe5..9c0783d 100644
--- a/vm.c
+++ b/vm.c
@@ -267,20 +267,14 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
 }
 
 void
-inituvm(pde_t *pgdir, char *addr, char *init, uint sz)
+inituvm(pde_t *pgdir, 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);
-  }
+  char *mem = kalloc();
+  if (sz >= PGSIZE)
+    panic("inituvm: more than a page");
+  memset(mem, 0, PGSIZE);
+  mappages(pgdir, 0, PGSIZE, PADDR(mem), PTE_W|PTE_U);
+  memmove(mem, init, sz);
 }
 
 // given a parent process's page table, create a copy
-- 
cgit v1.2.3


From f25a3f9a41de02116c39b0e65243d111e1cb1026 Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Thu, 2 Sep 2010 16:23:15 -0400
Subject: Rearrange vm.c so it's in logical order and prints nicely.  Shorten a
 few functions in uninteresting ways to make them fit.

---
 vm.c | 264 +++++++++++++++++++++++++++++++++----------------------------------
 1 file changed, 129 insertions(+), 135 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 9c0783d..f3436b7 100644
--- a/vm.c
+++ b/vm.c
@@ -6,33 +6,38 @@
 #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..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).
-
 #define USERTOP  0xA0000
 
 static pde_t *kpgdir;  // for use in scheduler()
 
+// Set up CPU's kernel segment descriptors.
+// Run once at boot time on each CPU.
+void
+ksegment(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.
@@ -50,10 +55,8 @@ walkpgdir(pde_t *pgdir, const void *va, int create)
     return 0;
   else {
     pgtab = (pte_t*) r;
-
     // 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.
@@ -68,9 +71,9 @@ walkpgdir(pde_t *pgdir, const void *va, int create)
 static int
 mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
 {
-  char *first = PGROUNDDOWN(la);
+  char *a = PGROUNDDOWN(la);
   char *last = PGROUNDDOWN(la + size - 1);
-  char *a = first;
+
   while(1){
     pte_t *pte = walkpgdir(pgdir, a, 1);
     if(pte == 0)
@@ -86,32 +89,75 @@ mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
   return 1;
 }
 
-// Set up CPU's kernel segment descriptors.
-// Run once at boot time on each CPU.
+// 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).
+
+// Allocate one page table for the machine for the kernel address
+// space for scheduler processes.
 void
-ksegment(void)
+kvmalloc(void)
 {
-  struct cpu *c;
+  kpgdir = setupkvm();
+}
 
-  // 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);
+// Set up kernel part of a page table.
+pde_t*
+setupkvm(void)
+{
+  pde_t *pgdir;
 
-  // map cpu, and curproc
-  c->gdt[SEG_KCPU] = SEG(STA_W, &c->cpu, 8, 0);
+  // Allocate page directory
+  if(!(pgdir = (pde_t *) kalloc()))
+    return 0;
+  memset(pgdir, 0, PGSIZE);
+  if(// Map IO space from 640K to 1Mbyte
+     !mappages(pgdir, (void *)USERTOP, 0x60000, USERTOP, PTE_W) ||
+     // Map kernel and free memory pool
+     !mappages(pgdir, (void *)0x100000, PHYSTOP-0x100000, 0x100000, PTE_W) ||
+     // Map devices such as ioapic, lapic, ...
+     !mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
+    return 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 register to the kernel-only page table, for when
+// no process is running.
+void
+switchkvm()
+{
+  lcr3(PADDR(kpgdir));   // Switch to the kernel page table
 }
 
 // Switch h/w page table and TSS registers to point to process p.
@@ -134,36 +180,6 @@ switchuvm(struct proc *p)
   popcli();
 }
 
-// Switch h/w page table register to the kernel-only page table, for when
-// no process is running.
-void
-switchkvm()
-{
-  lcr3(PADDR(kpgdir));   // Switch to the kernel page table
-}
-
-// Set up kernel part of a page table.
-pde_t*
-setupkvm(void)
-{
-  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 and free memory pool
-  if(!mappages(pgdir, (void *)0x100000, PHYSTOP-0x100000, 0x100000, PTE_W))
-    return 0;
-  // Map devices such as ioapic, lapic, ...
-  if(!mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
-    return 0;
-  return pgdir;
-}
-
 // 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
@@ -177,6 +193,37 @@ uva2ka(pde_t *pgdir, char *uva)
   return (char *)pa;
 }
 
+void
+inituvm(pde_t *pgdir, char *init, uint sz)
+{
+  char *mem = kalloc();
+  if (sz >= PGSIZE)
+    panic("inituvm: more than a page");
+  memset(mem, 0, PGSIZE);
+  mappages(pgdir, 0, PGSIZE, PADDR(mem), PTE_W|PTE_U);
+  memmove(mem, init, sz);
+}
+
+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;
+  }
+  return 1;
+}
+
 // 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.
@@ -187,10 +234,9 @@ allocuvm(pde_t *pgdir, char *addr, uint sz)
 {
   if(addr + sz > (char*)USERTOP)
     return 0;
-  char *first = PGROUNDDOWN(addr);
+  char *a = PGROUNDDOWN(addr);
   char *last = PGROUNDDOWN(addr + sz - 1);
-  char *a;
-  for(a = first; a <= last; a += PGSIZE){
+  for(; a <= last; a += PGSIZE){
     pte_t *pte = walkpgdir(pgdir, a, 0);
     if(pte == 0 || (*pte & PTE_P) == 0){
       char *mem = kalloc();
@@ -213,10 +259,9 @@ deallocuvm(pde_t *pgdir, char *addr, uint sz)
 {
   if(addr + sz > (char*)USERTOP)
     return 0;
-  char *first = (char*) PGROUNDUP((uint)addr);
+  char *a = (char *)PGROUNDUP((uint)addr);
   char *last = PGROUNDDOWN(addr + sz - 1);
-  char *a;
-  for(a = first; a <= last; a += PGSIZE){
+  for(; a <= last; a += PGSIZE){
     pte_t *pte = walkpgdir(pgdir, a, 0);
     if(pte && (*pte & PTE_P) != 0){
       uint pa = PTE_ADDR(*pte);
@@ -246,37 +291,6 @@ freevm(pde_t *pgdir)
   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;
-  }
-  return 1;
-}
-
-void
-inituvm(pde_t *pgdir, char *init, uint sz)
-{
-  char *mem = kalloc();
-  if (sz >= PGSIZE)
-    panic("inituvm: more than a page");
-  memset(mem, 0, PGSIZE);
-  mappages(pgdir, 0, PGSIZE, PADDR(mem), PTE_W|PTE_U);
-  memmove(mem, init, sz);
-}
-
 // given a parent process's page table, create a copy
 // of it for a child.
 pde_t*
@@ -307,23 +321,3 @@ bad:
   return 0;
 }
 
-// Allocate one page table for the machine for the kernel address
-// space for scheduler processes.
-void
-kvmalloc(void)
-{
-  kpgdir = setupkvm();
-}
-
-// Turn on paging.
-void
-vmenable(void)
-{
-  uint cr0;
-
-  switchkvm(); // load kpgdir into cr3
-  cr0 = rcr0();
-  cr0 |= CR0_PG;
-  lcr0(cr0);
-}
-
-- 
cgit v1.2.3


From 93a1e4cb07e329dc9550643f7fe8430da547497a Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Thu, 2 Sep 2010 16:36:38 -0400
Subject: Fix comment capitalization

---
 vm.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index f3436b7..2a57faf 100644
--- a/vm.c
+++ b/vm.c
@@ -27,7 +27,7 @@ ksegment(void)
   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
+  // Map cpu, and curproc
   c->gdt[SEG_KCPU] = SEG(STA_W, &c->cpu, 8, 0);
 
   lgdt(c->gdt, sizeof(c->gdt));
@@ -38,8 +38,8 @@ ksegment(void)
   proc = 0;
 }
 
-// return the address of the PTE in page table pgdir
-// that corresponds to linear address va.  if create!=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)
@@ -65,7 +65,7 @@ walkpgdir(pde_t *pgdir, const void *va, int create)
   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
@@ -152,12 +152,12 @@ vmenable(void)
   lcr0(cr0);
 }
 
-// Switch h/w page table register to the kernel-only page table, for when
-// no process is running.
+// Switch h/w page table register to the kernel-only page table,
+// for when no process is running.
 void
 switchkvm()
 {
-  lcr3(PADDR(kpgdir));   // Switch to the kernel page table
+  lcr3(PADDR(kpgdir));   // switch to the kernel page table
 }
 
 // Switch h/w page table and TSS registers to point to process p.
@@ -180,8 +180,8 @@ switchuvm(struct proc *p)
   popcli();
 }
 
-// return the physical address that a given user address
-// maps to. the result is also a kernel logical address,
+// 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*
@@ -224,10 +224,10 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
   return 1;
 }
 
-// allocate sz bytes more memory for a process starting at the
+// 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
+// It is a no-op for any parts of the requested memory
 // that are already allocated.
 int
 allocuvm(pde_t *pgdir, char *addr, uint sz)
@@ -252,7 +252,7 @@ allocuvm(pde_t *pgdir, char *addr, uint sz)
   return 1;
 }
 
-// deallocate some of the user pages. if addr is not page-aligned,
+// Deallocate some of the user pages. If addr is not page-aligned,
 // then only deallocates starting at the next page boundary.
 int
 deallocuvm(pde_t *pgdir, char *addr, uint sz)
@@ -274,7 +274,7 @@ deallocuvm(pde_t *pgdir, char *addr, uint sz)
   return 1;
 }
 
-// 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)
@@ -291,7 +291,7 @@ freevm(pde_t *pgdir)
   kfree((void *) pgdir);
 }
 
-// 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)
-- 
cgit v1.2.3


From 9a4670a138f7ab25062195be2f4d42403dddc077 Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Thu, 2 Sep 2010 16:39:55 -0400
Subject: Comment inituvm and loaduvm

---
 vm.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 2a57faf..0104c3e 100644
--- a/vm.c
+++ b/vm.c
@@ -193,6 +193,8 @@ uva2ka(pde_t *pgdir, char *uva)
   return (char *)pa;
 }
 
+// Load the initcode into address 0 of pgdir.
+// sz must be less than a page.
 void
 inituvm(pde_t *pgdir, char *init, uint sz)
 {
@@ -204,6 +206,8 @@ inituvm(pde_t *pgdir, char *init, uint sz)
   memmove(mem, init, sz);
 }
 
+// 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)
 {
-- 
cgit v1.2.3


From 79cd8b3eedeb1f85d3b19fb6119bd5224c4c532a Mon Sep 17 00:00:00 2001
From: Austin Clements <amdragon@mit.edu>
Date: Thu, 2 Sep 2010 18:28:36 -0400
Subject: Simplify allocuvm/deallocuvm to operate in a contiguous memory model.
  This makes their interface match up better with proc->sz and also simplifies
 the callers (it even gets the main body of exec on one page).

---
 vm.c | 58 +++++++++++++++++++++++++++-------------------------------
 1 file changed, 27 insertions(+), 31 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 0104c3e..5c6f943 100644
--- a/vm.c
+++ b/vm.c
@@ -228,54 +228,50 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
   return 1;
 }
 
-// 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 memory to the process to bring its size from oldsz to
+// newsz. Allocates physical memory and page table entries. oldsz and
+// newsz need not be page-aligned, nor does newsz have to be larger
+// than oldsz.  Returns the new process 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)
+  if(newsz > USERTOP)
     return 0;
-  char *a = PGROUNDDOWN(addr);
-  char *last = PGROUNDDOWN(addr + sz - 1);
-  for(; a <= last; a += PGSIZE){
-    pte_t *pte = walkpgdir(pgdir, a, 0);
-    if(pte == 0 || (*pte & PTE_P) == 0){
-      char *mem = kalloc();
-      if(mem == 0){
-        cprintf("allocuvm out of memory\n");
-        deallocuvm(pgdir, addr, sz);
-        return 0;
-      }
-      memset(mem, 0, PGSIZE);
-      mappages(pgdir, a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
+  char *a = (char *)PGROUNDUP(oldsz);
+  char *last = PGROUNDDOWN(newsz - 1);
+  for (; a <= last; a += PGSIZE){
+    char *mem = kalloc();
+    if(mem == 0){
+      cprintf("allocuvm out of memory\n");
+      deallocuvm(pgdir, newsz, oldsz);
+      return 0;
     }
+    memset(mem, 0, PGSIZE);
+    mappages(pgdir, a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
   }
-  return 1;
+  return newsz > oldsz ? newsz : oldsz;
 }
 
-// Deallocate some of the user pages. 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 *a = (char *)PGROUNDUP((uint)addr);
-  char *last = PGROUNDDOWN(addr + sz - 1);
+  char *a = (char *)PGROUNDUP(newsz);
+  char *last = PGROUNDDOWN(oldsz - 1);
   for(; a <= last; a += PGSIZE){
     pte_t *pte = walkpgdir(pgdir, a, 0);
     if(pte && (*pte & PTE_P) != 0){
       uint pa = PTE_ADDR(*pte);
       if(pa == 0)
-        panic("deallocuvm");
+        panic("kfree");
       kfree((void *) pa);
       *pte = 0;
     }
   }
-  return 1;
+  return newsz < oldsz ? newsz : oldsz;
 }
 
 // Free a page table and all the physical memory pages
@@ -287,7 +283,7 @@ freevm(pde_t *pgdir)
 
   if(!pgdir)
     panic("freevm: no pgdir");
-  deallocuvm(pgdir, 0, USERTOP);
+  deallocuvm(pgdir, USERTOP, 0);
   for(i = 0; i < NPDENTRIES; i++){
     if(pgdir[i] & PTE_P)
       kfree((void *) PTE_ADDR(pgdir[i]));
-- 
cgit v1.2.3


From faad047ab22cbe989c208bff5ecb42608ecb8d7b Mon Sep 17 00:00:00 2001
From: Robert Morris <rtm@csail.mit.edu>
Date: Mon, 13 Sep 2010 15:34:44 -0400
Subject: change some comments, maybe more informative delete most comments
 from bootother.S (since copy of bootasm.S) ksegment() -> seginit() move more
 stuff from main() to mainc()

---
 vm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 5c6f943..c57fa53 100644
--- a/vm.c
+++ b/vm.c
@@ -13,7 +13,7 @@ static pde_t *kpgdir;  // for use in scheduler()
 // Set up CPU's kernel segment descriptors.
 // Run once at boot time on each CPU.
 void
-ksegment(void)
+seginit(void)
 {
   struct cpu *c;
 
-- 
cgit v1.2.3


From a9183883b88bfccd1c6a62e27621b2c892d50b67 Mon Sep 17 00:00:00 2001
From: Robert Morris <rtm@csail.mit.edu>
Date: Mon, 20 Sep 2010 06:00:22 -0400
Subject: map kernel instructions r/o

---
 vm.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index c57fa53..cd6b255 100644
--- a/vm.c
+++ b/vm.c
@@ -125,6 +125,9 @@ pde_t*
 setupkvm(void)
 {
   pde_t *pgdir;
+  extern char etext[];
+  char *rwstart = PGROUNDDOWN(etext) - PGSIZE;
+  uint rwlen = (uint)rwstart - 0x100000;
 
   // Allocate page directory
   if(!(pgdir = (pde_t *) kalloc()))
@@ -132,8 +135,10 @@ setupkvm(void)
   memset(pgdir, 0, PGSIZE);
   if(// Map IO space from 640K to 1Mbyte
      !mappages(pgdir, (void *)USERTOP, 0x60000, USERTOP, PTE_W) ||
-     // Map kernel and free memory pool
-     !mappages(pgdir, (void *)0x100000, PHYSTOP-0x100000, 0x100000, PTE_W) ||
+     // Map kernel instructions
+     !mappages(pgdir, (void *)0x100000, rwlen, 0x100000, 0) ||
+     // Map kernel data and free memory pool
+     !mappages(pgdir, rwstart, PHYSTOP-(uint)rwstart, (uint)rwstart, PTE_W) ||
      // Map devices such as ioapic, lapic, ...
      !mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
     return 0;
-- 
cgit v1.2.3


From 4655d42e3b65f906eae8c815fb78331790f6e423 Mon Sep 17 00:00:00 2001
From: Robert Morris <rtm@csail.mit.edu>
Date: Mon, 27 Sep 2010 16:14:33 -0400
Subject: copyout() copies data to a va in a pagetable, for exec() &c usertest
 that passes too many arguments, break exec

---
 vm.c | 32 ++++++++++++++++++++++++++++----
 1 file changed, 28 insertions(+), 4 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index cd6b255..551efbf 100644
--- a/vm.c
+++ b/vm.c
@@ -6,8 +6,6 @@
 #include "proc.h"
 #include "elf.h"
 
-#define USERTOP  0xA0000
-
 static pde_t *kpgdir;  // for use in scheduler()
 
 // Set up CPU's kernel segment descriptors.
@@ -126,7 +124,7 @@ setupkvm(void)
 {
   pde_t *pgdir;
   extern char etext[];
-  char *rwstart = PGROUNDDOWN(etext) - PGSIZE;
+  char *rwstart = PGROUNDDOWN(etext);
   uint rwlen = (uint)rwstart - 0x100000;
 
   // Allocate page directory
@@ -193,7 +191,10 @@ char*
 uva2ka(pde_t *pgdir, char *uva)
 {    
   pte_t *pte = walkpgdir(pgdir, uva, 0);
-  if(pte == 0) return 0;
+  if((*pte & PTE_P) == 0)
+    return 0;
+  if((*pte & PTE_U) == 0)
+    return 0;
   uint pa = PTE_ADDR(*pte);
   return (char *)pa;
 }
@@ -326,3 +327,26 @@ bad:
   return 0;
 }
 
+// copy some data to user address va in page table pgdir.
+// most useful when pgdir is not the current page table.
+// returns 1 if everthing OK, 0 on error.
+// uva2ka ensures this only works for PTE_U pages.
+int
+copyout(pde_t *pgdir, uint va, void *xbuf, uint len)
+{
+  char *buf = (char *) xbuf;
+  while(len > 0){
+    uint va0 = (uint)PGROUNDDOWN(va);
+    char *pa0 = uva2ka(pgdir, (char*) va0);
+    if(pa0 == 0)
+      return 0;
+    uint n = PGSIZE - (va - va0);
+    if(n > len)
+      n = len;
+    memmove(pa0 + (va - va0), buf, n);
+    len -= n;
+    buf += n;
+    va = va0 + PGSIZE;
+  }
+  return 1;
+}
-- 
cgit v1.2.3


From 1a81e38b17144624415d252a521fd5a06079d681 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@swtch.com>
Date: Tue, 11 Jan 2011 13:01:13 -0500
Subject: make new code like old code

Variable declarations at top of function,
separate from initialization.

Use == 0 instead of ! for checking pointers.

Consistent spacing around {, *, casts.

Declare 0-parameter functions as (void) not ().

Integer valued functions return -1 on failure, 0 on success.
---
 vm.c | 143 +++++++++++++++++++++++++++++++++++++++----------------------------
 1 file changed, 84 insertions(+), 59 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 551efbf..940cc2f 100644
--- a/vm.c
+++ b/vm.c
@@ -42,23 +42,21 @@ seginit(void)
 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;
+    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)];
 }
@@ -69,13 +67,16 @@ walkpgdir(pde_t *pgdir, const void *va, int create)
 static int
 mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
 {
-  char *a = PGROUNDDOWN(la);
-  char *last = PGROUNDDOWN(la + size - 1);
+  char *a, *last;
+  pte_t *pte;
+  
+  a = PGROUNDDOWN(la);
+  last = PGROUNDDOWN(la + size - 1);
 
-  while(1){
-    pte_t *pte = walkpgdir(pgdir, a, 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;
@@ -84,7 +85,7 @@ mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
     a += PGSIZE;
     pa += PGSIZE;
   }
-  return 1;
+  return 0;
 }
 
 // The mappings from logical to linear are one to one (i.e.,
@@ -122,23 +123,26 @@ kvmalloc(void)
 pde_t*
 setupkvm(void)
 {
-  pde_t *pgdir;
   extern char etext[];
-  char *rwstart = PGROUNDDOWN(etext);
-  uint rwlen = (uint)rwstart - 0x100000;
+  char *rwstart;
+  pde_t *pgdir;
+  uint rwlen;
+
+  rwstart = PGROUNDDOWN(etext);
+  rwlen = (uint)rwstart - 0x100000;
 
   // Allocate page directory
-  if(!(pgdir = (pde_t *) kalloc()))
+  if((pgdir = (pde_t*)kalloc()) == 0)
     return 0;
   memset(pgdir, 0, PGSIZE);
   if(// Map IO space from 640K to 1Mbyte
-     !mappages(pgdir, (void *)USERTOP, 0x60000, USERTOP, PTE_W) ||
+     mappages(pgdir, (void*)USERTOP, 0x60000, USERTOP, PTE_W) < 0 ||
      // Map kernel instructions
-     !mappages(pgdir, (void *)0x100000, rwlen, 0x100000, 0) ||
+     mappages(pgdir, (void*)0x100000, rwlen, 0x100000, 0) < 0 ||
      // Map kernel data and free memory pool
-     !mappages(pgdir, rwstart, PHYSTOP-(uint)rwstart, (uint)rwstart, PTE_W) ||
+     mappages(pgdir, rwstart, PHYSTOP-(uint)rwstart, (uint)rwstart, PTE_W) < 0 ||
      // Map devices such as ioapic, lapic, ...
-     !mappages(pgdir, (void *)0xFE000000, 0x2000000, 0xFE000000, PTE_W))
+     mappages(pgdir, (void*)0xFE000000, 0x2000000, 0xFE000000, PTE_W) < 0)
     return 0;
   return pgdir;
 }
@@ -189,14 +193,15 @@ switchuvm(struct proc *p)
 // processes directly.
 char*
 uva2ka(pde_t *pgdir, char *uva)
-{    
-  pte_t *pte = walkpgdir(pgdir, uva, 0);
+{
+  pte_t *pte;
+
+  pte = walkpgdir(pgdir, uva, 0);
   if((*pte & PTE_P) == 0)
     return 0;
   if((*pte & PTE_U) == 0)
     return 0;
-  uint pa = PTE_ADDR(*pte);
-  return (char *)pa;
+  return (char*)PTE_ADDR(*pte);
 }
 
 // Load the initcode into address 0 of pgdir.
@@ -204,9 +209,11 @@ uva2ka(pde_t *pgdir, char *uva)
 void
 inituvm(pde_t *pgdir, char *init, uint sz)
 {
-  char *mem = kalloc();
-  if (sz >= PGSIZE)
+  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);
@@ -223,15 +230,17 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
   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)))
+    if((pte = walkpgdir(pgdir, addr+i, 0)) == 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;
+    if(sz - i < PGSIZE)
+      n = sz - i;
+    else
+      n = PGSIZE;
+    if(readi(ip, (char*)pa, offset+i, n) != n)
+      return -1;
   }
-  return 1;
+  return 0;
 }
 
 // Allocate memory to the process to bring its size from oldsz to
@@ -241,12 +250,17 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
 int
 allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
 {
+  char *a, *last, *mem;
+
   if(newsz > USERTOP)
     return 0;
-  char *a = (char *)PGROUNDUP(oldsz);
-  char *last = PGROUNDDOWN(newsz - 1);
-  for (; a <= last; a += PGSIZE){
-    char *mem = kalloc();
+  if(newsz < oldsz)
+    return oldsz;
+
+  a = (char*)PGROUNDUP(oldsz);
+  last = PGROUNDDOWN(newsz - 1);
+  for(; a <= last; a += PGSIZE){
+    mem = kalloc();
     if(mem == 0){
       cprintf("allocuvm out of memory\n");
       deallocuvm(pgdir, newsz, oldsz);
@@ -255,7 +269,7 @@ allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
     memset(mem, 0, PGSIZE);
     mappages(pgdir, a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
   }
-  return newsz > oldsz ? newsz : oldsz;
+  return newsz;
 }
 
 // Deallocate user pages to bring the process size from oldsz to
@@ -265,19 +279,26 @@ allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
 int
 deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
 {
-  char *a = (char *)PGROUNDUP(newsz);
-  char *last = PGROUNDDOWN(oldsz - 1);
+  char *a, *last;
+  pte_t *pte;
+  uint pa;
+
+  if(newsz >= oldsz)
+    return oldsz;
+
+  a = (char*)PGROUNDUP(newsz);
+  last = PGROUNDDOWN(oldsz - 1);
   for(; a <= last; a += PGSIZE){
-    pte_t *pte = walkpgdir(pgdir, a, 0);
+    pte = walkpgdir(pgdir, a, 0);
     if(pte && (*pte & PTE_P) != 0){
-      uint pa = PTE_ADDR(*pte);
+      pa = PTE_ADDR(*pte);
       if(pa == 0)
         panic("kfree");
-      kfree((void *) pa);
+      kfree((char*)pa);
       *pte = 0;
     }
   }
-  return newsz < oldsz ? newsz : oldsz;
+  return newsz;
 }
 
 // Free a page table and all the physical memory pages
@@ -287,14 +308,14 @@ freevm(pde_t *pgdir)
 {
   uint i;
 
-  if(!pgdir)
+  if(pgdir == 0)
     panic("freevm: no pgdir");
   deallocuvm(pgdir, USERTOP, 0);
   for(i = 0; i < NPDENTRIES; i++){
     if(pgdir[i] & PTE_P)
-      kfree((void *) PTE_ADDR(pgdir[i]));
+      kfree((char*)PTE_ADDR(pgdir[i]));
   }
-  kfree((void *) pgdir);
+  kfree((char*)pgdir);
 }
 
 // Given a parent process's page table, create a copy
@@ -302,22 +323,23 @@ freevm(pde_t *pgdir)
 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;
+  if((d = setupkvm()) == 0)
+    return 0;
   for(i = 0; i < sz; i += PGSIZE){
-    if(!(pte = walkpgdir(pgdir, (void *)i, 0)))
+    if((pte = walkpgdir(pgdir, (void*)i, 0)) == 0)
       panic("copyuvm: pte should exist\n");
     if(!(*pte & PTE_P))
       panic("copyuvm: page not present\n");
     pa = PTE_ADDR(*pte);
-    if(!(mem = kalloc()))
+    if((mem = kalloc()) == 0)
       goto bad;
-    memmove(mem, (char *)pa, PGSIZE);
-    if(!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
+    memmove(mem, (char*)pa, PGSIZE);
+    if(mappages(d, (void*)i, PGSIZE, PADDR(mem), PTE_W|PTE_U) < 0)
       goto bad;
   }
   return d;
@@ -334,13 +356,16 @@ bad:
 int
 copyout(pde_t *pgdir, uint va, void *xbuf, uint len)
 {
-  char *buf = (char *) xbuf;
+  char *buf, *pa0;
+  uint n, va0;
+  
+  buf = (char*)xbuf;
   while(len > 0){
-    uint va0 = (uint)PGROUNDDOWN(va);
-    char *pa0 = uva2ka(pgdir, (char*) va0);
+    va0 = (uint)PGROUNDDOWN(va);
+    pa0 = uva2ka(pgdir, (char*)va0);
     if(pa0 == 0)
-      return 0;
-    uint n = PGSIZE - (va - va0);
+      return -1;
+    n = PGSIZE - (va - va0);
     if(n > len)
       n = len;
     memmove(pa0 + (va - va0), buf, n);
@@ -348,5 +373,5 @@ copyout(pde_t *pgdir, uint va, void *xbuf, uint len)
     buf += n;
     va = va0 + PGSIZE;
   }
-  return 1;
+  return 0;
 }
-- 
cgit v1.2.3


From 417c37115e0c7fc3b2a65c3c4d213e566cbc8807 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@swtch.com>
Date: Tue, 11 Jan 2011 13:51:40 -0500
Subject: more trivial cleanup

---
 vm.c | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index 940cc2f..bfc0845 100644
--- a/vm.c
+++ b/vm.c
@@ -250,16 +250,16 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
 int
 allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
 {
-  char *a, *last, *mem;
+  char *mem;
+  uint a;
 
   if(newsz > USERTOP)
     return 0;
   if(newsz < oldsz)
     return oldsz;
 
-  a = (char*)PGROUNDUP(oldsz);
-  last = PGROUNDDOWN(newsz - 1);
-  for(; a <= last; a += PGSIZE){
+  a = PGROUNDUP(oldsz);
+  for(; a < newsz; a += PGSIZE){
     mem = kalloc();
     if(mem == 0){
       cprintf("allocuvm out of memory\n");
@@ -267,7 +267,7 @@ allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
       return 0;
     }
     memset(mem, 0, PGSIZE);
-    mappages(pgdir, a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
+    mappages(pgdir, (char*)a, PGSIZE, PADDR(mem), PTE_W|PTE_U);
   }
   return newsz;
 }
@@ -279,17 +279,15 @@ allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
 int
 deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
 {
-  char *a, *last;
   pte_t *pte;
-  uint pa;
+  uint a, pa;
 
   if(newsz >= oldsz)
     return oldsz;
 
-  a = (char*)PGROUNDUP(newsz);
-  last = PGROUNDDOWN(oldsz - 1);
-  for(; a <= last; a += PGSIZE){
-    pte = walkpgdir(pgdir, a, 0);
+  a = PGROUNDUP(newsz);
+  for(; a  < oldsz; a += PGSIZE){
+    pte = walkpgdir(pgdir, (char*)a, 0);
     if(pte && (*pte & PTE_P) != 0){
       pa = PTE_ADDR(*pte);
       if(pa == 0)
@@ -351,7 +349,6 @@ bad:
 
 // copy some data to user address va in page table pgdir.
 // most useful when pgdir is not the current page table.
-// returns 1 if everthing OK, 0 on error.
 // uva2ka ensures this only works for PTE_U pages.
 int
 copyout(pde_t *pgdir, uint va, void *xbuf, uint len)
-- 
cgit v1.2.3


From cf4b1ad90bcaeeb0c8458098c87948f61d408f94 Mon Sep 17 00:00:00 2001
From: Russ Cox <rsc@swtch.com>
Date: Sat, 19 Feb 2011 21:17:55 -0500
Subject: xv6: formatting, cleanup, rev5 (take 2)

---
 vm.c | 115 +++++++++++++++++++++++++++++++------------------------------------
 1 file changed, 54 insertions(+), 61 deletions(-)

(limited to 'vm.c')

diff --git a/vm.c b/vm.c
index bfc0845..1fe64d2 100644
--- a/vm.c
+++ b/vm.c
@@ -6,8 +6,18 @@
 #include "proc.h"
 #include "elf.h"
 
+extern char data[];  // defined in data.S
+
 static pde_t *kpgdir;  // for use in scheduler()
 
+// 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
@@ -72,7 +82,6 @@ mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
   
   a = PGROUNDDOWN(la);
   last = PGROUNDDOWN(la + size - 1);
-
   for(;;){
     pte = walkpgdir(pgdir, a, 1);
     if(pte == 0)
@@ -110,40 +119,32 @@ mappages(pde_t *pgdir, void *la, uint size, uint pa, int perm)
 // 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).
-
-// Allocate one page table for the machine for the kernel address
-// space for scheduler processes.
-void
-kvmalloc(void)
-{
-  kpgdir = setupkvm();
-}
+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)
 {
-  extern char etext[];
-  char *rwstart;
   pde_t *pgdir;
-  uint rwlen;
-
-  rwstart = PGROUNDDOWN(etext);
-  rwlen = (uint)rwstart - 0x100000;
+  struct kmap *k;
 
-  // Allocate page directory
   if((pgdir = (pde_t*)kalloc()) == 0)
     return 0;
   memset(pgdir, 0, PGSIZE);
-  if(// Map IO space from 640K to 1Mbyte
-     mappages(pgdir, (void*)USERTOP, 0x60000, USERTOP, PTE_W) < 0 ||
-     // Map kernel instructions
-     mappages(pgdir, (void*)0x100000, rwlen, 0x100000, 0) < 0 ||
-     // Map kernel data and free memory pool
-     mappages(pgdir, rwstart, PHYSTOP-(uint)rwstart, (uint)rwstart, PTE_W) < 0 ||
-     // Map devices such as ioapic, lapic, ...
-     mappages(pgdir, (void*)0xFE000000, 0x2000000, 0xFE000000, PTE_W) < 0)
-    return 0;
+  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;
+
   return pgdir;
 }
 
@@ -162,48 +163,27 @@ vmenable(void)
 // Switch h/w page table register to the kernel-only page table,
 // for when no process is running.
 void
-switchkvm()
+switchkvm(void)
 {
   lcr3(PADDR(kpgdir));   // switch to the kernel page table
 }
 
-// Switch h/w page table and TSS registers to point to process p.
+// 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");
-
+    panic("switchuvm: no pgdir");
   lcr3(PADDR(p->pgdir));  // switch to new address space
   popcli();
 }
 
-// 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;
-
-  pte = walkpgdir(pgdir, uva, 0);
-  if((*pte & PTE_P) == 0)
-    return 0;
-  if((*pte & PTE_U) == 0)
-    return 0;
-  return (char*)PTE_ADDR(*pte);
-}
-
 // Load the initcode into address 0 of pgdir.
 // sz must be less than a page.
 void
@@ -228,10 +208,10 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
   pte_t *pte;
 
   if((uint)addr % PGSIZE != 0)
-    panic("loaduvm: addr must be page aligned\n");
+    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\n");
+      panic("loaduvm: address should exist");
     pa = PTE_ADDR(*pte);
     if(sz - i < PGSIZE)
       n = sz - i;
@@ -243,10 +223,8 @@ loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
   return 0;
 }
 
-// Allocate memory to the process to bring its size from oldsz to
-// newsz. Allocates physical memory and page table entries. oldsz and
-// newsz need not be page-aligned, nor does newsz have to be larger
-// than oldsz.  Returns the new process size or 0 on error.
+// 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, uint oldsz, uint newsz)
 {
@@ -330,9 +308,9 @@ copyuvm(pde_t *pgdir, uint sz)
     return 0;
   for(i = 0; i < sz; i += PGSIZE){
     if((pte = walkpgdir(pgdir, (void*)i, 0)) == 0)
-      panic("copyuvm: pte should exist\n");
+      panic("copyuvm: pte should exist");
     if(!(*pte & PTE_P))
-      panic("copyuvm: page not present\n");
+      panic("copyuvm: page not present");
     pa = PTE_ADDR(*pte);
     if((mem = kalloc()) == 0)
       goto bad;
@@ -347,16 +325,31 @@ bad:
   return 0;
 }
 
-// copy some data to user address va in page table pgdir.
-// most useful when pgdir is not the current page table.
+//PAGEBREAK!
+// Map user virtual address to kernel physical address.
+char*
+uva2ka(pde_t *pgdir, char *uva)
+{
+  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);
+}
+
+// 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 *xbuf, uint len)
+copyout(pde_t *pgdir, uint va, void *p, uint len)
 {
   char *buf, *pa0;
   uint n, va0;
   
-  buf = (char*)xbuf;
+  buf = (char*)p;
   while(len > 0){
     va0 = (uint)PGROUNDDOWN(va);
     pa0 = uva2ka(pgdir, (char*)va0);
-- 
cgit v1.2.3