xv6源码分析--内存管理

一、前言

xv6的内存管理在kernel/kalloc.c文件中,在线查看该代码请[点击](https://github.com/jintongxu/xv6-riscv/blob/riscv/kernel/kalloc.c)。(**注意:** 该文章代码都在kernel/kalloc.c中)

首先介绍一个结构体kmem,源码如下:

struct run {
  struct run *next;
};

// 这是一个临界资源,修改时候要获取锁
struct {
  struct spinlock lock;
  struct run *freelist;
} kmem;

kmem是一个临界资源,其中定义了一个锁,还有一个空闲页的链表,在这个空闲页的链表中存储着当前所有的空闲页

二、xv6启动后内存的初始化

xv6启动的流程为entry.S --> start.c --> main.c。在main.c中会初始化各个部件,比如内存初始化、页表初始化等等。

1

(具体的启动流程,这边文章不过多说明,以后有时间专门写一篇文章)

初始化内存的函数是kinit(),这里的锁就不特别说明了,因为kmem结构是个临界资源,所以修改的时候要获取锁,防止在当前进程修改的过程中被其他进程修改了。

void
kinit()
{
  // 初始化锁
  initlock(&kmem.lock, "kmem");
  /*  将第一个可用的内存到最后一个可用的内存分成一页一页的
    * 并将这些页添加到空闲页链表中
  */
  freerange(end, (void*)PHYSTOP);
}

kinit()中调用了freerange(),该函数传入两个指针,从 pa_start到pa_end的物理地址分成一页一页的,然后加入到空闲链表中。

void
freerange(void *pa_start, void *pa_end)
{
  char *p;
  p = (char*)PGROUNDUP((uint64)pa_start);  // p  是比pa_start地址高,且最近的一个页 
  // 从 pa_start 内存对齐后的页,到 pa_end 的每个页都释放掉,并加入到空闲页链表中
  for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
    kfree(p);
}

freerange()中用到了一个PGROUNDUP,这个的作用是页对齐,也就是获取大于等于pa_start的下一个页面对齐的地址,因为pa_start到pa_end不一定能分成整数个的页,所以找到下一个是PGSIZE整数倍的地址(假设将所有物理内存分成一页一页的,将pa_start放到PGSIZE整数倍的地址处,能保证将该物理区域分成整数个page)。

2

freerange()还用到了kfree(void *pa),它的功能是将pa页释放掉,并且将pa页面加入到空闲页链表中。源码如下:

void
kfree(void *pa)
{
  struct run *r;

  // 如果该页不是 PGSIZE 的整数倍,或者小于第一个可用内存的地址,或者大于最大可用内存地址 -- 就陷入恐慌
  if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
    panic("kfree");

  // Fill with junk to catch dangling refs.
  memset(pa, 1, PGSIZE);

  r = (struct run*)pa;

  acquire(&kmem.lock);
  // 将 pa 页加入到空闲页链表中
  r->next = kmem.freelist;
  kmem.freelist = r;
  release(&kmem.lock);
}

可以看到kfree就是先判断页是否有效,然后fill with junk to catch dangling refs.,最后将pa页添加到空闲页链表中。

kinit()freerange(void *pa_start, void *pa_end)传入了两个参数,一个是end()、一个是(void*)PHYSTOP*。end()表示是内核区域后第一个可用的地址,(void)PHYSTOP表示的是物理地址的结束地址。所以kinit()**表示将当前可用的物理地址初始化为整数个页,并将这些页加入到空闲页链表中。

三、分配内存

kalloc(void)函数分配一个4096-byte的物理页,然后返回指向该页起始地址的指针。源码如下:

// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
void *
kalloc(void)
{
  struct run *r;

  acquire(&kmem.lock);
  // 获取空闲页链表中的第一个空闲页面
  r = kmem.freelist;
  if(r)
    // 将空闲页链表中的第一个空闲页面丢弃
    kmem.freelist = r->next;
  release(&kmem.lock);

  if(r)
    memset((char*)r, 5, PGSIZE); // fill with junk

  // 返回一个指向该地址的指针
  return (void*)r;
}

可以看到,上锁就不用多说了(因为要修改临界资源),先获取空闲链表中的第一个空闲页面,如果存在这个页面,就将该页面从空闲页面中去掉,然后把该页面fill with junk,最后返回指向该页起始地址的指针。

四、kalloc.c的源码

最后附一个kalloc.c的源码。

// Physical memory allocator, for user processes,
// kernel stacks, page-table pages,
// and pipe buffers. Allocates whole 4096-byte pages.

#include "types.h"
#include "param.h"
#include "memlayout.h"
#include "spinlock.h"
#include "riscv.h"
#include "defs.h"

void freerange(void *pa_start, void *pa_end);

// 第一个可用的空间
extern char end[]; // first address after kernel.
                   // defined by kernel.ld.

struct run {
  struct run *next;
};

// 这是一个临界资源,修改时候要获取锁
struct {
  struct spinlock lock;
  struct run *freelist;
} kmem;

void
kinit()
{
  // 初始化锁
  initlock(&kmem.lock, "kmem");
  /*  将第一个可用的内存到最后一个可用的内存分成一页一页的
    * 并将这些页添加到空闲页链表中
  */
  freerange(end, (void*)PHYSTOP);
}

void
freerange(void *pa_start, void *pa_end)
{
  char *p;
  p = (char*)PGROUNDUP((uint64)pa_start);  // p  是比pa_start地址高,且最近的一个页 
  // 从 pa_start 内存对齐后的页,到 pa_end 的每个页都释放掉,并加入到空闲页链表中
  for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
    kfree(p);
}

// Free the page of physical memory pointed at by pa,
// which normally should have been returned by a
// call to kalloc().  (The exception is when
// initializing the allocator; see kinit above.)
// 释放一个页,将该页加入到 freelist 中
void
kfree(void *pa)
{
  struct run *r;

  // 如果该页不是 PGSIZE 的整数倍,或者小于第一个可用内存的地址,或者大于最大可用内存地址 -- 就陷入恐慌
  if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
    panic("kfree");

  // Fill with junk to catch dangling refs.
  memset(pa, 1, PGSIZE);

  r = (struct run*)pa;

  acquire(&kmem.lock);
  // 将 pa 页加入到空闲页链表中
  r->next = kmem.freelist;
  kmem.freelist = r;
  release(&kmem.lock);
}

// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
void *
kalloc(void)
{
  struct run *r;

  acquire(&kmem.lock);
  // 获取空闲页链表中的第一个空闲页面
  r = kmem.freelist;
  if(r)
    // 将空闲页链表中的第一个空闲页面丢弃
    kmem.freelist = r->next;
  release(&kmem.lock);

  if(r)
    memset((char*)r, 5, PGSIZE); // fill with junk

  // 返回一个指向该地址的指针
  return (void*)r;
}
THE END