UTS_RELEASE

这个宏定义扩展成字符串, 描述了这个内核树的版本. 例如, "2.6.10".

LINUX_VERSION_CODE

这个宏定义扩展成内核版本的二进制形式, 版本号发行号的每个部分用一个字节表示. 例如, 2.6.10 的编码是 132618 ( 就是, 0x02060a ). ^[4]有了这个信息, 你可以(几乎是)容易地决定你在处理的内核版本.

KERNEL_VERSION(major,minor,release)

这个宏定义用来建立一个整型版本编码, 从组成一个版本号的单个数字. 例如, KERNEL_VERSION(2.6.10) 扩展成 132618. 这个宏定义非常有用, 当你需要比较当前版本和一个已知的检查点.

# If KERNELRELEASE is defined, we've been invoked from the
# kernel build system and can use its language.
ifneq ($(KERNELRELEASE),)
  obj-m := hello.o
# Otherwise we were called directly from the command
# line; invoke the kernel build system.
else
  KERNELDIR ?= /lib/modules/$(shell uname -r)/build
  PWD := $(shell pwd)
default:

$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

endif

module_init(initialization_function): 声明模块初始化函数
module_exit(cleanup_function): 声明模块注销函数

EXPORT_SYMBOL(name): 声明符号在模块外可用

EXPORT_SYMBOL_GPL(name): 声明符号仅对使用 GPL 许可的模块可用.

在模块中声明如下:

static char *whom = "world";
static int howmany = 1;
module_param(howmany, int, S_IRUGO);
module_param(whom, charp, S_IRUGO);

调用时如下:

insmod moduel_name howmany=10 whom="Mom"

比如:

struct test{int a; int b; int c; inte}test_t;
&test_t ==  container_of(&(test_t.c), struct test, c)

__setup("test=", test_setup);

void *kmalloc(size_t size, int flags); 试图分配 size 字节的内存; 返回值是指向那个内存的指针或者如果分配失败为NULL. flags 参数用来描述内存应当如何分配

申请的空间大小限制: 大概为128K

void kfree(void *ptr);分配的内存应当用 kfree 来释放. 传递一个 NULL 指针给 kfree 是合法的.




get_free_page申请的page数限制: 2^MAX_ORDER, 2的MAX_ORDER次方个page. 通常MAX_ORDER=10, 也就是最多2^10=1024个page, 4Mbyte


int access_ok(int type, const void *addr, unsigned long size): 验证用户空间有效性

put_user(datum, ptr) 
__put_user(datum, ptr) 

get_user(local, ptr) 
__get_user(local, ptr) 

如果使用上述四个函数时, 发现一个来自编译器的奇怪消息, 例如"coversion to non-scalar type requested". 必须使用 copy_to_user 或者 copy_from_user.

unsigned long copy_to_user(void __user *to,const void *from,unsigned long count); 拷贝一整段数据到用户地址空间. 任何存取用户空间的函数必须是可重入的. 此函数可能导致睡眠
unsigned long copy_from_user(void *to,const void __user *from,unsigned long count); 从用户地址空间拷贝一整段数据. 任何存取用户空间的函数必须是可重入的. 此函数可能导致睡眠

int capable(int capability); 

int printk(const char * fmt, ...);向console(而不是虚拟终端)打印一条消息, 并通过附加不同的记录级别或者优先级在消息上对消息的严重程度分类.没有指定优先级的printk语句缺省是DEFAULT_MESSAGE_LOGLEVEL, 在 kernel/printk.c里指定作为一个整数. 在2.6.10内核中, DEFAULT_MESSAGE_LOGLEVEL是KERN_WARNING, 但这个值在不同的内核中可能不一样.

int printk_ratelimit(void); 在你认为打印一个可能会常常重复的消息之前调用来避免重复输出很多相同的调试信息. 如果这个函数返回非零值, 继续打印你的消息, 否则跳过打印.
使用举例

int print_dev_t(char *buffer, dev_t dev); 
char *format_dev_t(char *buffer, dev_t dev);

MKDEV(int major, int minor): 讲主次设备号转换成dev_t

int register_chrdev_region(dev_t first, unsigned int count, char *name): 获取一个或多个设备编号来使用

int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, char *name);动态分配一个主编号

void unregister_chrdev_region(dev_t first, unsigned int count); 释放设备编号

设备注册:

struct cdev *cdev_alloc(void);为struct cdev申请内存空间

void cdev_init(struct cdev *cdev, struct file_operations *fops);初始化struct cdev结构. 其成员owner应当设置为 THIS_MODULE

int cdev_add(struct cdev *dev, dev_t num, unsigned int count);将设备注册到内核

void cdev_del(struct cdev *dev);将设备注销

devfs_handle_t devfs_register (devfs_handle_t dir,
            const char *name,
            unsigned int flags,
            unsigned int major, unsigned int minor,
            umode_t mode,
            void *ops, void *info);创建设备节点
dir:需要创建的设备文件所在目录,默认为/dev
name: 需要创建的设备文件名
flags: 通常取DEVFS_FL_DEFAULT
major: 主设备号
minor: 次设备号
mode: 此设备文件的读写权限
ops: 此设备的file_operations结构
info: 

#define DEV_ID        ((void*)123456)
#define DEV_NAME    "XXXXXXXXXXXXXX"
#define DEV_MAJOR    200
#define DEV_IRQ        IRQ_XXXX
#define DEV_IRQ_MODE    SA_SHIRQ

...

    //regist char device
  #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
    ret = register_chrdev(DEV_MAJOR, DEV_NAME, &fops);
  #else
    cdev_init(&dev_char, &fops);
    dev_char.owner = THIS_MODULE;
    dev_char.ops = &fops;
    ret = cdev_add(&dev_char, MKDEV(DEV_MAJOR, 0), 1);
  #endif
    if (ret < 0)
        goto __mod_init_err1;
    //make devfs
  #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
    devfs_handle = devfs_register(NULL, DEV_NAME, DEVFS_FL_DEFAULT,
                      DEV_MAJOR, 0, S_IFCHR | S_IRUSR | S_IWUSR, &fops, NULL);
    if (NULL == devfs_handle)
    {
        ret = -1;
        goto __mod_init_err2;
    }
  #else
    dev_class = class_create(THIS_MODULE, DEV_NAME);
    if(IS_ERR(dev_class))
    {
        ret = PTR_ERR(dev_class);
        goto __mod_init_err2;
    }
    class_device_create(dev_class, MKDEV(DEV_MAJOR, 0), NULL, DEV_NAME);
    ret = devfs_mk_cdev(MKDEV(DEV_MAJOR, 0), S_IFCHR | S_IRUGO | S_IWUSR, DEV_NAME);
    if(ret)
        goto __mod_init_err3;
  #endif

......

  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
  __mod_init_err3:
    class_device_destroy(dev_class, MKDEV(DEV_MAJOR, 0));
    class_destroy(dev_class);
  #endif   
  __mod_init_err2:
  #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
    unregister_chrdev(DEV_MAJOR, DEV_NAME);
  #else
    cdev_del(&dev_char);
  #endif
  __mod_init_err1:
    free_irq(DEV_IRQ, DEV_ID);
   
#endif//end of "ifndef INPUT_DEVICE"

__mod_init_err0:
    return ret;

void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset)

mmap操作: 将设备驱动里的一段内存映射到用户空间. 通过在current->mm中增加具有物理地址->虚拟地址映射关系的pmd, pte项来实现

mmap的设备驱动中的原型为
int (*mmap) (struct file *filp, struct vm_area_struct *vma);

.....
#elif defined(__arm__)
    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
    /* This is an IO map - tell maydump to skip this VMA */
    vma->vm_flags |= VM_IO;
#elif defined(__sh__)
.....

completion

DECLARE_COMPLETION(name)

定义并初始化一个completion

INIT_COMPLETION(struct completion c);

重新初始化一个completion, 主要是用在被唤醒的进程重新进入等待前的初始化

void init_completion(struct completion *c)

初始化一个completion

void wait_for_completion(struct completion *c)

进行一个不可打断的等待

void complete(struct completion *c)

唤醒一个等待的进程

void complete_call(struct completion *c)

唤醒所有等待的进程

void complete_and_exit(struct completion *c, long retval)

在内核线程A收到退出命令后,通知另一个内核线程B退出, 并等待B退出完成; B退出完成后调用complete通知A, 如果这种情况下用的是completion机制而A最后等待complete的时候调用的是这个函数,那么,A一收到B退出的通知就会结束整个线程

spin lock

spin lock是一个互斥设备, 只能有 2 个值:"上锁"和"解锁".

内核抢占(高优先级的进程抢占低优先级的进程)在持有spin lock期间被禁止

spinlock_t my_lock = SPIN_LOCK_UNLOCKED

编译时初始化

void spin_lock_init(spinlock_t *lock)

运行时初始化

void spin_lock(spinlock_t *lock)

void spin_lock_irqsave(spinlock_t *lock, unsigned long flags)

void spin_lock_irq(spinlock_t *lock)

void spin_lock_bh(spinlock_t *lock)

加锁

spin_lock_irqsave在获得锁之前在当前处理器禁止中断, 之前的中断状态会保存在flags里. 按说flags按值传递的, 如何保存irq状态呢? 因为spin_lock_irqsave不是函数而是宏. ^_^

spin_lock_irq如果可以确定没有其他地方禁止中断(因为对应的unlock函数会打开中断), 可以使用这个函数

spin_lock_bh在获取锁之前禁止软中断.

之所以需要引入irq/soft irq开关支持,是因为如果在线程内拥有锁, 这时候有中断进来, 而中断也要拥有锁才能工作, 就导致了死锁

void spin_unlock(spinlock_t *lock)

void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)

void spin_unlock_irq(spinlock_t *lock)

void spin_unlock_bh(spinlock_t *lock)

与加锁对应的个个版本的解锁

int spin_trylock(spinlock_t *lock)

int spin_trylock_bh(spinlock_t *lock)

非阻塞操作. 没有禁止中断的"try"版本

rwlock_t my_rwlock = RW_LOCK_UNLOCKED

rwlock_init(&my_rwlock)

void read_lock(rwlock_t *lock)

void read_lock_irqsave(rwlock_t *lock, unsigned long flags)

void read_lock_irq(rwlock_t *lock)

void read_lock_bh(rwlock_t *lock)

void read_unlock(rwlock_t *lock)

void read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)

void read_unlock_irq(rwlock_t *lock)

void read_unlock_bh(rwlock_t *lock)

void write_lock(rwlock_t *lock)

void write_lock_irqsave(rwlock_t *lock, unsigned long flags)

void write_lock_irq(rwlock_t *lock)

void write_lock_bh(rwlock_t *lock)

int write_trylock(rwlock_t *lock)

void write_unlock(rwlock_t *lock)

void write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)

void write_unlock_irq(rwlock_t *lock)

void write_unlock_bh(rwlock_t *lock)

读写锁版本的spin lock

用其他方式避免使用锁

环形缓冲

原子变量: atomic_t. 所有原子量操作必须使用如下函数

atomic_t v = ATOMIC_INIT(0): 声明并初始化atomic变量
void atomic_set(atomic_t *v, int i): 设置值
int atomic_read(atomic_t *v): 读值
void atomic_add(int i, atomic_t *v): 值加i
void atomic_sub(int i, atomic_t *v): 值减i
void atomic_inc(atomic_t *v): 值+1
void atomic_dec(atomic_t *v): 值-1
int atomic_inc_and_test(atomic_t *v): 值+1, 并测试值是否为0, 若为0返回真, 否则返回假
int atomic_dec_and_test(atomic_t *v): 值-1, 并测试值是否为0, 若为0返回真, 否则返回假
int atomic_sub_and_test(int i, atomic_t *v): 值-i, 并测试值是否为0, 若为0返回真, 否则返回假
int atomic_add_negative(int i, atomic_t *v): 值+i, 并测试值是否为负, 若为负返回真, 否则返回假
int atomic_add_return(int i, atomic_t *v): 值+i, 并返回值
int atomic_sub_return(int i, atomic_t *v): 值-i, 并返回值
int atomic_inc_return(atomic_t *v): 值+1, 并返回值
int atomic_dec_return(atomic_t *v): 值-1, 并返回值

位操作:

位操作依赖于体系结构. nr 参数(描述要操作哪个位)常常定义为 int, 也可能是 unsigned long; 要修改的地址常常是一个 unsigned long 指针, 但是几个体系使用 void * 代替.

void set_bit(nr, void *addr): 在 addr 指向的数据项中将第 nr 位设置为1
void clear_bit(nr, void *addr): 在 addr 指向的数据项中将第 nr 位设置为0
void change_bit(nr, void *addr): 对 addr 指向的数据项中的第 nr 位取反
test_bit(nr, void *addr): 返回 addr 指向的数据项中的第 nr 位
int test_and_set_bit(nr, void *addr): 在 addr 指向的数据项中将第 nr 位设置为1, 并返回设置前的值
int test_and_clear_bit(nr, void *addr): 在 addr 指向的数据项中将第 nr 位设置为0, 并返回设置前的值
int test_and_change_bit(nr, void *addr): 对 addr 指向的数据项中的第 nr 位取反, 并返回取反前的值
Mark: 大部分现代代码不使用位操作,而是使用自选锁

阻塞 I/O

运行在原子上下文时不能睡眠. 持有一个自旋锁, seqlock, RCU 锁或中断已关闭时不能睡眠. 但在持有一个旗标时睡眠是合法的

不能对醒后的系统状态做任何的假设, 并且必须检查来确保你在等待的条件已经满足

确保有其他进程会做唤醒动作

明确的非阻塞 I/O 由 filp->f_flags 中的 O_NONBLOCK/O_NDELAY 标志来指示. 只有 read, write, 和 open 文件操作受到非阻塞标志影响

下列情况下应该实现阻塞

DECLARE_WAIT_QUEUE_HEAD(name);

定义并初始化一个等待队列

init_waitqueue_head(wait_queue_head_t *name);

wait_event(queue, condition)
wait_event_interruptible(queue, condition)
wait_event_timeout(queue, condition, timeout)
wait_event_interruptible_timeout(queue, condition, timeout)

void wake_up(wait_queue_head_t *queue);
void wake_up_interruptible(wait_queue_head_t *queue);

6.2.5.1. 一个进程如何睡眠
放弃处理器是最后一步, 但是要首先做一件事: 你必须先检查你在睡眠的条件. 做这个检查失败会引入一个竞争条件; 如果在你忙于上面的这个过程并且有其他的线程刚刚试图唤醒你, 如果这个条件变为真会发生什么? 你可能错过唤醒并且睡眠超过你预想的时间. 因此, 在睡眠的代码下面, 典型地你会见到下面的代码:
if (!condition)
    schedule();
通过在设置了进程状态后检查我们的条件, 我们涵盖了所有的可能的事件进展. 如果我们在等待的条件已经在设置进程状态之前到来, 我们在这个检查中注意到并且不真正地睡眠. 如果之后发生了唤醒, 进程被置为可运行的不管是否我们已真正进入睡眠.

如果在if判断之后,schedule之前,有其他进程试图唤醒当前进程, 那么当前进程就会被置为可运行的(但可能会到下次调度才会再次运行), 所以这个过程是安全的

Low memory: 因为所有可用的内存最初都是被映射到内核空间再进行分配的, 而内核空间的大小有限(通常被配置为1G), 所以实际能够利用的内存大小也是有限的, 这部分内存就是low memory. 内核的很多数据结构都必须放在low memory中
High memory: 由于low memory大小有限, 在配置了大量内存的主机里, 大于low memory部分的空间只能通过明确的虚拟映射映射进来. 这部分大于low memory部分的内存就叫High memory. High memory没有逻辑地址. 打开内核的High memory支持会导致性能下降

User virtual addresses: 用户(进程)虚拟地址. 这是被用户程序见到的常规地址. 用户地址在长度上是 32 位或者 64 位, 依赖底层的硬件结构. 每个进程有它自己的虚拟地址空间.
Physical addresses: 物理地址. 在处理器和系统内存之间使用的地址. 物理地址是3或者64位的量. 32位系统在某些情况下可使用更大的物理地址.
Bus addresses: 总线地址. 在外设和内存之间使用的地址. 通常, 它们和处理器使用的物理地址相同; 但一些体系可提供一个I/O内存管理单元(IOMMU), 它在总线和主内存之间重映射地址. 一个IOMMU可用多种方法使事情简单(例如, 使散布在内存中的缓冲对设备看来是连续的)
Kernel logical addresses: 内核逻辑地址. 这些组成了正常的内核地址空间. 这些地址映射了部分(也许全部)主存并且常常被当作物理内存来对待.
在大部分的体系上, 逻辑地址和它们的相关物理地址只差一个常量偏移. 逻辑地址使用硬件的本地指针大小, 因此, 可能不能在配置大量内存(大于4G)的32位系统上寻址所有的物理内存.
逻辑地址常常存储于unsigned long或者void *类型的变量中.
从 kmalloc 返回的内存有内核逻辑地址.
Kernel virtual addresses: 内核虚拟地址. 类似于逻辑地址, 它们都是从内核空间地址到物理地址的映射. 内核虚拟地址不必有逻辑地址空间具备的线性的, 一对一到物理地址的映射
所有的逻辑地址都是内核虚拟地址, 但是许多内核虚拟地址不是逻辑地址.
例如, vmalloc分配的内存有虚拟地址(但没有直接物理映射). kmap 函数也返回虚拟地址.
虚拟地址常常存储于指针变量.

内存相关的数据结构:

从物理系统供给内存的角度看, 各个数据结构总体关系如下:

一个线性的存储区被称为节点(node)
typedef struct pglist_data {
    zone_t node_zones[MAX_NR_ZONES];            该节点的zone类型，一般包括ZONE_HIGHMEM、ZONE_NORMAL和ZONE_DMA三类
    zonelist_t node_zonelists[GFP_ZONEMASK+1]; 分配时内存时zone的排序。由free_area_init_core()通过page_alloc.c::build_zonelists()设置zone的顺序
    int nr_zones;                                             该节点的zone个数, 可以从1 到3(即上面的ZONE_HIGHMEM、ZONE_NORMAL和ZONE_DMA)，但不是所有的节点都需要有3个zone
    struct page *node_mem_map;                      当前节点的struct page数组, 可能为全局mem_map中的某个位置
    unsigned long *valid_addr_bitmap;                 节点内存空洞的位图
    struct bootmem_data *bdata;
    unsigned long node_start_paddr;                    该节点的起始物理地址
    unsigned long node_start_mapnr;                   全局mem_map中的页偏移
    unsigned long node_size;                              该zone内的页框总数
    int node_id;                                                该节点的ID, 全系统节点ID从0开始. 系统中所有节点都维护在pgdat_list列表中
    struct pglist_data *node_next;
}pg_data_t;
节点中的内存被分为多块(通常为DMA memory, low memory, high memory), 这样的块被称为zone.
通常有这样的划分: ZONE_DMA: 0 -- 16MB；ZONE_NORMAL: 16MB - 896MB；ZONE_HIGHMEM: 896MB --
typedef struct zone_struct {
    /*Commonly accessed fields*/
    spinlock_t             lock;                               操作此结构时需要得到的自旋锁
    unsigned long        free_pages;                      剩余的空闲页总数
    unsigned long        pages_min, pages_low, pages_high;   zone中空闲页的阀值, 详细见下
    int            need_balance;                             告诉kswapd需要对该zone的页进行交换
    /** free areas of different sizes*/
    free_area_t free_area[MAX_ORDER];               根据连续页大小分组的空闲页链表组, 连续页大小分为 2^0, 2^1, 2^2, ... 2^MAX_ORDER个连续页
    /** Discontig memory support fields.*/
    struct pglist_data    *zone_pgdat;                 父管理结构, 见上
    struct page        *zone_mem_map;                当前zone的mem_map, 即全局mem_map中该zone所引用的第一页位置
    unsigned long        zone_start_paddr;             zone开始的物理地址(包括此地址)
    unsigned long        zone_start_mapnr;            在 全局mem_map 中的索引（或下标）
    /** rarely used fields:*/
    char            *name;                                   zone名字, “DMA”，“Normal”或“HighMem”
    unsigned long        size;                               zone的大小, 以页为单位
} zone_t;

当free_pages达到pages_min时，buddy分配器将采用同步方式进行kswapd的工作;
当free_pages达到pages_low时，kswapd被buddy分配器唤醒，开始释放页;
当free_pages达到pages_high时，kswapd将被唤醒，此时kswapd不会考虑如何平衡该zone，直到有pages_high空闲页为止。

typedef struct page {
    struct list_head list;                                    通过此结构挂到空闲队列/干净缓冲队列/脏缓冲队列等
    struct address_space *mapping;                    /* The inode (or ...) we belong to. */
    unsigned long index;                                    PFN, page frame number, 在页索引数组中的index
    struct page *next_hash;                              指向页高速缓存哈希表中下一个共享的页
    atomic_t count;                                         页引用计数
    unsigned long flags;                                    一套描述页状态的一套位标志. 这些包括 PG_locked, 它指示该页在内存中已被加锁, 以及 PG_reserved, 它防止内存管理系统使用该页.
    struct list_head lru;                                    /* Pageout list, eg. active_list; protected by pagemap_lru_lock !! */
    wait_queue_head_t wait;                            等待这一页的页队列
    struct page **pprev_hash;                         与next_hash相对应
    struct buffer_head * buffers;                       把缓冲区映射到一个磁盘块
    void *virtual;                                            被映射成的虚拟地址(Kernel virtual address, NULL if not kmapped, ie. highmem)
    struct zone_struct *zone;                           属于哪个管理区, 其结构见上
} mem_map_t;

从系统对内存的需求的角度来看, 又有如下结构
struct vm_area_struct {
    struct mm_struct * vm_mm;    指向父mm(用户进程mm)
    unsigned long vm_start;        当前area开始的地址
    unsigned long vm_end;        当前area结束的地址
    struct vm_area_struct *vm_next; 指向同一个mm中的下一个area
    pgprot_t vm_page_prot;        当前area的存取权限
    unsigned long vm_flags;        描述这个区的一套标志. 详细见下
    rb_node_t vm_rb;        
    struct vm_area_struct *vm_next_share;
    struct vm_area_struct **vm_pprev_share;
    struct vm_operations_struct * vm_ops;    一套内核可用来操作此区间的函数, 详细见mmap
    unsigned long vm_pgoff;        若与文件关联, 则为在文件中的偏移, 以PAGE_SIZE为单位
    struct file * vm_file;        如果当前area与一个文件关联, 则指向文件的struct file结构
    unsigned long vm_raend;   
    void * vm_private_data;
};

vm_flags: 对驱动编写者最感兴趣的标志是 VM_IO 和 VM_RESERVUED.

VM_IO 标志一个VMA作为内存映射的I/O区. VM_IO 标志阻止这个区被包含在进程核转储中.
VM_RESERVED 告知内存管理系统不要试图交换出这个VMA; 它应当在大部分设备映射中设置.

物理地址与页的关系:

页大小: PAGE_SIZE
物理地址(PA)-->页帧号(PFN, 此页在页索引数组中的index): PA右移PAGE_SHIFT位得到PFN
struct page *virt_to_page(void *kaddr);

内核逻辑地址转换成struct page指针. 注意: 需要一个逻辑地址, 不能使用来自vmalloc的内存或者high memory

struct page *pfn_to_page(int pfn);

页帧号(PFN, page frame number)转换成struct page指针

void *page_address(struct page *page);

返回这个页的内核虚拟地址, 如果这样一个地址存在.
对于高内存, 那个地址仅当这个页已被映射才存在. 大部分情况下, 使用 kmap 的一个版本而不是 page_address.

#include <linux/highmem.h>
void *kmap(struct page *page);
void kunmap(struct page *page);

kmap为系统中的任何页返回一个内核虚拟地址.
对于低内存页, 它只返回页的逻辑地址;
对于高内存, kmap 在内核地址空间的一个专用部分中创建一个特殊的映射.
使用 kmap 创建的映射应当一直使用 kunmap 来释放. 映射的总数是有限的, 所以不再使用时需要及时unmap
kmap 调用维护一个计数器, 因此如果 2 个或 多个函数都在同一个页上调用 kmap, 操作也是正常的
注意: 当没有映射可用时, kmap可能睡眠.

#include <linux/highmem.h>
#include <asm/kmap_types.h>
void *kmap_atomic(struct page *page, enum km_type type);
void kunmap_atomic(void *addr, enum km_type type);

kmap_atomic 是kmap 的一种高性能形式. 每个体系都给原子的kmaps维护一个槽(专用的页表项); kmap_atomic的调用者必须在type参数中指定哪个槽. 对驱动有意义的唯一插口是 KM_USER0和KM_USER1(对于直接从来自用户空间的调用运行的代码), 以及KM_IRQ0和KM_IRQ1(对于中断处理).
注意带atomic的kmaps必须是原子的

参考书目: