XV6学习笔记(2) :内存管理
XV6学习笔记(2) :内存管理
在学习笔记1中，完成了对于pc启动和加载的过程。目前已经可以开始在c语言代码中运行了,而当前已经开启了分页模式，不过是两个4mb的大的内存页，而没有开启小的内存页。接下来就可以从main.c的init函数开始
这里会和JOS做一个对比
首先看一下在执行main.c之前的物理内存分布
0x0000-0x7c00 引导程序的栈 0x7c00-0x7d00 引导程序的代码(512字节) 0x10000-0x11000 内核ELF文件头(4096字节) 0xA0000-0x100000 设备区 0x100000-0x400000 Xv6操作系统(未用满)
1. Kinit1函数
1.1 xv6中的kinit1函数
int
main(void)
{
kinit1(end, P2V(4*1024*1024)); // phys page allocator
kvmalloc(); // kernel page table
//....
}
这是main函数的开始。所以我们先从kinit1开始
这里的end地址就是kernel从0x80100000开始。然后是内核的代码段 + 只读数据段+ stab段+ stabstr + 数据段 + .bss段这些之后的起始地址。如下图所示。
void
kinit1(void *vstart, void *vend)
{
initlock(&kmem.lock, "kmem");
kmem.use_lock = 0;
freerange(vstart, vend);
}
- 这里的vstart就是end的地址而vend是
KERNBASE + 4MB=0x80400000 - 这里就是把[vstart, 0x80400000]的内存按页(4kb大小)进行free
kree这里会把他插入到freelist中
void
freerange(void *vstart, void *vend)
{
char *p;
p = (char*)PGROUNDUP((uint)vstart);
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
kfree(p);
}
//PAGEBREAK: 21
// Free the page of physical memory pointed at by v,
// which normally should have been returned by a
// call to kalloc(). (The exception is when
// initializing the allocator; see kinit above.)
void
kfree(char *v)
{
struct run *r;
if((uint)v % PGSIZE || v < end || V2P(v) >= PHYSTOP)
panic("kfree");
// Fill with junk to catch dangling refs.
memset(v, 1, PGSIZE);
if(kmem.use_lock)
acquire(&kmem.lock);
r = (struct run*)v;
r->next = kmem.freelist;
kmem.freelist = r;
if(kmem.use_lock)
release(&kmem.lock);
}
好了这里就可以完成整个free操作了
1.2 jos的boot_alloc函数
和上面的是非常类似的
- 当第一次执行的时候nextfree是空这里会进行第一次分配。这里的起始地址也是
end的地址 - 然后返回这一段分配的地址，并更新nextfree
static void *
boot_alloc(uint32_t n)
{
static char *nextfree; // virtual address of next byte of free memory
char *result = NULL;
// Initialize nextfree if this is the first time.
// 'end' is a magic symbol automatically generated by the linker,
// which points to the end of the kernel's bss segment:
// the first virtual address that the linker did *not* assign
// to any kernel code or global variables.
if (!nextfree) {
extern char end[];
nextfree = ROUNDUP((char *) end + 1, PGSIZE);
}
// Allocate a chunk large enough to hold 'n' bytes, then update
// nextfree. Make sure nextfree is kept aligned
// to a multiple of PGSIZE.
//
// LAB 2: Your code here.
if (n > 0) {
result = nextfree;
nextfree = ROUNDUP(nextfree + n, PGSIZE);
} else if (n == 0) {
result = ROUNDUP(nextfree, PGSIZE);
} else {
panic("boot_alloc(n): n < 0\n");
}
cprintf("boot_alloc(): nextfree=%08x\n", nextfree);
if ((uintptr_t) nextfree >= KERNBASE + PTSIZE) {
panic("boot_alloc(): out of memory\n");
}
return result;
}
2. kvmalloc
void
kvmalloc(void)
{
kpgdir = setupkvm();
switchkvm();
}
这里我们先看一下setupkvm
// Set up kernel part of a page table.
pde_t*
setupkvm(void)
{
pde_t *pgdir;
struct kmap *k;
if((pgdir = (pde_t*)kalloc()) == 0) // 分配pgdir
return 0;
memset(pgdir, 0, PGSIZE);
if (P2V(PHYSTOP) > (void*)DEVSPACE)
panic("PHYSTOP too high");
for(k = kmap; k < &kmap[NELEM(kmap)]; k++) //遍历kmap进行映射
if(mappages(pgdir, k->virt, k->phys_end - k->phys_start,
(uint)k->phys_start, k->perm) < 0) {// 如果映射失败则 free掉
freevm(pgdir);
return 0;
}
return pgdir;
当然这里引出了很多函数
1. kalloc函数
从我们的空闲队列中获得一个指针。返回
char*
kalloc(void)
{
struct run *r;
if(kmem.use_lock)
acquire(&kmem.lock);
r = kmem.freelist;
if(r)
kmem.freelist = r->next;
if(kmem.use_lock)
release(&kmem.lock);
return (char*)r;
}
2. kmap指明了内核中需要映射的区域：
// This table defines the kernel’s
// every process’s page table.
static struct kmap {
void *virt;
uint phys_start;
uint phys_end;
int perm; //权限
} kmap[] = {
{ (void*)KERNBASE, 0, EXTMEM, PTE_W }, // I/O space
{ (void*)KERNLINK, V2P(KERNLINK), V2P(data), 0 }, // kern text+rodata
{ (void*)data,V2P(data), PHYSTOP, PTE_W }, // kern data+memory
{ (void*)DEVSPACE, DEVSPACE, 0, PTE_W }, // more devices
};
3. mappages函数
- 给定虚拟地址va和物理地址pa
- 把[va , va + size]和 [pa, pa + size]进行映射。并且以perm位
static int
mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm)
{
char *a, *last;
pte_t *pte;
a = (char*)PGROUNDDOWN((uint)va);
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
for(;;){
if((pte = walkpgdir(pgdir, a, 1)) == 0)
return -1;
if(*pte & PTE_P)
panic("remap");
*pte = pa | perm | PTE_P;
if(a == last)
break;
a += PGSIZE;
pa += PGSIZE;
}
return 0;
}
4.walkpgdir函数
这里关于页的操作要补充一些关于页表操作的知识
首先页表目录结构如下。4gb内存32地址的话
//
// +--------10------+-------10-------+---------12----------+
// | Page Directory | Page Table | Offset within Page |
// | Index | Index | |
// +----------------+----------------+---------------------+
// \--- PDX(va) --/ \--- PTX(va) --/
// page directory index
#define PDX(va) (((uint)(va) >> PDXSHIFT) & 0x3FF)
// page table index
#define PTX(va) (((uint)(va) >> PTXSHIFT) & 0x3FF)
// construct virtual address from indexes and offset
#define PGADDR(d, t, o) ((uint)((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))
#define PTXSHIFT 12 // offset of PTX in a linear address
#define PDXSHIFT 22 // offset of PDX in a linear address
// Address in page table or page directory entry
#define PTE_ADDR(pte) ((uint)(pte) & ~0xFFF)
-
这里的操作用到了
PTE_ADDR函数0xFFF = 1111 | 1111 | 1111 ~0xFFF = 0000 | 0000 | 0000 #其实就是把最后12位设置为0 -
这里就是获取指定虚拟地址的pte条目
static pte_t *
walkpgdir(pde_t *pgdir, const void *va, int alloc)
{
pde_t *pde;
pte_t *pgtab;
pde = &pgdir[PDX(va)];
if(*pde & PTE_P){
pgtab = (pte_t*)P2V(PTE_ADDR(*pde));
} else {
if(!alloc || (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 = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
}
return &pgtab[PTX(va)];
}
整个映射完的图如下
而在xv6的二级页表条目管理如下
5. switchkvm函数
这个函数就是把kernel的pagedir传输到cr3寄存器中
kenel的pagedir由上面的操作获得
// Switch h/w page table register to the kernel-only page table,
// for when no process is running.
void
switchkvm(void)
{
lcr3(V2P(kpgdir)); // switch to the kernel page table
}
3. kinit2函数
在main函数进入这个函数之前还有好多别的函数。但是这个进入第一个用户进程之前的最后一个函数，
kinit2()将[0x400000, 0xE00000]范围内的物理地址纳入到内存页管理之中。至此，Xv6的内存页管理系统和内核页表已经全部建立完毕。需要注意的是，这个内核页表(kpgdir变量)只会在调度器运行时被使用。对于每一个用户进程，都会拥有自己独自的完整页表，其中也包含了一份一模一样的内核页表。
void
kinit2(void *vstart, void *vend)
{
freerange(vstart, vend);
kmem.use_lock = 1;
}
此时的虚拟内存和物理内存的映射关系如下
| 虚拟地址 | 映射到物理地址 | 内容 |
|---|---|---|
| [0x80000000, 0x80100000] | [0, 0x100000] | I/O设备 |
| [0x80100000, 0x80000000+data] | [0x100000, data] | 内核代码和只读数据 |
| [0x80000000+data, 0x80E00000] | [data, 0xE00000] | 内核数据+可用物理内存 |
| [0xFE000000, 0] | [0xFE000000, 0] | 其他通过内存映射的I/O设备 |
