塊分配器 有幾種實(shí)現(xiàn)方式，分別為：

• SLAB：適用于 大量物理內(nèi)存 的機(jī)器
• SLUB：與 SLAB 相同，在 SLAB 的基礎(chǔ)上進(jìn)行優(yōu)化，其內(nèi)存開銷比較小
• SLOB：適用于 小內(nèi)存 的嵌入式機(jī)器

2.5.1 塊分配器接口

雖然 塊分配器 具有多種實(shí)現(xiàn)，但對外提供了統(tǒng)一接口，只是底層實(shí)現(xiàn)不同。

2.5.1.1 通用內(nèi)存緩存接口

• kmalloc：用于 分配內(nèi)存。塊分配器找到一個(gè)合適的 通用內(nèi)存緩存(即對象長度剛好大于或等于請求的內(nèi)存長度)，從中 分配對象 并返回 對象地址。
• krealloc：用于 重新 分配內(nèi)存，根據(jù)新的長度為對象分配新的內(nèi)存。
• kfree：釋放內(nèi)存

通用內(nèi)存緩存接口 需要找到一個(gè) 對象長度剛好大于或等于請求的內(nèi)存長度 的 通用緩存。如果請求的內(nèi)存長度和申請到的內(nèi)存緩存對象的長度相差太遠(yuǎn)會(huì)浪費(fèi)較大的內(nèi)存

2.5.1.2 專用內(nèi)存緩存接口

為了解決 通用內(nèi)存緩存的問題，可以使用 專用內(nèi)存緩存。專用內(nèi)存緩存 可以指定 對象長度，有效解決內(nèi)存浪費(fèi)的問題。其接口如下：

• keme_cache_create：創(chuàng)建內(nèi)存緩存
• kmem_cache_destroy：銷毀內(nèi)存緩存
• kmem_cache_alloc：從內(nèi)存緩存中分配對象
• kmem_cache_free：釋放對象，將其放回內(nèi)存緩存中

2.5.2 SLAB分配器

本小節(jié)將簡單地介紹 SLAB分配器 的原理，有助理解內(nèi)核的內(nèi)存管理。
SLAB 的數(shù)據(jù)結(jié)構(gòu)如圖所示：

SLAB

圖中需要關(guān)注的數(shù)據(jù)結(jié)構(gòu)有 3個(gè)：

• struct kmem_cache：即 內(nèi)存緩存，所有操作都在該結(jié)構(gòu)體上
• struct kmem_cache_node：即 內(nèi)存緩存節(jié)點(diǎn)，每一個(gè) 內(nèi)存節(jié)點(diǎn) 都對應(yīng)一個(gè)該結(jié)構(gòu)體
• struct page：即 page示例，一個(gè) page實(shí)例 對應(yīng)一個(gè) 物理頁

2.5.2.1 struct kmem_cache

其結(jié)構(gòu)體代碼如下：

struct array_cache {
    /* 數(shù)組entry存放的可用對象數(shù)量 */
    unsigned int avail;
    /* 數(shù)組entry的大小 */
    unsigned int limit;
    /* 對象地址數(shù)組，用于存放釋放對象的指針 */
    void *entry[];
};

struct kmem_cache {
    /* 
    指向本地CPU高速緩存的指針數(shù)組。每個(gè)CPU在其中都有對應(yīng)的結(jié)構(gòu)體。
    當(dāng)有對象釋放時(shí)，優(yōu)先放入本地CPU高速緩存中 
    */
    struct array_cache __percpu *cpu_cache;
    /* 每個(gè)SLAB擁有的對象數(shù)量 */
    unsigned int num;
    /* slab的階數(shù)，代表slab擁有即2^gfporder個(gè)物理頁 */
    unsigned int gfporder;
    /* 對象的原始長度 */
    int object_size;
    /* 
    每個(gè)對象都帶有填充信息，以讓塊分配器可以進(jìn)行某些操作 
    size = 填充信息長度 + object_size
    */
    int size;
    /* slab節(jié)點(diǎn)鏈表，每個(gè)內(nèi)存節(jié)點(diǎn)都對應(yīng)一個(gè)鏈表節(jié)點(diǎn) */
    struct kmem_cache_node *node[MAX_NUMNODES];
};

1. 將 剛釋放的對象 存放在 cpu_cache 可以有效的 減少鏈表操作和鎖操作，并提高分配速度。
2. size 和 object_size 的關(guān)系如下圖所示：
   
   size關(guān)系圖
   • 修改幻數(shù)1：長度 8字節(jié)，如果該值被修改說明對象被改寫。該字段打開調(diào)試宏時(shí)才有
   • 修改幻數(shù)2：與 修改幻數(shù)1 相同。該字段打開調(diào)試宏時(shí)才有
   • 最后調(diào)用者地址：長度 8字節(jié)，用于確定對象被誰改寫。該字段打開調(diào)試宏時(shí)才有
     PS：關(guān)于這3個(gè)調(diào)試字段，有興趣的讀者自行查閱資料

2.5.2.2 struct kmem_cache_node

重要成員代碼如下：

/* kmem_cache_node鏈表的節(jié)點(diǎn)，本質(zhì)上就是一個(gè)page實(shí)例，即物理頁  */
struct page {
    /* 本質(zhì)是一個(gè)數(shù)組，該指針指向第一個(gè)對象的地址 */
    void *s_mem;
    /* 本質(zhì)是一個(gè)數(shù)組，其元素存放的是空閑對象在s_mem數(shù)組中的下標(biāo) */
    void *freelist; 
    /* 
    active具有2層含義：
    1. 記錄該slab分配出去的對象數(shù)量
    2. 是一個(gè)數(shù)組下標(biāo)，指向freelist數(shù)組中的第一個(gè)空閑對象下標(biāo)。該下標(biāo)所在的元素是s_mem中對象的下表你
     */
    unsigned int active;
    /* 鏈表節(jié)點(diǎn)，用于串起多個(gè)slab */
    struct list_head lru;
    /* 指向所屬的內(nèi)存緩存 */
    struct kmem_cache *slab_cache;
};
struct kmem_cache_node {
    /* 只分配了部分對象的slab(page)鏈表 */
    struct list_head slabs_partial;
    /* 所有對象都已經(jīng)分配出去的slab(page)鏈表 */
    struct list_head slabs_full;
    /* 所有對象都空閑的slab(page)鏈表 */
    struct list_head slabs_free;
};

這里可能讀者對于 freelist 和 s_mem 的關(guān)系有些許疑惑，筆者簡單地做以下說明：

1. 空閑階段：此時(shí)沒有分配任何對象，所以可以看到 s_mem 中的所有對象為 空閑， active 也為 0，表示沒有對象分配出去。且 active 指向 freelist 的第一個(gè)元素，而 freelist 被 active 所指向的元素的值為 0，表明此時(shí) s_mem 中下標(biāo)為 freelistactive 的對象是 空閑的
   

   空閑階段

2. 分配階段：此時(shí)分配出 1個(gè)對象，可以看到 s_mem 中的 對象0 已經(jīng)被分配出去了。且 active 的值為 1，指向了 freelist 的元素也改變了
   

   分配階段

3. 連續(xù)分配：經(jīng)過多次使用，s_mem 已經(jīng)分配出 3 個(gè)對象了，其中 active 的值為 3。指向了 freelist 的元素值為 3，s_mem[freelist[active]] 的對象是空閑的。以此類推
   

   連續(xù)分配

4. 釋放階段：使用完了以后釋放 對象0，可以看到 freelist[active] 的值為 0，那么 s_mem[freelist[active]] 的對象已經(jīng)被釋放且狀態(tài)為 空閑
   

   釋放階段

從代碼中可以看出 freelist 僅僅只是一個(gè) 指針，那么就需要為這個(gè)指針 開辟內(nèi)存空間。而關(guān)于存放該內(nèi)存空間的地方也有一定的講究，這里筆者簡單地說明一下，請有興趣的讀者自行查閱資料。

1. 在 s_mem 中分配出一個(gè) 對象 存放 freelist數(shù)組，即使用內(nèi)部空間
2. 重新在 s_mem 之外的地方開辟一個(gè) 數(shù)組 來存放 freelist數(shù)組，即使用外部空間

SLAB分配 會(huì)定時(shí) 回收對象和空閑slab，其實(shí)現(xiàn)方法是在 每個(gè)處理器 上向 全局工作隊(duì)列 添加 延遲工作項(xiàng)，其處理函數(shù)為 cache_reap

一般來講，SLAB 釋放對象后，對象優(yōu)先放在 CPU_cache。當(dāng) CPU_cache 滿了以后再將 空閑對象 批量釋放到 空閑SLAB。而 空閑SLAB 達(dá)到一定數(shù)量后再將 物理頁 釋放到 頁分配器。

2.5.3 SLUB分配器

前面提到 SLAB分配器 釋放 對象 時(shí)會(huì)優(yōu)先回到 CPU_cache，這將造成一個(gè)問題。設(shè)想一下，如果 SLAB 迎來了一個(gè) 分配高峰期，則會(huì)從 頁分配器 申請?jiān)S多 SLAB(物理頁)。之后這些 物理內(nèi)存 將優(yōu)先放回 CPU_cache 和 三個(gè)SLAB鏈表 中，而不是回到 頁分配器，從而造成內(nèi)存浪費(fèi)。

為了解決該問題，內(nèi)核提供了 SLUB分配器，其數(shù)據(jù)結(jié)構(gòu)圖下圖所示：

SLUB

相比于 SLAB分配器，SLUB分配器 有以下改進(jìn)：

• SLUB分配器 的數(shù)據(jù)結(jié)構(gòu)開銷小
• SLUB分配器 僅保留了 部分空閑鏈表(partial_slab)
• SLUB分配器 不進(jìn)行 著色(用于加快內(nèi)存訪問，有興趣讀者請自行查閱資料)

與 SLAB分配器 一樣，重要的數(shù)據(jù)結(jié)構(gòu)還是：

• kmem_cache
• kmem_cache_node
• page

2.5.3.1 kmem_cache

SLUB分配器 部分代碼如下

struct kmem_cache_cpu {
    /* 指向當(dāng)前使用slab的空閑對線鏈表 */
    void **freelist;    
    /* 指向當(dāng)前使用的slab(page實(shí)例) */
    struct page *page;  
    /* 指向當(dāng)前每處理器部分空閑slab鏈表 */
    struct page *partial;   
};
struct kmem_cache {
    /* 處理器緩存 */
    struct kmem_cache_cpu __percpu *cpu_slab;
    /* 對象長度，帶填充信息 */
    int size;   
    /* 對象原始長度 */
    int object_size;    
    /* 
    低16位為最優(yōu)對象數(shù)量
    高16位為最優(yōu)階數(shù)
     */
    struct kmem_cache_order_objects oo;
    /* 
    低16位為最小對象數(shù)量
    高16位為最小階數(shù)
    當(dāng)設(shè)備長時(shí)間運(yùn)行后，內(nèi)存碎片化，分配連續(xù)的物理頁很難成功。如果分配最優(yōu)階數(shù)的slab失敗，則分配最小階數(shù)slab
     */
    struct kmem_cache_order_objects min;
    /* 內(nèi)存節(jié)點(diǎn) */
    struct kmem_cache_node *node[MAX_NUMNODES];
};

與 SLAB分配器 同理，對象所具備的信息不只是對象本身，還附帶有其他填充信息。SLUB分配器 的一種(SLUB分配器有多種對象布局，本文按照下面這種來講述)填充信息如下圖所示：

SLUB對象

除了對象之外的其余 填充信息 均要打開 調(diào)試宏 才具備，其功能與 SLAB分配器 類似，需要注意的是 SLUB對象 將 最后調(diào)用者地址 修改為 分配者地址 和 釋放者地址。

SLAB分配器 的 CPU_cache(每處理器緩存) 是以 對象 為單位，而 SLUB分配器 的 CPU_slab(每處理器緩存) 則以 SLAB 為單位

2.5.3.2 kmem_cache_node

SLUB分配器 的 kmem_cache_node 結(jié)構(gòu)復(fù)用了 SLAB分配器， 其部分重要成員如下：

struct kmem_cache_node {
    /* 空閑slab的數(shù)量 */
    unsigned long nr_partial;
    /* 空閑slab鏈表，鏈表節(jié)點(diǎn)為slab，即page實(shí)例 */
    struct list_head partial;
};

2.5.3.3 page

SLUB分配器 也復(fù)用了 struct page 來作為 鏈表節(jié)點(diǎn)，其部分成員如下：

struct page {
    /* 一般設(shè)置為 PG_SLAB << 1 來表示該頁屬于 SLUB分配器 */
    unsigned long flags;
    /* 空閑對象鏈表 */
    void *freelist;
    struct {
        /* 已分配對象的數(shù)量 */
        unsigned inuse:16;
        /* 對象數(shù)量 */
        unsigned objects:15;
        /* 表示當(dāng)前page實(shí)例是否被凍結(jié)在cpu_slab中 */
        unsigned frozen:1;
    };   
    /* 鏈表節(jié)點(diǎn) */
    struct list_head lru;
    /* 指向所屬的kmem_cache */
    struct kmem_cache *slab_cache;
}

SLAB分配器 的 空閑鏈表是一個(gè)數(shù)組，而 SLUB分配器 的 空閑鏈表 則是一個(gè)貨真價(jià)實(shí)的鏈表。對象 中的 空閑指針 指向了 下一個(gè)對象的地址，從而將所有 對象 串起來。空閑鏈表 的幾種狀態(tài)如下：

• 空閑狀態(tài)：
  
  空閑freelist
• 分配狀態(tài)：修改 freelist指針的指向，如下圖
  
  分配對象

釋放時(shí)將對象繼續(xù)插入回 freelist鏈表。

2.5.3.4 CPU_slab

SLUB分配器 的 CPU_slab 結(jié)構(gòu)圖如下所示：

CPU_slab

struct kmem_cache_cpu {
    /* 指向當(dāng)前使用slab的空閑對線鏈表 */
    void **freelist;    
    /* 指向當(dāng)前使用的slab(page實(shí)例) */
    struct page *page;  
    /* 指向當(dāng)前每處理器部分空閑slab鏈表 */
    struct page *partial;   
};
struct kmem_cache {
    struct kmem_cache_cpu  *cpu_slab;
    /* 處理器緩存 */
    int CPU_partial
};

一些重要數(shù)據(jù)結(jié)構(gòu)的說明如下：

• CPU_slab 中的 page成員 指向了當(dāng)前正在使用的 slab。而 partial 指向了 等待使用的部分空閑slab，并且串成鏈表。
• partial鏈表 的 第一個(gè)slab 中的 pages 表明了該鏈表中 slab的數(shù)量，pobjects 表明鏈表中 空閑對象的數(shù)量。(請注意鏈表后面的slab并沒有使用這2個(gè)成員)
• 內(nèi)存緩存kmem_cache 中的 cpu_partial 決定了 partial鏈表 中 空閑對象的數(shù)量

上面簡單講了數(shù)據(jù)結(jié)構(gòu)之間的關(guān)系，下面我們看看 分配對象 和 釋放對象 時(shí)如何操作 cpu_slab。

• 分配對象：

  1. 從 當(dāng)前處理器 的 cpu_slab 分配，如果 當(dāng)前使用的slab 有 空閑對象，那么分配一個(gè)對象。
  2. 如果 當(dāng)前處理器的cpu_slab鏈表 沒有 空閑對象，那么取 partial鏈表 中的 第一個(gè)slab 作為當(dāng)前使用的slab，并繼續(xù)分配對象

• 釋放對象：

  1. 如果 對象 所屬的 slab 在此之前沒有 空閑對象，并且 沒有凍結(jié) 在 cpu_slab 中，那么把該 slab 存放到 partial鏈表 中
  2. 如果發(fā)現(xiàn) partial鏈表 中的 空閑對象總數(shù) 超過了 cpu_partial，那么把 partial鏈表 中的 所有slab 歸還到 內(nèi)存節(jié)點(diǎn) 的 部分空閑slab鏈表 中。

可以發(fā)現(xiàn)，釋放對象 時(shí)會(huì)檢查 slab 的 空閑對象數(shù)量，并據(jù)此進(jìn)行操作。這樣做的好處是：優(yōu)先使用空閑對象少的slab，并且從中分配對象，減少內(nèi)存浪費(fèi)

2.6 不連續(xù)內(nèi)存分配

當(dāng)設(shè)備長時(shí)間裕興后，內(nèi)存會(huì)碎片化，很難找到 連續(xù)的物理也。如果在這種情況下仍需要分配出 長度超過一頁的內(nèi)存塊，可以使用 不連續(xù)分配器。使用 不連續(xù)分配器 分配 內(nèi)存頁 在 虛擬地址 上是 連續(xù)的，而在 物理地址 上 不連續(xù)。
而且 不連續(xù)分配器 是優(yōu)先從 高端區(qū)域 分配虛擬地址，減少了 常規(guī)線性區(qū)域 的使用。
其實(shí)現(xiàn)原理是使用 MMU 建立 *物理地址 到 虛擬地址 的映射，并使用方法確保 不連續(xù)的物理地址 按照固定的映射關(guān)系映射到 連續(xù)的虛擬地址。

PS：不連續(xù)內(nèi)存分配器的映射單位為物理頁，小于物理頁尺寸的內(nèi)存無法映射到連續(xù)的虛擬地址上，只能將多個(gè)不連續(xù)的物理頁映射到連續(xù)的虛擬地址上

其接口如下：

• vmalloc：分配 不連續(xù)的物理頁 并將 物理頁地址 映射到 連續(xù)的虛擬地址

• vfree：使用內(nèi)存

• vmap(pages, count, flags, prot)：把已經(jīng)分配的 不連續(xù)頁 映射到 連續(xù)的虛地址，參數(shù)如下

  1. pages：page實(shí)例 的指針數(shù)組
  2. count：指針數(shù)組 的大小
  3. flags：標(biāo)志位
  4. prot：保護(hù)位

• vunmap：釋放映射的 虛擬地址

• kvmalloc：優(yōu)先使用 kmalloc 分配內(nèi)存，如果失敗再使用 vmalloc

• kvfree：釋放 kvmalloc 分配的內(nèi)存

那么以上就是本文的所有內(nèi)容，只是簡單地對內(nèi)核的內(nèi)存管理進(jìn)行整理，梳理出框架脈絡(luò)。本文內(nèi)容僅占Linux內(nèi)存管理的冰山一角，有興趣的讀者請自行查閱其他資料補(bǔ)齊知識(shí)框架

三、附錄

3.1 例程代碼

/* 內(nèi)核驅(qū)動(dòng) */
#include <linux/module.h>   
#include <linux/init.h>  
#include <linux/fs.h>   
#include <linux/device.h>   
#include <linux/slab.h>  
#include <linux/cdev.h>  
#include <linux/err.h>  
#include <linux/mm_types.h>  
#include <asm/uaccess.h>  
#include <linux/io.h>  
#include <linux/platform_device.h>
#include <linux/kern_levels.h>
#include <linux/ioport.h>      
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/uaccess.h>


#define DEVICE_MM_SIZE 4096

struct test_device
{
    dev_t n_dev;            
    struct cdev cdev;     
    struct class *dev_class;
    struct device *dev;  
    u8*  share_buffer;
    u32  buffer_size;  
};

static int open(struct inode* inode, struct file* filp)
{   
    printk("device open, filp = %p, f_owner.pid = %p\n", filp, filp->f_owner.pid);
    filp->private_data = (void*)container_of(inode->i_cdev, struct test_device, cdev);
    return 0;
}

static ssize_t read(struct file* filp, char __user * buf, size_t size, loff_t* ppos)
{
    int ret = 0;
    struct test_device* test_device = (struct test_device*)filp->private_data;
    if(size > test_device->buffer_size)
    {
        printk("size(%d) is out of range(%d)\n", size, test_device->buffer_size);
        return -1;
    }

    ret = copy_to_user(buf, test_device->share_buffer, size);
    if(-1 == ret)
    {
        printk("read failed\n");
        return -1;        
    }

    return size;
}

static ssize_t write(struct file* filp, const char __user * buf, size_t size, loff_t* ppos)
{
    int ret = 0;
    struct test_device* test_device = (struct test_device*)filp->private_data;

    if(size > test_device->buffer_size)
    {
        printk("size(%d) is out of range(%d)\n", size, test_device->buffer_size);
        return -1;
    }

    ret = copy_from_user(test_device->share_buffer, buf, size);    
    if(-1 == ret)
    {
        printk("write failed\n");
        return -1;        
    }

    return size;
}

static int mmap(struct file* filp, struct vm_area_struct* vma)
{
    struct test_device* test_device = (struct test_device*)filp->private_data;
    vma->vm_flags |= VM_IO;
    if(remap_pfn_range(vma, 
                       vma->vm_start, 
                       virt_to_phys(test_device->share_buffer) >> PAGE_SHIFT, 
                       vma->vm_end - vma->vm_start, 
                       vma->vm_page_prot))
    {
        return -EAGAIN;
    }
    return 0;
}

static struct file_operations test_fops = 
{
    .owner = THIS_MODULE, 
    .open = open,
    .read = read,
    .write = write,
    .mmap = mmap,
};

static int probe(struct platform_device *pdev)
{
    int ret = 0;
    struct test_device* test_device = NULL;

    /* 1. 為設(shè)備數(shù)據(jù)分配空間 */
    test_device = devm_kzalloc(&pdev->dev, sizeof(struct test_device), GFP_KERNEL);
    if(!test_device)
    {
        printk("can't create test_device\n");
        goto ALLOC_FAIL;
    }
    platform_set_drvdata(pdev, test_device);

    /* 2.1 分配設(shè)備號(hào) */
    int base_minor = 0;
    int n_num = 1;
    ret = alloc_chrdev_region(&test_device->n_dev, base_minor, n_num, "test_device");
    if(0 != ret)
    {
        printk(KERN_INFO"can't alloc a chrdev number\n");
        goto REGION_FAIL;
    }
    printk("major = %d, minor = %d\n", MAJOR(test_device->n_dev), MINOR(test_device->n_dev));

    /* 2.2 初始化字符設(shè)備 */
    int dev_count = 1;
    cdev_init(&test_device->cdev, &test_fops);
    test_device->cdev.owner = THIS_MODULE;
    ret = cdev_add(&test_device->cdev, test_device->n_dev, dev_count);
    if(0 != ret)
    {
        printk(KERN_INFO"add a cdev error\n");
        goto CDEV_FAILE;
    }  

    /* 2.3 創(chuàng)建設(shè)備，發(fā)出uevent事件 ,在/sys/class/目錄下創(chuàng)建設(shè)備類別目錄dev_class */
    test_device->dev_class = class_create(THIS_MODULE, "dev_class");
    if(IS_ERR(test_device->dev_class)) 
    {
        printk(KERN_INFO"create a class error\n");
        goto CDEV_FAILE;
    }       

    /* 2.4 在/dev/目錄和/sys/class/gpio_class目錄下分別創(chuàng)建設(shè)備文件gpio_dev */
    test_device->dev = device_create(test_device->dev_class, NULL, test_device->n_dev, NULL, "test_dev");
    if(IS_ERR(test_device->dev)) 
    {
        printk(KERN_INFO"create a device error\n");
        goto CLASS_FAILE;
    }

    test_device->buffer_size = DEVICE_MM_SIZE;
#if 1    
    /*
        請注意，要進(jìn)行mmap映射的內(nèi)存地址必須是4k對齊，不然應(yīng)用層使用mmap映射后的地址可能是不對的。
        筆者理解是：因?yàn)閞emap_pfn_range調(diào)用會(huì)對地址進(jìn)行檢查，將地址映射到4k對齊的虛擬地址。
        舉個(gè)例子，假如該內(nèi)存地址是不對齊的，比如為0x0000fb10，那么有可能會(huì)導(dǎo)致地址映射到0x0000fb00，這樣導(dǎo)致應(yīng)用層映射到的地址是從0x0000fb00開始
    */
    test_device->share_buffer = kmalloc(test_device->buffer_size, GFP_KERNEL);
#else
    /*
        使用devm_kzalloc會(huì)導(dǎo)致出來的地址并不是4k對齊，從而導(dǎo)致應(yīng)用層會(huì)發(fā)生映射錯(cuò)誤
        筆者一開始使用的是devm_kzalloc分配，分配出來的地址為0xc3b96010，從而導(dǎo)致應(yīng)用層讀取錯(cuò)誤，需要加上16的便宜才能訪問到正確的地址
        修改為kmalloc，分配出來的地址是0xb6f9a000，該地址是4k對齊，所以應(yīng)用層映射后的地址是正確的。
    */
    test_device->share_buffer = devm_kzalloc(&pdev->dev, test_device->buffer_size, GFP_KERNEL);
#endif
    if(!test_device->share_buffer)
    {
        printk("can't create share buffer\n");
        goto ALLOC_BUFFER_FAIL;
    }

    return 0;
ALLOC_BUFFER_FAIL:
    device_destroy(test_device->dev_class, test_device->n_dev);
CLASS_FAILE:
    class_destroy(test_device->dev_class);
CDEV_FAILE:    
    unregister_chrdev_region(test_device->n_dev, n_num); 
REGION_FAIL:    
    devm_kfree(&pdev->dev, test_device); 
ALLOC_FAIL:
    return -1;
}  
static int remove(struct platform_device *pdev)
{    
    struct test_device* test_device = (struct test_device*)platform_get_drvdata(pdev);
    int n_num = 1;
#if 1  
    kfree(test_device->share_buffer);
#else
    devm_kfree(&pdev->dev, test_device->share_buffer);
#endif    
    device_destroy(test_device->dev_class, test_device->n_dev);
    class_destroy(test_device->dev_class);
    cdev_del(&test_device->cdev);
    unregister_chrdev_region(test_device->n_dev, n_num); 
    devm_kfree(&pdev->dev, test_device);
    return 0;
}  

static const struct of_device_id of_dev_match[] = {
    { .compatible = "device_node", .data = NULL},
    {},
};
static struct platform_driver dev_driver = {
    .probe  = probe,
    .remove = remove,
    .driver = {
        .name   = "dev_driver",
        .of_match_table = of_dev_match,
    },
};

module_platform_driver(dev_driver);
MODULE_LICENSE("GPL");  

/* 應(yīng)用代碼 */
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <strings.h>

#define MM_SIZE 4096

int main(int argc, char* argv[])
{
    int dev_fd = 0;
    char* buf_addr = NULL;
    char buffer[MM_SIZE] = {0};

    dev_fd = open("/dev/test_dev", O_RDWR);//必須設(shè)置為O_RDWR，不然無法使用MAP_SHARED映射標(biāo)志
    if(-1 == dev_fd)
    {
        printf("open device error\n");
        return -1;
    }

    buf_addr = mmap(NULL, MM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, dev_fd, 0) + 16;
    
    strcpy(buf_addr, "read_device_mmap");
    bzero(buffer, MM_SIZE);
    int ret = read(dev_fd, buffer, MM_SIZE);
    printf("read buffer: %s\n", buffer);

    
    bzero(buffer, MM_SIZE);
    write(dev_fd, buffer, MM_SIZE);
    write(dev_fd, "write_device_mmap", strlen("write_device_mmap"));
    printf("write buffer: %s\n", buf_addr);

    munmap(buf_addr, MM_SIZE);
}

3.2 參考鏈接

mm_struct
認(rèn)真分析mmap：是什么 為什么 怎么用
linux內(nèi)核線程的問題
CPU與內(nèi)存互聯(lián)的架構(gòu)演變
Linux系統(tǒng)調(diào)用--mmap/munmap函數(shù)詳解
linux用戶態(tài)和kernel之間共享內(nèi)存
io_remap_pfn_range
linux內(nèi)存管理 之 內(nèi)存節(jié)點(diǎn)和內(nèi)存分區(qū)
linux內(nèi)存源碼分析 - SLAB分配器概述
Linux內(nèi)存管理 (5)slab分配器
Linux slab 分配器剖析
slab為什么要進(jìn)行著色處理
slab著色區(qū)的作用
SLUB和SLAB的區(qū)別
Linux驅(qū)動(dòng)mmap內(nèi)存映射