xv6源码分析--内存管理_xv6 struct run

大家好，我叫徐锦桐，个人博客地址为www.xujintong.com，github地址为https://github.com/jintongxu。平时记录一下学习计算机过程中获取的知识，还有日常折腾的经验，欢迎大家访问。

一、前言

xv6的内存管理在kernel/kalloc.c文件中，在线查看该代码请点击。(注意： 该文章代码都在kernel/kalloc.c中)

首先介绍一个结构体kmem，源码如下：

struct run {
  struct run *next;
};

// 这是一个临界资源，修改时候要获取锁
struct {
  struct spinlock lock;
  struct run *freelist;
} kmem;
1
2
3
4
5
6
7
8
9

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

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

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

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

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

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

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);
}
1
2
3
4
5
6
7
8
9

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

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

可以看到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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

四、kalloc.c的源码

最后附一个kernel/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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96