linux内存管理子系统 笔记

4-4 linux内存管理子系统

4-4-1 linux内存管理（参考课件）

物理地址：cpu地址总线上寻址物理内存的地址信号，是地址变换的最终结果

逻辑地址：程序代码经过编译后，出现在汇编程序中的地址（程序设计时使用的地址）

线性地址：又名虚拟地址，32位cpu架构下4G地址空间

CPU要将一个逻辑地址转换为物理地址，需要两步：

1、首先CPU利用段式内存管理单元，将逻辑地址转换成线性地址；

2、再利用页式内存管理单元，把线性地址最终转换为物理地址

相关公式：

逻辑地址=段基地址+段内偏移量(段基地址寄存器+段偏移寄存器)（通用的）

16位CPU：逻辑地址=段基地址+段内偏移量(段基地址寄存器+段偏移寄存器)

线性地址=段寄存器的值×16+逻辑地址的偏移部分

物理地址=线性地址（没有页式管理）

32位CPU：逻辑地址=段基地址+段内偏移量(段基地址寄存器+段偏移寄存器)

线性地址=段寄存器的值+逻辑地址的偏移部分

物理地址<——>线性地址（mapping转换）

ARM32位：逻辑地址=段基地址+段内偏移量(段基地址寄存器+段偏移寄存器)

逻辑地址=段内偏移量（段基地址为0）

线性地址=逻辑地址=段内偏移量（32位不用乘以32）

物理地址<——>线性地址（mapping转换）

************************!!以下都是x86模式下!!*********************************

一、段式管理

1.1、16位CPU：（没有页式管理）

1.1.1、段式管理的由来：

16位CPU内部有20位地址总线，可寻址2的20次方即1M的内存空间，但16位CPU 只有16位的寄存器，因此只能访问2的16次方即64K。因此就采用了内存分段的管理模式，在CPU内部加入了段寄存器，这样1M被分成若干个逻辑段，每个逻辑段的要求如下：

1、逻辑段的起始地址（段地址）必须是16的整数倍，即最后4个二进制位须全是0 (因此不必保存)。

2、逻辑段的最大容量为64K。

1.1.2、物理地址的形成方式：

段地址：将段寄存器中的数值左移4位补4个0（乘以16），得到实际的段地址。

段偏移：在段偏移寄存器中。

1）逻辑地址=段基地址+段内偏移量(段基地址寄存器+段偏移寄存器)

2）由逻辑地址得到物理地址的公式为：（因为没有页式管理，所以这一步就得到了物理地址）物理地址PA=段寄存器的值×16+逻辑地址的偏移部分(注意!!)(段与段可能会重叠)

按段式管理能访问2的32次方共4GB 的空间（2的16次方个段，每个段可以为2的16次方byte的大小），但是只有20位地址总线，因此只能访问1M的内存。

1.2、32位CPU：

1)实模式：

与16位时是一样的

段寄存器的值×16就是段地址

2)保护模式：

段寄存器的值是一个选择器，间接指出一个32位的段地址

段基地址长达32位，每个段的最大容量可达4G，段寄存器的值是段地址的“选择器”(segment selector),用该“选择器”从内存（segment descriptor）中得到一个32位的段地址，存储单元的线性地址就是段地址加上段内偏移量，这与32位CPU的物理地址的计算方式完全不同。

!!!线性地址=段基地址+段内偏移量/逻辑地址(段选择器指向的内存中存储的基地址+段偏移寄存器)!!! 这里不用乘以16或者32，因为段基址寄存器可以完全存下段地址。

32位CPU得到线性地址后，再经过页式管理就能得到物理地址

二、页式管理

2.1页：线性地址被分为固定长度的组，称为页。例如32位的机器，每页4KB，可划为2的20次方个页(划分虚拟单元)，32位机器的线性地址空间为4G。

2.2物理页：也称为页框、页桢；分页单元把所有的物理内存也划分为固定长度的管理单位(划

分实在的单元)，它的长度一般与线性地址页是相同的。

二者的区别：页划分的是线性地址，物理页划分的是实际的物理地址

二者的联系：1、页的长度一般相同，2、通过mapping转换，存在映射关系。

通过分页管理模型，由线性地址得到物理地址

1、分页单元中，页目录的地址存放在CPU的cr3寄存器中，是进行地址转换的开始点。

2、每个进程，都有其独立的虚拟地址空间，运行一个进程，首先要将它的页目录地址放到cr3寄存器中，将其他进程的页目录地址保存下来。

3、每个32位的线性地址被划分为三部分：页目录索引（10位）；页表索引（10位）；偏移（12位）

（mapping映射关系由下图反映）

上图中页的大小为2的12次方，即4K。两级分页模型（页不算在内）

******************************!!以上都是x86模式!!*********** *******************

Linux内存管理

Linux有限度地使用了Intel的段式管理机制，而完全采用了页式管理机制。（也可以说没有采用段式管理）

所有段的基地址全部为零（那么所有段都重合，相当于只有一个段）

又因为"线性地址=段基地址+段内偏移量/逻辑地址偏移部分"，

所以"线性地址=逻辑地址"。

在linux系统中，逻辑地址=线性地址=虚拟地址

物理地址<——>线性地址（mapping转换）

linux页式管理

linux2.6.29内核采用了四级页式管理架构，来兼容二级、三级管理架构的CPU。

页全局目录、页上级目录、页中间目录、页表（四级时，线性地址为64位）

4-4-2进程地址空间（参考课件）

linux操作系统采用虚拟内存管理技术，使得每个进程的地址空间都是独立的。该空间大小是3G，用户看到的都是虚拟地址，无法看到实际的物理地址。

虚拟内存管理的优点：1、保护操作系统，

2、用户程序可以使用比实际物理内存更大的地址空间。

linux将4G的虚拟地址空间划分为用户空间和内核空间。

用户空间：0～0xbfffffff（0~3G）：用户进程通常情况下只能访问用户空间。

内核空间：0xc0000000~0xffffffff（3G-4G）

用户空间对应进程，所以每当进程切换，用户空间就会跟着变化。每个进程的地址空间都是独立的。每个进程的页目录、页表不一样，因此通过页式转换就可以得到不同的物理地址。例如：

同一个用户程序运行多次，产生多个进程，每个进程访问的虚拟地址（逻辑地址、线性地址）都是一样的，但是每个进程都有一套独立的页目录、页表，因此得到的实际物理地址是不同的。每个进程的页目录和页表就可以理解为进程独立的用户空间。

Fork()，execve()，malloc()等进程相关操作分配的内存，都是虚拟地址。只有当进程去访问新获取的虚拟地址时，才会由“请页机制”去分配实际的物理地址。

实际的物理内存只有当进程真的去访问新获取的虚拟地址时，才会由“请页机制”产生“缺页”异常，从而进入分配实际页框的程序。该异常是虚拟内存机制赖以生存的基本保证——它会告诉内核去为进程分配物理页，并建立对应的页表，这之后虚拟地址才实实在在地映射到了物理地址上。

动态分配——Linux内核中，动态分配内存使用函数kmalloc()

头文件：#include

原型：void *kmalloc(size_t size,int flags) ——kfree，适用于分配小于128KB的内存

功能：分配实际的物理页框，虽然返回的是虚拟地址，但已经有对应的物理页了。

参数：Flags取值为：

1、GFP_KERNEL，分配实际的内存，分配不到时睡眠。返回虚拟地址，但对应有实

际的物理单元。（16M-896M）

2、GFP_ATOMIC，用来在进程上下文之外的代码（包括中断处理）中分配内存，

从不睡眠。

3、__GFP_DMA，要求分配能够DMA的内存（物理地址在16M以下的页桢）

4、__GFP_HIGHMEM，分配的内存位于高端内存。（896M以上）

当用完这些页，需要使用下列函数之一来释放它们：

◎kfree函数

◎get_zeroed_page(unsigned int flags)——free_page

返回指向新页面的指针，并将页面清零。

◎__get_free_page(unsigned int flags)——free_page

和get_ zeroed _page类似，但不清零页面。

◎__get_free_pages(unsigned int flags,unsigned int order)——free_pages

分配若干的连续的页面，返回指向该内存区域的指针，但也不清零这段内存区域。

当用完这些页，需要使用下列函数之一来释放它们：

◎void free_page(unsigned long addr)

◎void free_pages(unsigned long addr,unsigned long order)

如果释放的页面和先前分配的页面数目不等，会导致系统错误。

4-4-3内核地址空间（参考课件）

内核空间是由内核负责映射，它并不会跟着进程改变，是固定的。内核映射的这一套页目录、页表是固定不变的。内核空间：3G-4G。

高端内存：物理内存896M以上的内存。

1、直接内存映射区：线性地址=3G+物理地址。从3G开始，最大896M的线性地址区间，我们称作直接内存映射区，这是因为该区域的线性地址和物理地址之间存在线性转换关系。

2、动态内存映射区：最小120M。由内核函数vmalloc()来分配。线性空间连续，物理空间不一定连续。分配一段虚拟地址，仅仅是一个地址，并不对应实际的物理地址。分配的虚拟地址在动态内存映射区，但可能处于低端内存，也可能处于高端内存（因为直接映射区最大为896M）。

3、永久内存映射区：4M。（PKMAP）896M以上的高端内存，可以使用该区域来访问。访问方法：

1）使用alloc_page(__GFP_HIGHMEM)分配高端内存页（得到物理页）

2）使用kmap函数将分配到的高端内存映射到该区域。（得到线性地址）

4、固定内存映射区：4M。每个地址项都服务于特定的用途，如ACPI_BASE等。映射关系做好了，不能改变。

4-4-4内核链表（参考课件）

链表数据结构：一般包含两个域：数据域和指针域。

链表数据结构的定义：

struct list_head

{

struct list_head *next,*prev;

}

内核链表具备双链表功能，通常它都组织成双向循环链表，在[include/linux/list.h]中。

传统链表和linux链表的比较：

1、传统链表：单向链表，指针指向下一节点，指针为下一节点数据类型的指针。

缺点，节点类型变化，则指针类型也要变化，不通用。

2、linux链表：双向循环链表，指针类型固定为struct list_head，链表头也为struct list_head

类型，但是不含数据。通用。

1、初始化链表头

INIT_LIST_HEAD(list_head *head)

2、插入节点

list_add(struct list_head *new,struct list_head *head)：插入的节点位于head之后。

list_add_tail(struct list_head *new,struct list_head *head)：插入的节点位于链表尾。

3、删除节点

list_del(struct list_head *entry)：entry为要删除的节点。

4、提取数据结构

list_entry(ptr,type,member)

根据已知的数据结构中的节点指针ptr，找出数据结构和数据。

ptr：指向本节点struct list_head结构的指针

type：要提取的数据的类型（包含struct list_head结构和数据）

member：struct list_head结构在整个数据结构中的成员名

返回值：指向整个数据结构的指针。

例如：list_entry(aup,struct autofs,list)

5、遍历链表——list_for_each和list_for_each_safe

list_for_each(struct list_head *pos,struct list_head *head)：实际上是一个循环，是一个宏。

head：指定要遍历哪一个链表；

pos：获取值，每一次遍历时指向不同的节点的list_head，第一次指向第一个节点。

例如：

struct list_head *entry;

struct list_head cs46xx_devs;//链表头

srtuct cs_card card;

list_for_each(entry,&cs46xx_devs)

{

card = list_entry(entry,srtuct cs_card,list); //寻找srtuct cs_card类型的结构

if(card->dev_midi = = minor) //利用srtuct cs_card类型结构的指针再访问里面的数据break;

}

编译在arm平台运行的内核模块时，makefile的编写：

ifneq ($(KERNELRELEASE),)

obj-m := myhello.o //编译多个内核模块时直接在后面加

myhello-objs := file1.o file2.o file3.o

else

KDIR := /lib/modules/2.6.18-53.el5/build //指定内核模块所依赖的内核源代码（运行环境）all:

make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-

//其他都一样，就这里不一样

clean:

rm -f *.ko *.o *.mod.o *.mod.c *.symvers

endif

4-4-5内核定时器（参考课件）

时钟中断：由系统的定时硬件以周期性的时间间隔产生，这个时间间隔（即频率）由内核根据HZ来确定，HZ是一个与体系结构无关的常数，默认值为1000。

Jiffies：（unsigned long）每当时钟中断发生时，全局变量jiffies就加1。

（jiffies记录了linux系统自启动发生时钟中断的次数），可以用来计算时间间隔。例如：

unsigned long j=jiffies + jit_delay*HZ;

while(jiffies

{

/*do nothing*/ //延时jit_delay秒

}

内核定时器的作用：

用于控制某个函数（定时器处理函数）在未来的某个特定的时间执行。

内核定时器注册的处理函数只执行一次，

通过使用内核函数mod_timer修改超时时间，可以实现多次使用内核定时器。

struct timer_list结构：

一个struct timer_list结构只描述一个内核定时器（内核定时器被组织成双向链表）。

struct timer_list

{

struct list_head entry; //内核使用，用来串连定时器链表。

unsigned long expires; //超时的jiffies的值，指定定时器在何时超时

void (*function)(unsigned long); //超时处理函数

unsigned long data; //超时处理函数的参数

struct tevc_base *base; //内核使用

}

初始化定时器分为两个步骤：1、内核使用的两个参数不用管，2、其他三个参数需要在，初始化定时器队列结构之后，启动定时器之前，自己去初始化的。

操作定时器有如下函数：

1、void init_timer(struct timer_list *timer);

初始化定时器队列结构

2、void add_timer(struct timer_list *timer);

启动定时器

3、int del_timer(struct timer_list *timer);

在定时器超时之前将它删除。当定时器超时后，系统会自动地将它删除。