一文看懂Linux内存分配，告别“内存小白”！

在 Linux 系统的复杂生态中，内存管理堪称是维持系统高效稳定运行的核心枢纽。想象一下，Linux 系统就像是一座繁忙的超级大都市，内存则是城市里的土地资源，每一个运行的程序、进程都如同在这片土地上建造的建筑，它们都需要占用一定的内存空间来存储数据和执行指令 。如果没有一个科学合理的内存管理机制，这座 “城市” 将会陷入混乱，出现内存资源分配不均、内存泄漏等问题，进而导致程序运行缓慢、系统响应迟钝，甚至引发系统崩溃。

比如，当你在 Linux 系统上同时运行多个大型程序时，若内存管理不佳，可能会使某些程序因得不到足够的内存而无法正常运行，或者因为内存的不合理分配，导致部分内存空间被浪费，造成资源的低效利用。所以，深入了解 Linux 内存的常见分配方式，对于系统管理员、开发者以及追求系统高性能的用户来说，就如同掌握了城市规划的秘籍，能够更好地调配内存资源，让 Linux 系统这座 “城市” 有序且高效地运转，极大地激发读者探索 Linux 内存分配方式的兴趣，为后续深入讲解内容做好铺垫。

一、内存分配三剑客

在 Linux 系统中，malloc、kmalloc、vmalloc 属于不同层次的内存分配函数，它们看似相似，却各怀绝技：一个服务用户态，一个专注内核连续物理页，另一个则驾驭虚拟映射的离散空间。理解它们的差异与妙用，正是优化性能、规避陷阱的关键一步。

1.1 malloc用户空间内存分配

malloc 函数是 C 标准库中用于动态内存分配的函数，其底层由 C 库实现。C 库维护着一个缓存，当该缓存中的内存足够满足分配需求时，malloc 会直接从 C 库缓存中分配内存。而当 C 库缓存中的内存不足时，malloc 则需借助系统调用与操作系统交互来获取更多内存。

在 Linux 系统中，这主要涉及 brk 和 mmap 这两个系统调用。当申请的内存小于 128KB 时，malloc 通常会通过系统调用 brk 向内核申请内存，具体来说是从堆空间申请一个虚拟内存区域（VMA）。brk 系统调用通过移动程序数据段的结束地址（即 “堆顶” 指针）来增加堆的大小，从而分配新的内存。当申请的内存大于等于 128KB 时，malloc 一般会使用 mmap 系统调用。mmap 系统调用是在进程的虚拟地址空间中（堆和栈中间，称为文件映射区域的地方）找一块空闲的虚拟内存来满足内存分配请求。

malloc实现步骤：

经过平台相关实现，malloc最终会调用SYSCALL_DEFINE1宏，扩展为__do_sys_brk函数：

总结下_do_sys_brk()功能：

依次调用：

当设置VM_LOCKED标志时，表示要马上申请物理页面，并与vma建立映射；否则，这里不操作，直到访问该vma时，触发缺页异常，再分配物理页面，并建立映射；

(1)malloc函数，从C库缓存分配内存，其分配或释放内存，未必马上会执行；

(2)malloc实际分配内存动作，要么主动设置mlockall()，人为触发缺页异常，分配物理页面；或者在访问内存时触发缺页异常，分配物理页面；

(3)malloc分配虚拟内存，有三种情况：

1.2 kmalloc内核空间常规内存分配

一般来说内核程序中对小于一页的小块内存的请求会通过slab分配器提供的接口kmalloc来完成(虽然它可分配32到131072字节的内存)。从内核内存分配角度讲kmalloc可被看成是get_free_page(s)的一个有效补充，内存分配粒度更灵活了。

kmalloc()函数类似与我们常见的malloc()函数，前者用于内核态的内存分配，后者用于用户态；kmalloc()函数在物理内存中分配一块连续的存储空间，且和malloc()函数一样，不会清除里面的原始数据，如果内存充足，它的分配速度很快，其原型如下：

使用 GFP_ KERNEL 标志申请内存时，若暂时不能满足，则进程会睡眠等待页，即会引起阻塞，因此不能在中断上下文或持有自旋锁的时候使用GFP_KERNE 申请内存。所以，在中断处理函数、tasklet 和内核定时器等非进程上下文中不能阻塞，此时驱动应当使用 GFP_ATOMIC 标志来申请内存。当使用 GFP_ATOMIC 标志申请内存时，若不存在空闲页，则不等待，直接返回。

kmalloc函数

kmem_cache_alloc_trace分配函数

可见，kmalloc()基于slab分配器实现，因此分配的内存，物理上都是连续的。

1.3 vmalloc内核空间虚拟内存分配

vmalloc()一般用在为只存在于软件中（没有对应的硬件意义）的较大的顺序缓冲区分配内存，当内存没有足够大的连续物理空间可以分配时，可以用该函数来分配虚拟地址连续但物理地址不连续的内存。由于需要建立新的页表，所以它的开销要远远大于kmalloc及后面将要讲到的__get_free_pages()函数。且vmalloc()不能用在原子上下文中，因为它的内部实现使用了标志为 GFP_KERNEL 的kmalloc()，其函数原型如下：

使用 vmalloc 函数的一个例子函数是create_module()系统调用，它利用 vmalloc()函数来获取被创建模块需要的内存空间。

内存分配是一项要求严格的任务，无论什么时候，都应该对返回值进行检测，在驱动编程中可以使用copy_from_user()对内存进行使用。下面举一个使用vmalloc函数的示例：

可见，vmalloc是临时在vmalloc内存区申请vma，并且分配物理页面，建立映射；直接分配物理页面，至少一个页4K，因此vmalloc适合用于分配较大内存，并且物理内存不一定连续；

二、mmap函数详解最后

2.1mmap函数

mmap 即 memory map，也就是内存映射。mmap 是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用 read、write 等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。如下图所示：

图片

mmap的作用，在应用这一层，是让你把文件的某一段，当作内存一样来访问。将文件映射到物理内存，将进程虚拟空间映射到那块内存。这样，进程不仅能像访问内存一样读写文件，多个进程映射同一文件，还能保证虚拟空间映射到同一块物理内存，达到内存共享的作用。

mmap 是 Linux 中用处非常广泛的一个系统调用，它将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。mmap 必须以 PAGE_SIZE 为单位进行映射，而内存也只能以页为单位进行映射，若要映射非 PAGE_SIZE 整数倍的地址范围，要先进行内存对齐，强行以 PAGE_SIZE 的倍数大小进行映射。

其函数原型为：void *mmap (void start, size_t length, int prot, int flags, int fd, off_t offset);int munmap(void start, size_t length);。下面介绍一下内存映射的步骤：

2.2mmap工作原理

mmap函数创建一个新的vm_area_struct结构，并将其与文件/设备的物理地址相连。

vm_area_struct：linux使用vm_area_struct来表示一个独立的虚拟内存区域，一个进程可以使用多个vm_area_struct来表示不用类型的虚拟内存区域（如堆，栈，代码段，MMAP区域等）。

vm_area_struct结构中包含了区域起始地址。同时也包含了一个vm_opt指针，其内部可引出所有针对这个区域可以使用的系统调用函数。从而，进程可以通过vm_area_struct获取操作这段内存区域所需的任何信息。

进程通过vma操作内存，而vma与文件/设备的物理地址相连，系统自动回写脏页面到对应的文件磁盘上（或写入到设备地址空间），实现内存映射文件。

内存映射文件的原理：

首先创建虚拟区间并完成地址映射，此时还没有将任何文件数据拷贝至主存。当进程发起读写操作时，会访问虚拟地址空间，通过查询页表，发现这段地址不在物理页上，因为只建立了地址映射，真正的数据还没有拷贝到内存，因此引发缺页异常。缺页异常经过一系列判断，确定无非法操作后，内核发起请求调页过程。

最终会调用nopage函数把所缺的页从文件在磁盘里的地址拷贝到物理内存。之后进程便可以对这片主存进行读写，如果写操作修改了内容，一定时间后系统会自动回写脏页面到对应的磁盘地址，完成了写入到文件的过程。另外，也可以调用msync()来强制同步，这样所写的内存就能立刻保存到文件中。

mmap内存映射的实现过程，总的来说可以分为三个阶段：

⑴进程启动映射过程，并在虚拟地址空间中为映射创建虚拟映射区域

⑵调用内核空间的系统调用函数mmap（不同于用户空间函数），实现文件物理地址和进程虚拟地址的一一映射关系

⑶进程发起对这片映射空间的访问，引发缺页异常，实现文件内容到物理内存（主存）的拷贝

注：前两个阶段仅在于创建虚拟区间并完成地址映射，但是并没有将任何文件数据的拷贝至主存。真正的文件读取是当进程发起读或写操作时。

注：修改过的脏页面并不会立即更新回文件中，而是有一段时间的延迟，可以调用msync()来强制同步, 这样所写的内容就能立即保存到文件里了。

2.3如何使用mmap技术

使用mmap需要注意的一个关键点是，mmap映射区域大小必须是物理页大小(page_size)的整倍数（32位系统中通常是4k字节）。原因是，内存的最小粒度是页，而进程虚拟地址空间和内存的映射也是以页为单位。为了匹配内存的操作，mmap从磁盘到虚拟地址空间的映射也必须是页。

内核可以跟踪被内存映射的底层对象（文件）的大小，进程可以合法的访问在当前文件大小以内又在内存映射区以内的那些字节。也就是说，如果文件的大小一直在扩张，只要在映射区域范围内的数据，进程都可以合法得到，这和映射建立时文件的大小无关。

映射建立之后，即使文件关闭，映射依然存在。因为映射的是磁盘的地址，不是文件本身，和文件句柄无关。同时可用于进程间通信的有效地址空间不完全受限于被映射文件的大小，因为是按页映射。

在上面的知识前提下，我们下面看看如果大小不是页的整倍数的具体情况：

情形一：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射5000字节到虚拟内存中。

分析：因为单位物理页面的大小是4096字节，虽然被映射的文件只有5000字节，但是对应到进程虚拟地址区域的大小需要满足整页大小，因此mmap函数执行后，实际映射到虚拟内存区域8192个 字节，5000~8191的字节部分用零填充。映射后的对应关系如下图所示：

图片

此时：（1）读/写前5000个字节（0~4999），会返回操作文件内容。（2）读字节50008191时，结果全为0。写50008191时，进程不会报错，但是所写的内容不会写入原文件中 。（3）读/写8192以外的磁盘部分，会返回一个SIGSECV错误。

情形二：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射15000字节到虚拟内存中，即映射大小超过了原始文件的大小。

分析：由于文件的大小是5000字节，和情形一一样，其对应的两个物理页。那么这两个物理页都是合法可以读写的，只是超出5000的部分不会体现在原文件中。由于程序要求映射15000字节，而文件只占两个物理页，因此8192字节~15000字节都不能读写，操作时会返回异常。如下图所示：

图片

此时：（1）进程可以正常读/写被映射的前5000字节(0~4999)，写操作的改动会在一定时间后反映在原文件中。（2）对于5000~8191字节，进程可以进行读写过程，不会报错。但是内容在写入前均为0，另外，写入后不会反映在文件中。（3）对于8192~14999字节，进程不能对其进行读写，会报SIGBUS错误。（4）对于15000以外的字节，进程不能对其读写，会引发SIGSEGV错误。

情形三：一个文件初始大小为0，使用mmap操作映射了10004K的大小，即1000个物理页大约4M字节空间，mmap返回指针ptr。

分析：如果在映射建立之初，就对文件进行读写操作，由于文件大小为0，并没有合法的物理页对应，如同情形二一样，会返回SIGBUS错误。但是如果，每次操作ptr读写前，先增加文件的大小，那么ptr在文件大小内部的操作就是合法的。例如，文件扩充4096字节，ptr就能操作ptr ~ [ (char)ptr + 4095]的空间。只要文件扩充的范围在1000个物理页（映射范围）内，ptr都可以对应操作相同的大小。这样，方便随时扩充文件空间，随时写入文件，不造成空间浪费。

在 Linux 中，mmap 函数定义如下：void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);。参数解释如下：

返回值：返回映射区域的起始地址，如果映射失败，则返回 MAP_FAILED。

在内存映射的过程中，并没有实际的数据拷贝，文件没有被载入内存，只是逻辑上被放入了内存，具体到代码，就是建立并初始化了相关的数据结构（struct address_space），这个过程有系统调用mmap()实现，所以建立内存映射的效率很高。既然建立内存映射没有进行实际的数据拷贝，那么进程又怎么能最终直接通过内存操作访问到硬盘上的文件呢？

那就要看内存映射之后的几个相关的过程了。mmap()会返回一个指针ptr，它指向进程逻辑地址空间中的一个地址，这样以后，进程无需再调用read或write对文件进行读写，而只需要通过ptr就能够操作文件。但是ptr所指向的是一个逻辑地址，要操作其中的数据，必须通过MMU将逻辑地址转换成物理地址，这个过程与内存映射无关。

前面讲过，建立内存映射并没有实际拷贝数据，这时，MMU在地址映射表中是无法找到与ptr相对应的物理地址的，也就是MMU失败，将产生一个缺页中断，缺页中断的中断响应函数会在swap中寻找相对应的页面，如果找不到（也就是该文件从来没有被读入内存的情况），则会通过mmap()建立的映射关系，从硬盘上将文件读取到物理内存中，如图1中过程3所示。这个过程与内存映射无关。如果在拷贝数据时，发现物理内存不够用，则会通过虚拟内存机制（swap）将暂时不用的物理页面交换到硬盘上，这个过程也与内存映射无关。

mmap内存映射的实现过程：

适合的场景

不适合的场景

示例代码

使用 mmap 后，必须调用 munmap 来解除映射，释放分配的虚拟内存。其函数定义如下：int munmap(void *addr, size_t length);。

返回值：成功返回 0，失败返回 -1。

⑴利用 mmap 访问硬件，减少数据拷贝次数

mmap 可以将文件、设备等外部资源映射到内存地址空间，进程可以像访问内存一样访问文件数据或硬件资源。当使用 mmap 访问硬件时，数据可以直接从硬件设备通过 DMA 拷贝到内核缓冲区，然后进程可以直接访问这个缓冲区，减少了数据拷贝的次数。

例如，在嵌入式系统中，可以使用 mmap 将物理地址映射到用户虚拟地址空间，实现对硬件设备的直接访问。在进行数据传输时，避免了传统方式中从内核空间到用户空间的多次数据拷贝，提高了数据传输的效率。

⑵通过 mmap 实现将物理地址映射到用户虚拟地址空间：

⑶在嵌入式系统中，还可以通过以下方式实现物理地址到用户虚拟地址空间的映射：

三、页分配函数最后

该函数定义在头文件/include/linux/gfp.h中，它既可以在内核空间分配，也可以在用户空间分配，它返回分配的第一个页的描述符而非首地址，其原型为：

图片

根据返回页面数目分类，分为仅返回单页面的函数和返回多页面的函数。

3.1alloc_page()和alloc_pages()函数

该函数定义在头文件/include/linux/gfp.h中，它既可以在内核空间分配，也可以在用户空间分配，它返回分配的第一个页的描述符而非首地址，其原型为：

3.2_get_free_pages()系列函数

它是kmalloc函数实现的基础，返回一个或多个页面的虚拟地址。该系列函数/宏包括 get_zeroed_page()、_ _get_free_page()和_ _get_free_pages()。在使用时，其申请标志的值及含义与 kmalloc()完全一样，最常用的是 GFP_KERNEL 和 GFP_ATOMIC。

使用_ _get_free_pages()系列函数/宏申请的内存应使用free_page(addr)或free_pages(addr, order)函数释放：

free_pages()函数是调用__free_pages()函数完成内存释放的。

四、Buddy算法详解最后

4.1Buddy算法

Buddy 算法堪称 Linux 内存管理的基石，主要用于管理 DMA（直接内存存取）、常规、高端内存这 3 个区域 。它的核心理念十分巧妙，将空闲的页以 2 的 n 次方为单位进行管理，这意味着 Linux 最底层的内存申请都是以 2 的 n 次方为单位。其最大的优势在于能够有效避免内存的外部碎片。在传统的内存管理算法中，频繁的内存分配和释放容易导致内存空间被分割成许多小块，这些小块之间的空闲区域无法被有效利用，就形成了外部碎片。而 Buddy 算法通过将内存页按照 2 的幂次方大小进行组织和管理，使得系统在分配和回收内存时，能够更好地合并相邻的空闲块，从而避免了这种外部碎片的产生 。

例如，假设 ZONE_NORMAL 区域有 16 页内存（即 2 的 4 次方），当有程序申请一页内存时，Buddy 算法会把剩下的 15 页巧妙地拆分成 8 + 4 + 2 + 1，分别放到不同的链表中。此时若再有程序申请 4 页内存，系统可以直接从 4 页的链表中分配；若再申请 4 页，就从 8 页的链表中拿出 4 页进行分配，正好剩下 4 页。其精髓就在于任何正整数都可以拆分成 2 的 n 次方之和。

然而，金无足赤，人无完人，Buddy 算法也有其局限性。长期运行后，系统中大片的连续内存会逐渐减少，而 1 页、2 页、4 页这种小内存块会越来越多。当需要分配大片连续内存时，就可能会出现问题，也就是说它是以产生内部碎片为代价来避免外部碎片的产生。所谓内部碎片，就是系统已经分配给用户使用，但用户自己没有用到的那部分存储空间。我们可以通过/proc/buddyinfo文件来查看内存空闲的相关情况，以便及时了解系统内存的分配状态，为系统优化提供依据 。

4.2伙伴算法原理

Linux 便是采用这著名的伙伴系统算法来解决外部碎片的问题。把所有的空闲页框分组为 11 块链表，每一块链表分别包含大小为1，2，4，8，16，32，64，128，256，512 和 1024 个连续的页框。对1024 个页框的最大请求对应着 4MB 大小的连续RAM 块。每一块的第一个页框的物理地址是该块大小的整数倍。例如，大小为 16个页框的块，其起始地址是 16 * 2^12 （2^12 = 4096，这是一个常规页的大小）的倍数。

下面通过一个简单的例子来说明该算法的工作原理：

假设要请求一个256（129~256）个页框的块。算法先在256个页框的链表中检查是否有一个空闲块。如果没有这样的块，算法会查找下一个更大的页块，也就是，在512个页框的链表中找一个空闲块。如果存在这样的块，内核就把512的页框分成两等分，一般用作满足需求，另一半则插入到256个页框的链表中。

如果在512个页框的块链表中也没找到空闲块，就继续找更大的块——1024个页框的块。如果这样的块存在，内核就把1024个页框块的256个页框用作请求，然后剩余的768个页框中拿512个插入到512个页框的链表中，再把最后的256个插入到256个页框的链表中。如果1024个页框的链表还是空的，算法就放弃并发出错误信号。

Zone结构体中的free_area数组的第k个元素，它保存了所有连续大小为2^k的空闲块，具体是通过将连续页的第一个页插入到free_list中实现的，连续页的第一个页的页描述符的private字段表明改部分连续页属于哪一个order链表。

Linux内核启动时，伙伴算法还不可用，linux是通过bootmem来管理内存，在mem_init中会把bootmem位图中空闲的内存块插入到伙伴算法系统的free_list中。

调用流程如下：

mem_init----->__free_all_bootmem()—>free_all_bootmem()>free_all_bootmem_core(NODE_DATA(0))–>free_all_bootmem_core(pgdat)

4.3分配过程

现内存总容量为16KB，用户请求分配4KB大小的内存空间，且规定最小的内存分配单元是2KB。于是位图分为8个区域，用1表示已分配，用0表示未分配，则初始位图和空闲链表如图所示。从上到下依次是位图、内存块、空闲链表。

图片

由于需要分配4KB内存，数显到链表中4KB位置进行查看，发现为空，于是继续向后查找8KB位置，发现仍为空，直到到达链表尾16KB位置不为空。16KB块分裂成两个8KB的块，其中一块插入到链表相应位置，另一块继续分裂成两个4KB的块，其中一个交付使用，另一个插入到链表中，结果如下图所示：

图片

内存回收是内存分配的逆过程，假设以上存储要释放4KB内存，首先到链表中4KB位置查看是否有它的“伙伴”，发现该位置不为空，于是合并成一个8KB的块，继续寻找它的“伙伴”，然后合并成一个16KB的块，插入链表中。若在查找过程中没有发现“伙伴”，则直接插入到链表中，然后将位图中的标记清零，表示内存可用。

当程序请求内存时，Linux 内核内存伙伴算法会按照以下步骤进行分配：

首先从空闲的内存中搜索比申请的内存大的最小的内存块。例如，如果程序请求一个大小为特定值（假设为 N）的内存块，伙伴算法会先在与 N 大小相同的块链表中查找空闲块。如果没有找到合适的块，就会去更大的块链表中继续查找。

如果这样的内存块存在，则将这块内存标记为 “已用”，同时将该内存分配给应用程序。比如，假设程序请求的内存大小处于某个特定范围（比如 129 - 256 个页框），算法会先在 256 个页框的链表中检查是否有空闲块。若存在这样的块，就可以直接分配给程序使用。

如果这样的内存不存在，则操作系统将寻找更大块的空闲内存，然后将这块内存平分成两部分，一部分返回给程序使用，另一部分作为空闲的内存块等待下一次被分配。例如，若在特定大小的链表中（如 256 个页框的链表）没有找到空闲块，算法会查找下一个更大的页块，如在 512 个页框的链表中找一个空闲块。如果存在这样的块，内核就把 512 的页框分成两等分，一半用作满足需求，另一半则插入到 256 个页框的链表中。如果在 512 个页框的块链表中也没找到空闲块，就继续找更大的块，如 1024 个页框的块。如果这样的块存在，内核就把 1024 个页框块的一部分（满足程序需求的大小）用作请求，然后将剩余部分按照大小插入到相应的链表中等待后续分配。

4.4释放过程

当程序释放内存时，Linux 内核内存伙伴算法会执行以下操作：

操作系统首先将该内存回收，然后检查与该内存相邻的内存是否是同样大小并且同样处于空闲的状态。例如，当释放一个特定大小的内存块（假设为 256 个页框的块）时，算法就把其插入到 256 个页框的链表中，然后检查与该内存相邻的内存。

如果是，则将这两块内存合并，然后程序递归进行同样的检查，试图合并更大的块。如果存在同样大小为 256 个页框的并且空闲的内存，就将这两块内存合并成 512 个页框，然后插入到 512 个页框的链表中。如果合并后的 512 个页框的内存存在大小为 512 个页框的相邻且空闲的内存，则将两者合并，然后插入到 1024 个页框的链表中。如果不存在合适的伙伴块，就直接把要释放的块挂入链表头等待后续可能的合并操作。

五、CMA算法

在应用程序中，我们申请的内存从虚拟地址角度看是连续的，因为虚拟地址本身具有连续性。但在实际的物理内存空间中，所申请的这片内存未必是连续的。不过对于有内存管理单元（MMU）的系统来说，这并不会影响应用程序的正常运行，因为 MMU 可以将物理地址映射成虚拟地址，应用程序无需关心实际的内存情况。

但如果是没有 MMU 的情况呢？当设备需要通过 DMA 直接访问内存时，就迫切需要一片连续的内存空间，而 CMA 机制正是为了解决这一棘手问题而诞生的。DMA zone 区域并非 DMA 设备专属，其他程序也可以申请该区域的内存。当设备要申请 DMA zone 空间中的一大片连续内存时，如果此时已经没有连续的大片内存，只有 1 页、2 页、4 页等连续的小内存，CMA 机制就会发挥作用。

系统会事先标记某一片连续区域为 CMA 区域，在没有大片连续内存申请时，这片区域只给可移动（moveable）的程序使用。当有大片连续内存请求到来时，系统会前往这片 CMA 区域，将所有可移动的小片内存移动到其它的非 CMA 区域，并更改对应的程序页表，然后把空出来的 CMA 区域分配给设备，从而完美实现了 DMA 大片连续内存的分配。CMA 机制并非孤立存在，它通常是为 DMA 设备服务的。当设备调用dma_alloc_coherent函数申请内存后，为了确保得到一片连续的内存，CMA 机制就会被触发调用，以保证申请内存的连续性。此外，CMA 区域通常被分配在高端内存，以满足特定的内存需求场景 。

六、slab算法

当在驱动程序中，遇到反复分配、释放同一大小的内存块时（例如，inode、task_struct等），建议使用内存池技术（对象在前后两次被使用时均分配在同一块内存或同一类内存空间，且保留了基本的数据结构，这大大提高了效率）。在linux中，有一个叫做slab分配器的内存池管理技术，内存池使用的内存区叫做后备高速缓存。

salb相关头文件在linux/slab.h中，在使用后备高速缓存前，需要创建一个kmem_cache的结构体。

6.1创建slab缓存区

该函数创建一个slab缓存（后备高速缓冲区），它是一个可以驻留任意数目全部同样大小的后备缓存。其原型如下：

其中：

6.2分配slab缓存函数

一旦创建完后备高速缓冲区后，就可以调用kmem_cache_alloc()在缓存区分配一个内存块对象了，其原型如下：

cachep指向开始分配的后备高速缓存，flags与传给kmalloc函数的参数相同，一般为GFP_KERNEL。

6.3释放slab缓存

该函数释放一个内存块对象：

6.4销毁slab缓存

与kmem_cache_create对应的是销毁函数，释放一个后备高速缓存：

它必须等待所有已经分配的内存块对象被释放后才能释放后备高速缓存区。

6.5slab缓存使用举例

创建一个存放线程结构体（struct thread_info）的后备高速缓存，因为在linux中涉及频繁的线程创建与释放，如果使用__get_free_page()函数会造成内存的大量浪费，效率也不高。所以在linux内核的初始化阶段就创建了一个名为thread_info的后备高速缓存，代码如下：

七、内存池

在 Linux 内核中还包含对内存池的支持，内存池技术也是一种非常经典的用于分配大量小对象的后备缓存技术。

7.1创建内存池

mempool_create()函数用于创建一个内存池，min_nr 参数是需要预分配对象的数目，alloc_fn 和 free_fn 是指向内存池机制提供的标准对象分配和回收函数的指针，其原型分别为：

pool_data 是分配和回收函数用到的指针，gfp_mask 是分配标记。只有当_ _GFP_WAIT 标记被指定时，分配函数才会休眠。

7.2分配和回收对象

在内存池中分配和回收对象需由以下函数来完成：

mempool_alloc()用来分配对象，如果内存池分配器无法提供内存，那么就可以用预分配的池。

7.3销毁内存池

mempool_create()函数创建的内存池需由 mempool_destroy()来回收。

八、应用案例分析

8.1实际场景中的应用

在服务器运维领域，内存分配方式的选择对系统性能有着显著影响。以运行数据库服务的服务器为例，数据库系统需要频繁地读写数据，对内存的需求十分庞大且复杂。在这种场景下，Buddy 算法就发挥着重要作用，它能够为数据库分配连续的大块内存，确保数据的快速存储和读取。同时，slab 算法也不可或缺，数据库中存在许多频繁使用的小数据结构，如数据库连接池中的连接对象、缓存中的数据块描述符等，slab 算法能够高效地管理这些小内存块的分配和回收，大大提高了数据库系统的运行效率。

在嵌入式开发场景中，CMA 算法的应用则尤为关键。比如在开发一款基于 Linux 系统的智能摄像头设备时，摄像头需要通过 DMA 将拍摄的图像数据快速传输到内存中进行处理。由于图像数据量较大，需要连续的内存空间来保证数据传输的稳定性和高效性。此时，CMA 算法就可以提前预留出一片连续的内存区域作为 CMA 区域，当摄像头设备需要申请内存时，系统能够及时从 CMA 区域中分配出连续的内存，满足摄像头对 DMA 连续内存的需求，确保图像数据的正常传输和处理，为智能摄像头的稳定运行提供了有力保障 。

8.2遇到的问题及解决办法

在实际使用过程中，内存分配可能会引发各种问题。例如，在一个长时间运行的服务器应用中，由于频繁地进行内存分配和释放操作，可能会导致内存碎片过多。当内存碎片达到一定程度时，即使系统中存在足够的空闲内存，也可能无法分配出连续的大块内存，从而导致某些需要大块连续内存的操作失败，如数据库的大规模数据加载。为了解决这个问题，可以采用内存整理工具，如defragment命令（需 root 权限运行），对内存进行碎片整理，使内存空间变得更加连续，提高内存的利用率 。

再比如，在嵌入式设备开发中，可能会遇到内存分配失败的情况。这可能是由于设备内存资源有限，而应用程序对内存的需求过大导致的。当这种情况发生时，可以通过优化应用程序的内存使用方式来解决。例如，采用内存池技术，预先分配一块连续的内存空间，在需要时从内存池中分配内存，避免频繁地进行系统级的内存分配和释放操作，从而减少内存碎片的产生，提高内存分配的成功率。同时，合理调整应用程序的功能和数据结构，减少不必要的内存占用，也是解决内存分配失败问题的有效途径 。

8.3教你如何查看内存分配情况

了解了 Linux 内存的常见分配方式后，学会如何查看内存分配情况也是非常重要的，这有助于我们实时监控系统内存的使用状态，及时发现潜在的问题 。

在 Linux 系统中，我们可以通过/proc/buddyinfo文件来查看 Buddy 算法的内存分配情况。这个文件详细记录了每个内存节点和区域中不同阶的空闲内存块数量 。例如，在一个单节点系统中，/proc/buddyinfo文件的内容可能如下：

从这些数据中，我们可以清晰地看到不同区域（如 DMA、DMA32、Normal）中不同大小内存块（从 order0 到 order10，对应不同的 2 的幂次方大小）的可用数量。通过分析这些数据，我们可以判断系统内存的碎片化程度。如果高阶块（如 order10）的可用块较少，可能表明内存碎片化严重，难以分配到大块连续内存；如果低阶块（如 order0 或 order1）的可用块较少，则可能表示系统内存紧张 。

对于 slab 算法的内存分配情况，我们可以使用cat /proc/slabinfo命令来查看。执行该命令后，会输出一系列的信息，每一行代表一个 slab 缓存 。例如：

在这些输出信息中，active_objs表示当前活跃的对象数量，num_objs表示对象总数，objsize表示每个对象的大小，objperslab表示每个 slab 中包含的对象数量，pagesperslab表示每个 slab 占用的页数。通过这些数据，我们可以了解到各个 slab 缓存的使用情况，判断是否存在内存分配不合理的情况 。比如，如果某个 slab 缓存中active_objs数量长期很高，而num_objs与active_objs相差不大，可能说明该 slab 缓存中的对象频繁被使用，需要进一步优化内存分配策略 。

除了上述方法外，我们还可以使用free命令查看系统的物理内存和交换空间使用情况，包括空闲和已用内存的数量、缓冲区和缓存的大小等信息。运行free -h可以以易于阅读的方式显示结果 。top命令也是一个实时监测系统资源的工具，它可以显示当前系统的进程、CPU、内存、磁盘等使用情况，在top的输出中，我们能够查看内存使用情况的相关信息，包括总内存、已用内存、空闲内存等 。

htop命令是一个增强版的top命令，提供了更多的交互式功能和可视化显示，允许我们查看进程的内存使用情况，以及各个进程所占用的内存大小 。这些工具和命令相互配合，能够帮助我们全面、深入地了解 Linux 系统的内存分配情况，为系统的优化和管理提供有力的支持 。