[wangyubin@localhost ]$ getconf -a | grep -i 'page'

PAGESIZE                           4096
PAGE_SIZE                          4096
_AVPHYS_PAGES                      637406
_PHYS_PAGES                        2012863

/*
 * 頁中包含的成員非常多，還包含了一些聯(lián)合體
 * 其中有些字段我暫時還不清楚含義，以后再補上。。。
 */
struct page {
    unsigned long flags;    /* 存放頁的狀態(tài)，各種狀態(tài)參見<linux/page-flags.h> */
    atomic_t _count;        /* 頁的引用計數(shù) */
    union {
        atomic_t _mapcount;    /* 已經(jīng)映射到mms的pte的個數(shù) */
        struct {        /* 用于slab層 */
            u16 inuse;
            u16 objects;
        };
    };
    union {
        struct {
        unsigned long private;        /* 此page作為私有數(shù)據(jù)時，指向私有數(shù)據(jù) */
        struct address_space *mapping;    /* 此page作為頁緩存時，指向關聯(lián)的address_space */
        };
#if USE_SPLIT_PTLOCKS
        spinlock_t ptl;
#endif
        struct kmem_cache *slab;    /* 指向slab層 */
        struct page *first_page;    /* 尾部復合頁中的第一個頁 */
    };
    union {
        pgoff_t index;        /* Our offset within mapping. */
        void *freelist;        /* SLUB: freelist req. slab lock */
    };
    struct list_head lru;    /* 將頁關聯(lián)起來的鏈表項 */
#if defined(WANT_PAGE_VIRTUAL)
    void *virtual;            /* 頁的虛擬地址 */
#endif /* WANT_PAGE_VIRTUAL */
#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
    unsigned long debug_flags;    /* Use atomic bitops on this */
#endif

#ifdef CONFIG_KMEMCHECK
    /*
     * kmemcheck wants to track the status of each byte in a page; this
     * is a pointer to such a status block. NULL if not tracked.
     */
    void *shadow;
#endif
};

extern void __free_pages(struct page *page, unsigned int order);
extern void free_pages(unsigned long addr, unsigned int order);
extern void free_hot_page(struct page *page);

/**
 * @size  - 申請分配的字節(jié)數(shù)
 * @flags - 上面討論的各種 gfp_mask
 */
static __always_inline void *kmalloc(size_t size, gfp_t flags)
#+end_src

vmalloc的定義在 mm/vmalloc.c 中
#+begin_src C
/**
 * @size - 申請分配的字節(jié)數(shù)
 */
void *vmalloc(unsigned long size)

void kfree(const void *)
void vfree(const void *)

struct slab {
    struct list_head list;   /* 存放緩存對象，這個鏈表有 滿，部分滿，空 3種狀態(tài)  */
    unsigned long colouroff; /* slab 著色的偏移量 */
    void *s_mem;             /* 在 slab 中的第一個對象 */
    unsigned int inuse;         /* slab 中已分配的對象數(shù) */
    kmem_bufctl_t free;      /* 第一個空閑對象(如果有的話) */
    unsigned short nodeid;   /* 應該是在 NUMA 環(huán)境下使用 */
};

/**
 * 創(chuàng)建高速緩存
 * 參見文件： mm/slab.c
 * 這個函數(shù)的注釋很詳細，這里就不多說了。
 */
struct kmem_cache *
kmem_cache_create (const char *name, size_t size, size_t align,
    unsigned long flags, void (*ctor)(void *))

/**
 * 從高速緩存中分配對象也很簡單
 * 函數(shù)參見文件：mm/slab.c
 * @cachep - 指向高速緩存指針
 * @flags  - 之前討論的 gfp_mask 標志，只有在高速緩存中所有slab都沒有空閑對象時，
 *           需要申請新的空間時，這個標志才會起作用。
 *
 * 分配成功時，返回指向對象的指針
 */
void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)

/**
 * 向高速緩存釋放對象
 * @cachep - 指向高速緩存指針
 * @objp   - 要釋放的對象的指針
 */
void kmem_cache_free(struct kmem_cache *cachep, void *objp)

/**
 * 銷毀高速緩存
 * @cachep - 指向高速緩存指針 
 */
void kmem_cache_destroy(struct kmem_cache *cachep)

#include <linux/slab.h>
#include <linux/slab_def.h>
#include "kn_common.h"

MODULE_LICENSE("Dual BSD/GPL");

#define MYSLAB "testslab"

static struct kmem_cache *myslab;

/* 申請內存時調用的構造函數(shù) */
static void ctor(void* obj)
{
    printk(KERN_ALERT "constructor is running....\n");
}

struct student
{
    int id;
    char* name;
};

static void print_student(struct student *);


static int testslab_init(void)
{
    struct student *stu1, *stu2;
    
    /* 建立slab高速緩存，名稱就是宏 MYSLAB */
    myslab = kmem_cache_create(MYSLAB,
                               sizeof(struct student),
                               0,
                               0,
                               ctor);

    /* 高速緩存中分配2個對象 */
    printk(KERN_ALERT "alloc one student....\n");
    stu1 = (struct student*)kmem_cache_alloc(myslab, GFP_KERNEL);
    stu1->id = 1;
    stu1->name = "wyb1";
    print_student(stu1);
    
    printk(KERN_ALERT "alloc one student....\n");
    stu2 = (struct student*)kmem_cache_alloc(myslab, GFP_KERNEL);
    stu2->id = 2;
    stu2->name = "wyb2";
    print_student(stu2);
    
    /* 釋放高速緩存中的對象 */
    printk(KERN_ALERT "free one student....\n");
    kmem_cache_free(myslab, stu1);

    printk(KERN_ALERT "free one student....\n");
    kmem_cache_free(myslab, stu2);

    /* 執(zhí)行完后查看 /proc/slabinfo 文件中是否有名稱為 “testslab”的緩存 */
    return 0;
}

static void testslab_exit(void)
{
    /* 刪除建立的高速緩存 */
    printk(KERN_ALERT "*************************\n");
    print_current_time(0);
    kmem_cache_destroy(myslab);
    printk(KERN_ALERT "testslab is exited!\n");
    printk(KERN_ALERT "*************************\n");

    /* 執(zhí)行完后查看 /proc/slabinfo 文件中是否有名稱為 “testslab”的緩存 */
}

static void print_student(struct student *stu)
{
    if (stu != NULL)
    {
        printk(KERN_ALERT "**********student info***********\n");
        printk(KERN_ALERT "student id   is: %d\n", stu->id);
        printk(KERN_ALERT "student name is: %s\n", stu->name);
        printk(KERN_ALERT "*********************************\n");
    }
    else
        printk(KERN_ALERT "the student info is null!!\n");    
}

module_init(testslab_init);
module_exit(testslab_exit);

# must complile on customize kernel
obj-m += myslab.o
myslab-objs := testslab.o kn_common.o

#generate the path
CURRENT_PATH:=$(shell pwd)
#the current kernel version number
LINUX_KERNEL:=$(shell uname -r)
#the absolute path
LINUX_KERNEL_PATH:=/usr/src/kernels/$(LINUX_KERNEL)
#complie object
all:
    make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
    rm -rf modules.order Module.symvers .*.cmd *.o *.mod.c .tmp_versions *.unsigned
#clean
clean:
    rm -rf modules.order Module.symvers .*.cmd *.o *.mod.c *.ko .tmp_versions *.unsigned

[root@vbox chap12]# make
[root@vbox chap12]# insmod myslab.ko 
[root@vbox chap12]# dmesg | tail -220 
# 可以看到第一次申請內存時，系統(tǒng)一次分配很多內存用于緩存(構造函數(shù)執(zhí)行了多次)
[root@vbox chap12]# cat /proc/slabinfo | grep test #查看我們建立的緩存名在不在系統(tǒng)中
testslab               0      0     16  202    1 : tunables  120   60    0 : slabdata      0      0      0
[root@vbox chap12]# rmmod myslab.ko #卸載內核模塊
[root@vbox chap12]# cat /proc/slabinfo | grep test #我們的緩存名已經(jīng)不在系統(tǒng)中了

/* 將 ZONE_HIGHMEM 區(qū)的一個page永久的映射到內核地址空間
 * 返回值即為這個page對應的邏輯地址
 */
static inline void *kmap(struct page *page)

/* 允許永久映射的數(shù)量是有限的，所以不需要高端內存時，應該及時的解除映射 */
static inline void kunmap(struct page *page)

/**
 * 將 ZONE_HIGHMEM 區(qū)的一個page臨時映射到內核地址空間
 * 其中的 km_type 表示映射的目的，
 * enum kn_type 的定義參見：<asm/kmap_types.h>
 */
static inline void *kmap_atomic(struct page *page, enum km_type idx)

/* 相應的解除映射是個宏 */
#define kunmap_atomic(addr, idx)    do { pagefault_enable(); } while (0)

[xxxxx@localhost ~]$ ulimit -a | grep 'stack'
stack size              (kbytes, -s) 8192

void* p;

if (p == NULL)
{
/* 對 P 進行相應的操作，最終 P 不是NULL了 */
}
else
{
/* P 不是NULL，繼續(xù)對 P 進行相應的操作 */
}

/* 給每個CPU聲明一個類型為 type，名稱為 name 的變量 */
DECLARE_PER_CPU(type, name)
/* 給每個CPU定義一個類型為 type，名稱為 name 的變量 */
DEFINE_PER_CPU(type, name)

DEFINE_PER_CPU(int, name);      /* 為每個CPU定義一個 int 類型的name變量 */

get_cpu_var(name)++;            /* 當前處理器上的name變量 +1 */
put_cpu_var(name);              /* 完成對name的操作后，激活當前處理器的內核搶占 */

#define get_cpu_var(var) (*({                \
    extern int simple_identifier_##var(void);    \
    preempt_disable();/* 這句就是禁止當前處理器上的內核搶占 */    \
    &__get_cpu_var(var); }))
#define put_cpu_var(var) preempt_enable()  /* 這句就是激活當前處理器上的內核搶占 */

/* 給每個處理器分配一個 size 字節(jié)大小的對象，對象的偏移量是 align */
extern void *__alloc_percpu(size_t size, size_t align);
/* 釋放所有處理器上已分配的變量 __pdata */
extern void free_percpu(void *__pdata);

/* 還有一個宏，是按對象類型 type 來給每個CPU分配數(shù)據(jù)的，
 * 其實本質上還是調用了 __alloc_percpu 函數(shù) */
#define alloc_percpu(type)    (type *)__alloc_percpu(sizeof(type), \
                               __alignof__(type))

void *percpu_ptr;
unsigned long *foo;

percpu_ptr = alloc_percpu(unsigned long);
if (!percpu_ptr)
    /* 內存分配錯誤 */

foo = get_cpu_var(percpu_ptr);
/* 操作foo ... */
put_cpu_var(percpu_ptr);