xv6源码分析 012

xv6源码分析 012

我们来看看xv6内核的内存配置器（kalloc.c）。

xv6的内存配置器是基于单向链表的，这是最简单实现方式。

extern char end[];

这是一个物理地址：0x80000000；它被定义在kernel.ld文件中，这个文件是一个ARM架构的链接脚本（linker script），用来指导链接器如何布局目标文件中的各个段（section）。

声明一下：这篇文章的东西有点过于底层，我并不是很了解，所以大部分都来自gpt。

我们看看具体的代码，主要功能包括：

• .text：包含所有.text和.text.*段的内容，进行0x1000字节对齐，并在其中放置trampsec部分。之后检查这部分大小是否恰好为一页（0x1000字节），并定义etext符号指向段尾。

  • .text段具有以下特征和功能：
    1. 只读性：通常.text段被标记为只读，以防止程序运行过程中意外修改代码。操作系统在加载程序时会将其映射到内存的只读区域。
    2. 指令存储：该段包含了程序的所有可执行指令，包括函数定义，循环结构，条件判断，算数运算等一切控制流相关的代码。当程序执行时，CPU会按照指令的顺序，从.text段中读取并执行指令。
    3. 内存布局：在程序的内存布局中，.text通常位于较低的地址空间，紧随程序的入口点（如，_start和main）。这样的设计有助于提高指令访问速度，因为现代处理器通常有较小的指令缓存，对低地址空间的指令访问效率更高。
    4. 静态链接与动态链接：对于静态链接的程序，.text段包含了所有依赖库的代码；而对于动态链接的程序，.text段仅包含自身代码和一些必要的动态链接信息（如重定位表），实际的库代码会在运行时有动态链接器加载到内存的其他位置。
    5. 权限与安全：由于.text段的只读性质，它常常称为安全防护的重点。例如，某些安全机制会监控对.text段的写入尝试，以防止恶意代码篡改程序的行为（如：缓冲区溢出攻击）。

• .rodata：包含.srodata、.srodata.*、.rodata和.rodata.*段的内容，进行16字节对齐。

  • .rodata段具有以下性质：
    1. 只读性：.rodata段的内容在程序运行期间是不可修改的。操作系统在加载程序的时候会将其映射到内存的只读区域，任何尝试写入该区域的操作都将触发保护机制，导致错误或异常。
    2. 静态数据存储：该段通常包含那些在编译时就已经确定，并且在整个程序执行过程中始终保持不变的数据。这类数据包括：
       • 常量：使用const关键字声明的常数值，如整数，浮点数，字符常量等。
       • 字符串字面量：程序中直接使用的字符串。编译器会将重复的字符串合并，确保程序中每一个唯一的字符串字面量在.rodata中只有一份拷贝。
       • 编译器计算结果：编译器可能在某些编译器计算得到的值放入.rodata段，如宏定义，枚举值，编译器内部使用的固定表等。
    3. 内存布局：.rodata通常紧邻.text段，同样位于较低的地址空间，这样的布局有利于提高数据访问效率，因为指令执行过程中可能会频繁引用.rodata总的常量或者表项。
    4. 共享与空间优化：在多进程环境中，.rodata的内容可以在多个进程之间共享，从而节省内存资源。尤其是在嵌入式系统中，rodata段可能被放置在ROM中，运行时直接从ROM中读取，无需加载到RAM总。这种技术被称为XIP（execute-in-place），可以减少RAM使用并提高执行速度。
    5. 安全考虑：由于.rodata段的内容不可变，它相对不易受到某些类型的攻击。

• .data：包含.sdata、.sdata.*、.data和.data.*段的内容，进行16字节对齐。

  • .data
    1. 存储内容：
       • 全局变量：在程序的全局作用内定义且带有初始值的非const变量。
       • 静态变量：在函数内部使用static关键字声明且带有初始值的变量。这些变量虽然在函数内部定义，但是其生命周期贯穿整个程序执行的过程，且仅初始化一次。
       • 常量（有时）：尽管常量通常存储在只读数据段中，但在某些编译器或平台下，非常量表达式计算结果的全局或静态变量可能会被存储在data段，特别是当他们依赖于编译时无法确定的宏定义或其他编译条件时。
    2. 初始化状态：data段中的变量在程序加载到内存时就已经被初始化为编译时指定的值。这意味着这些变量的初始值被直接包含在可执行文件中，作为其一部分，确保程序启动时他们就有确切的值。
    3. 内存属性：
       • data段在内存中可读写的，因为在其上存储的变量在程序运行过程中可能被修改。
       • data段通常位于静态数据区，其地址在程序执行期间固定不变，与堆（动态分配内存区域）和栈（函数调用时自动分配和释放内存）不同。
    4. 内存分配：
       • data段的大小在编译时即确定，因为它直接取决于所有已初始化全局变量和静态变量的总大小以及他们的初始值所需存储空间。
       • 在程序加载阶段，操作系统或加载器会根据可执行文件的描述信息为data段分配相应的内存，并从文件中复制初始值到相应的内存位置。
    5. 对性能和资源的影响：
       • data段的存在增加了可执行文件的大小，因为它包含了初始值的二进制表示，大型或复杂的初始数据结构可能导致可执行文件显著增大。
       • 加载程序时，data段的内容必须从磁盘读取到内存，这可能影响到程序的启动速度，特别是在内存资源紧张或磁盘IO性能较低的情况下。

• .bss：包含.sbss、.sbss.*、.bss和.bss.*段的内容，进行16字节对齐。

  bss（block started by symbol）段是程序在内存中占用的一个特定的区域，主要用来存放未初始化的全局变量和静态变量。

  • 存储内容：

    1. 未初始化的全局变量
    2. 未初始化的静态变量

  • 初始化状态：

    1. bss段中的变量在程序加载到内存时并不包含具体的初始值。相反，操作系统或加载器仅分配必要的空间，且默认将这些空间初始化为零。

    2. bss段本身并不在可执行文件中占据实际的空间来存储这些变量的初始值。它仅通过可执行文件的描述信息（ELF head或PE head）记录这些变量所需要的总内存大小。

  • 内存属性：

    1. bss段在内存中同样是可读写的
    2. 它位于程序的静态数据区，与data段相邻，其地址在程序执行期间也是固定的，独立于堆栈。

  • 内存分配：

    跟data段相似

  • 对性能和资源的影响：

    与data段相反

SECTIONS
{
  /*
   * ensure that entry.S / _entry is at 0x80000000,
   * where qemu's -kernel jumps.
   */
  . = 0x80000000;

  .text : {
    *(.text .text.*)
    . = ALIGN(0x1000);
    _trampoline = .;
    *(trampsec)
    . = ALIGN(0x1000);
    ASSERT(. - _trampoline == 0x1000, "error: trampoline larger than one page");
    PROVIDE(etext = .);
  }

  .rodata : {
    . = ALIGN(16);
    *(.srodata .srodata.*) /* do not need to distinguish this from .rodata */
    . = ALIGN(16);
    *(.rodata .rodata.*)
  }

  .data : {
    . = ALIGN(16);
    *(.sdata .sdata.*) /* do not need to distinguish this from .data */
    . = ALIGN(16);
    *(.data .data.*)
  }

  .bss : {
    . = ALIGN(16);
    *(.sbss .sbss.*) /* do not need to distinguish this from .bss */
    . = ALIGN(16);
    *(.bss .bss.*)
  }

  PROVIDE(end = .);
}

---

空间配置器

struct run {
  struct run *next;
};

struct {
  struct spinlock lock;
  struct run *freelist;
} kmem;

struct run是块链表，每一个节点代表一个内存块（memory block），固定4096个字节的大小。

struct spinlock是保护整个数据结构的互斥锁。

初始化

void
freerange(void *pa_start, void *pa_end)
{
  char *p;
  p = (char*)PGROUNDUP((uint64)pa_start);
  for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
    kfree(p);
}

// 在mian函数中被调用
void
kinit()
{
  initlock(&kmem.lock, "kmem");
  freerange(end, (void*)PHYSTOP);
}

提供的接口

释放申请的内存

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

  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);
  r->next = kmem.freelist;
  kmem.freelist = r;
  release(&kmem.lock);
}

申请分配内存

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;
}

我们需要注意，这里的memset并不是库函数中的memset，是自己实现的。