XV6学习笔记(2) :内存管理

时间：2021-01-21 00:22:58

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段这些之后的起始地址。如下图所示。

XV6学习笔记(2) :内存管理

void

kinit1(void *vstart, void *vend)

{

  initlock(&kmem.lock, "kmem");

  kmem.use_lock = 0;

  freerange(vstart, vend);

}
  1. 这里的vstart就是end的地址而vend是KERNBASE + 4MB = 0x80400000
  2. 这里就是把[vstart, 0x80400000]的内存按页(4kb大小)进行free
  3. 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操作了

XV6学习笔记(2) :内存管理

1.2 jos的boot_alloc函数

和上面的是非常类似的

  1. 当第一次执行的时候nextfree是空这里会进行第一次分配。这里的起始地址也是end的地址
  2. 然后返回这一段分配的地址，并更新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函数

  1. 给定虚拟地址va和物理地址pa
  2. 把[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)

  1. 这里的操作用到了PTE_ADDR函数

    0xFFF = 1111 | 1111 | 1111
    
~0xFFF = 0000 | 0000 | 0000
    
#其实就是把最后12位设置为0

  2. 这里就是获取指定虚拟地址的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学习笔记(2) :内存管理

而在xv6的二级页表条目管理如下

XV6学习笔记(2) :内存管理

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设备

参考1

参考2

相关文章