// Contexts are stored at the bottom of the stack they
// describe; the stack pointer is the address of the context.
// The layout of the context matches the layout of the stack in swtch.S
-// at "Switch stacks" comment. Switch itself doesn't save eip explicitly,
+// at the "Switch stacks" comment. Switch doesn't save eip explicitly,
// but it is on the stack and allocproc() manipulates it.
struct context {
uint edi;
// Per-process state
struct proc {
uint sz; // Size of process memory (bytes)
- pde_t* pgdir; // linear address of proc's pgdir
+ pde_t* pgdir; // Linear address of proc's pgdir
char *kstack; // Bottom of kernel stack for this process
enum procstate state; // Process state
volatile int pid; // Process ID
// Process memory is laid out contiguously, low addresses first:
// text
// original data and bss
+// invalid page
// fixed-size stack
// expandable heap
// The mappings from logical to linear are one to one (i.e.,
// segmentation doesn't do anything).
-// The mapping from linear to physical are one to one for the kernel.
-// The mappings for the kernel include all of physical memory (until
-// PHYSTOP), including the I/O hole, and the top of physical address
-// space, where additional devices are located.
-// The kernel itself is linked to be at 1MB, and its physical memory
-// is also at 1MB.
-// Physical memory for user programs is allocated from physical memory
+// 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
static uint kerndsz;
static uint kernend;
static uint freesz;
-pde_t *kpgdir; // One kernel page table for scheduler procs
+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,
proc = 0;
}
-// Setup address space and current process task state.
+// Switch h/w page table and TSS registers to point to process p.
void
-loadvm(struct proc *p)
+switchuvm(struct proc *p)
{
pushcli();
ltr(SEG_TSS << 3);
if (p->pgdir == 0)
- panic("loadvm: no pgdir\n");
+ panic("switchuvm: no pgdir\n");
lcr3(PADDR(p->pgdir)); // switch to new address space
popcli();
}
-// Setup kernel part of a page table. Linear adresses map one-to-one
-// on physical addresses.
+// 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)
{
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
+// processes directly.
char*
uva2ka(pde_t *pgdir, char *uva)
{
}
}
+// given a parent process's page table, create a copy
+// of it for a child.
pde_t*
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");
- pa = PTE_ADDR(*pte);
- if (!(mem = kalloc(PGSIZE)))
- return 0;
- memmove(mem, (char *)pa, PGSIZE);
- if (!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
- return 0;
+ if(*pte & PTE_P){
+ pa = PTE_ADDR(*pte);
+ if (!(mem = kalloc(PGSIZE)))
+ return 0;
+ memmove(mem, (char *)pa, PGSIZE);
+ if (!mappages(d, (void *)i, PGSIZE, PADDR(mem), PTE_W|PTE_U))
+ return 0;
+ }
}
return d;
}
-// Gather about physical memory layout. Called once during boot.
+// Gather information about physical memory layout.
+// Called once during boot.
void
pminit(void)
{
kerndsz = ph[1].memsz;
freesz = PHYSTOP - kernend;
- cprintf("kerntext@0x%x(sz=0x%x), kerndata@0x%x(sz=0x%x), kernend 0x%x freesz = 0x%x\n",
- kerntext, kerntsz, kerndata, kerndsz, kernend, freesz);
-
kinit((char *)kernend, freesz);
}
projects / cs3210-lab1.git / commitdiff