LDD3 第15章 内存映射和DMA

本章内容分为三个部分：

• 第一部分讲述了mmap系统调用的实现过程。将设备内存直接映射到用户进程的地址空间，尽管不是所有设备都需要，但是能显著的提高设备性能。
• 如何跨越边界直接访问用户空间的内存页，一些相关的驱动程序需要这种能力。在很多情况下，内核执行了该种映射，而无需驱动程序的参与。
• 直接内存访问（DMA）I/O操作，它使得外设具有直接访问系统内存的能力。

一、Linux的内存管理

关注Linux内存管理实现的主要特性，而非讲述操作系统中内存管理的理论。

1.1 地址类型

Linux是一个虚拟内存系统，意味着用户程序所使用的地址与硬件使用的物理地址是不同的。

虚拟内存是一个简介层，系统中运行的程序可以分配比物理内存更多的内存。甚至单独进程都拥有比系统物理内存更多的虚拟地址空间。

在任何情况下使用何种类型的地址，内核代码并未明确加以区分，因此程序对此要仔细处理。

• 用户虚拟地址：这是在用户空间程序所能看到的常规地址。用户地址或者32位的，或者是64位的
• 物理地址：该地址在处理器和系统内存之家使用。
• 总线地址：该地址在外围总线和内存之间使用。通常他们与处理器使用的物理地址相同，但这么做并不是必须的。一些计算机提供I/O内存管理（MMU），实现总线和主内存之间的重新映射。
• 但使用DMA时，MMU变成了一个额外的操作。
• 内核逻辑地址：内核逻辑地址组成了内核的常规地址空间。kmalloc返回的就是内核逻辑地址
• 内核虚拟地址：内核虚拟地址和内核逻辑地址，都将内核空间的地址映射到物理地址上。内核虚拟地址与物理地址的映射不是一一对应的。

如果有一个逻辑地址，宏__pa()（在<asm/page.h>中定义）返回其对应的物理地址，

使用宏__va()也能将物理地址逆向映射到逻辑地址，但这只对低端内存页有效。

1.2 物理地址和页

物理地址被分散成离散的单元，称之为页。系统对内存的操作都是基于单个页的。

每个页的大小随体系架构的不同而不同，大多数系统使用4095个字节。常量PAGE_SIZE（在<asm/page.h>中定义）给出了在任何指定体系架构下的大小。

1.3 高端与低端内存

大量的32位系统中，系统的寻址空间不能大于4GB。内核在（x86中）将4GB的虚拟地址空间分割成用户空间和内核空间。

典型的分配是1GB内核空间，3GB的用户空间。内核对任何内存的访问，都需要映射至虚拟地址空间内核部分的大小，再减去内核代码自身所占用的空间。

低端内存：在于内核空间上的逻辑地址内存。

高端内存：那些不存在逻辑地址的内存，它们处于内核虚拟地址之上。

1.4 内存映射和页结构

内核使用逻辑地址来引用物理内存中的页。支持高端内存后，在高端内存中无法使用逻辑地址。内核处理内存的函数趋向于使用指向page结构的指针（在<linux/mm.h>中）。

/*
 * Each physical page in the system has a struct page associated with
 * it to keep track of whatever it is we are using the page for at the
 * moment. Note that we have no way to track which tasks are using
 * a page, though if it is a pagecache page, rmap structures can tell us
 * who is mapping it.
 */
struct page {
    unsigned long flags;        /* Atomic flags, some possibly
                     * updated asynchronously */
    atomic_t _count;        /* Usage count, see below. */
    union {
        /*
         * Count of ptes mapped in
         * mms, to show when page is
         * mapped & limit reverse map
         * searches.
         *
         * Used also for tail pages
         * refcounting instead of
         * _count. Tail pages cannot
         * be mapped and keeping the
         * tail page _count zero at
         * all times guarantees
         * get_page_unless_zero() will
         * never succeed on tail
         * pages.
         */
        atomic_t _mapcount;

        struct {        /* SLUB */
            u16 inuse;
            u16 objects;
        };
    };
    union {
        struct {
        unsigned long private;      /* Mapping-private opaque data:
                         * usually used for buffer_heads
                         * if PagePrivate set; used for
                         * swp_entry_t if PageSwapCache;
                         * indicates order in the buddy
                         * system if PG_buddy is set.
                         */
        struct address_space *mapping;  /* If low bit clear, points to
                         * inode address_space, or NULL.
                         * If page mapped as anonymous
                         * memory, low bit is set, and
                         * it points to anon_vma object:
                         * see PAGE_MAPPING_ANON below.
                         */
        };
#if USE_SPLIT_PTLOCKS
        spinlock_t ptl;
#endif
        struct kmem_cache *slab;    /* SLUB: Pointer to slab */
        struct page *first_page;    /* Compound tail pages */
    };
    union {
        pgoff_t index;      /* Our offset within mapping. */
        void *freelist;     /* SLUB: freelist req. slab lock */
    };
    struct list_head lru;       /* Pageout list, eg. active_list
                     * protected by zone->lru_lock !
                     */
    /*
     * On machines where all RAM is mapped into kernel address space,
     * we can simply calculate the virtual address. On machines with
     * highmem some memory is mapped into kernel virtual memory
     * dynamically, so we need a place to store that address.
     * Note that this field could be 16 bits on x86 ... ;)
     *
     * Architectures with slow multiplication can define
     * WANT_PAGE_VIRTUAL in asm/page.h
     */
#if defined(WANT_PAGE_VIRTUAL)
    void *virtual;          /* Kernel virtual address (NULL if
                       not kmapped, ie. highmem) */
#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
};

struct page

atomic_t count;　　　　对该页的访问计数，当计数值为0时，该页将返回给空闲链表

void *virtual;　　　　　　如果页面被映射，指向内核虚拟地址。未被映射则是NULL

unsigned long flags;　　描述页状态的一系列标志。PG_locked表示内存中的页已经被锁住，而PG_reserved表示禁止内存管理系统访问该页

有一些函数和宏用来在page结构指针与虚拟地址之间进行转换。

struct page *virt_to_page(void *kaddr);
在<asm/page.h>中定义，负责将内核逻辑地址转换为相应的page结构体指针。
犹豫需要一个逻辑地址，因此不能操作vmalloc生成的地址以及高端内存。
struct page *pfn_to_page(int pfn);
针对给定的页帧号，返回page结构指针。使用pfn_valid确认页帧号的合理性
void *page_address(struct page *page);
如果地址存在的话，返回页的内核虚拟地址。对于高端内存来说，只有当内存页被映射后该地址才存在。
该函数定义在<linux/mm.h>中。大多数情况下，使用kmap而不是page_address

kmap相关的函数：

#include <linux/highmem.h>
void *kmap(struct page *page);
void kunmap(struct page *page);
kmap为系统中的页返回内核虚拟地址。对于低端内存页来说，它只返回页的逻辑地址；
对于高端内存，kmap在抓弄的内核地址空间创建特殊的映射。
kmap的映射数量是有限的，不能映射过长的时间。

kmap_atomic相关函数：

#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的高性能版本，以原子的处理
type参数：对驱动程序有意义的只有KM_USER0和KM_USER1。（KM_IRQ0和KM_IRQ1中断）

1.5 页表

处理器必须使用某种机制，将虚拟地址转换为相应的物理地址，这种机制被称为页表。

1.6 虚拟内存区

用于管理进程地址空间中不同区域的内核数据结构。

进程内存映射（至少）包含下面这些区域：

• 程序的可执行代码（通常称为text）区域
• 多个数据区，其中包含初始化数据、非初始化数据（BSS）以及程序堆栈。
• 与每个活动的内存映射对应的区域

查看/proc/<pid>/maps （其中pid要替换为具体的进程ID）文件就能了解进程的内存区域

/proc/self 是一个特殊的文件，始终指向当前进程。

cat /proc/<pid>/maps的结果与vm_area_struct结构中的一个成员相对应。

start
end        该内存区域的起始处和结束处的虚拟地址
perm        内存区域的读、写和执行权限的位掩码。
offset        表示内存区域在映射文件中的起始位置。
major
minor        拥有映射文件的设备的主设备号和次设备号
inode        被映射文件的索引节点号
image        被映射额文件（通常是一个可执行映象）的名称

1.7 vm_area_struct结构

vma的主要成员如下所示，在头文件<linux/mm.h>中定义：

/*
 * This struct defines a memory VMM memory area. There is one of these
 * per VM-area/task.  A VM area is any part of the process virtual memory
 * space that has a special rule for the page-fault handlers (ie a shared
 * library, the executable area etc).
 */
struct vm_area_struct {
    struct mm_struct * vm_mm;   /* The address space we belong to. */
    unsigned long vm_start;     /* Our start address within vm_mm. */
    unsigned long vm_end;       /* The first byte after our end address
                       within vm_mm. */

    /* linked list of VM areas per task, sorted by address */
    struct vm_area_struct *vm_next, *vm_prev;

    pgprot_t vm_page_prot;      /* Access permissions of this VMA. */
    unsigned long vm_flags;     /* Flags, see mm.h. */

    struct rb_node vm_rb;

    /*
     * For areas with an address space and backing store,
     * linkage into the address_space->i_mmap prio tree, or
     * linkage to the list of like vmas hanging off its node, or
     * linkage of vma in the address_space->i_mmap_nonlinear list.
     */
    union {
        struct {
            struct list_head list;
            void *parent;   /* aligns with prio_tree_node parent */
            struct vm_area_struct *head;
        } vm_set;

        struct raw_prio_tree_node prio_tree_node;
    } shared;

    /*
     * A file's MAP_PRIVATE vma can be in both i_mmap tree and anon_vma
     * list, after a COW of one of the file pages.  A MAP_SHARED vma
     * can only be in the i_mmap tree.  An anonymous MAP_PRIVATE, stack
     * or brk vma (with NULL file) can only be in an anon_vma list.
     */
    struct list_head anon_vma_chain; /* Serialized by mmap_sem &
                      * page_table_lock */
    struct anon_vma *anon_vma;  /* Serialized by page_table_lock */

    /* Function pointers to deal with this struct. */
    const struct vm_operations_struct *vm_ops;

    /* Information about our backing store: */
    unsigned long vm_pgoff;     /* Offset (within vm_file) in PAGE_SIZE
                       units, *not* PAGE_CACHE_SIZE */
    struct file * vm_file;      /* File we map to (can be NULL). */
    void * vm_private_data;     /* was vm_pte (shared mem) */

#ifndef CONFIG_MMU
    struct vm_region *vm_region;    /* NOMMU mapping region */
#endif
#ifdef CONFIG_NUMA
    struct mempolicy *vm_policy;    /* NUMA policy for the VMA */
#endif
};

vm_area_struct

unsigned long vm_start;

unsigned long vm_end;　　　　　　该VMA所覆盖的虚拟地址范围。这是/proc/*/maps中最前面的两个成员

struct file *vm_file;　　　　　　　　指向与该区域（如果存在的话）相关联的file结构指针

unsigned long vm_pgoff;　　　　　　以页为单位，文件中该区域的偏移量。当映射一个文件或者设备时，它是该区域中被映射的第一页在文件中的位置

unsigned long vm_flags;　　　　　　描述该区域的一套标志。驱动程序相关的是VM_IO和VM_RESERVED

struct vm_operations_struct *vm_ops;　　内核能调用的一套函数，用来对该内存区进行操作。

void *vm_private_data;　　　　　　　驱动程序用来保存自身信息的成员

/*
 * These are the virtual MM functions - opening of an area, closing and
 * unmapping it (needed to keep files on disk up-to-date etc), pointer
 * to the functions called when a no-page or a wp-page exception occurs.
 */
struct vm_operations_struct {
    void (*open)(struct vm_area_struct * area);
    void (*close)(struct vm_area_struct * area);
    int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);

    /* notification that a previously read-only page is about to become
     * writable, if an error is returned it will cause a SIGBUS */
    int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);

    /* called by access_process_vm when get_user_pages() fails, typically
     * for use by special VMAs that can switch between memory and hardware
     */
    int (*access)(struct vm_area_struct *vma, unsigned long addr,
              void *buf, int len, int write);
#ifdef CONFIG_NUMA
    /*
     * set_policy() op must add a reference to any non-NULL @new mempolicy
     * to hold the policy upon return.  Caller should pass NULL @new to
     * remove a policy and fall back to surrounding context--i.e. do not
     * install a MPOL_DEFAULT policy, nor the task or system default
     * mempolicy.
     */
    int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);

    /*
     * get_policy() op must add reference [mpol_get()] to any policy at
     * (vma,addr) marked as MPOL_SHARED.  The shared policy infrastructure
     * in mm/mempolicy.c will do this automatically.
     * get_policy() must NOT add a ref if the policy at (vma,addr) is not
     * marked as MPOL_SHARED. vma policies are protected by the mmap_sem.
     * If no [shared/vma] mempolicy exists at the addr, get_policy() op
     * must return NULL--i.e., do not "fallback" to task or system default
     * policy.
     */
    struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
                    unsigned long addr);
    int (*migrate)(struct vm_area_struct *vma, const nodemask_t *from,
        const nodemask_t *to, unsigned long flags);
#endif
};

vm_operations_struct

1.8 内存映射处理

每个进程都拥有一个struct mm_struct 结构（在<linux/sched.h>中定义） ，其中包括虚拟内存区域链表、页表以及其他大量内存管理信息。

还包括信号灯（mmap_sem）和一个自旋锁（page_table_lock）。多数驱动要访问时，使用current->mm

二、mmap设备操作

mmap方法是file_operations结构的一部分，并且执行mmap系统调用时将调用该方法。

这个方法和系统调用的mmap有很大的不同，原型如下：

mmap(caddr_t addr, size_t len, int port, int flags, int fd, off_t offset);

int (*mmap)(struct file *filp, struct vm_area_struct *vma);
vma包含了用于访问设备的虚拟地址的信息

有两种建立页表的方法：

• 使用remap_pfn_range函数一次全部建立
• 通过nopage VMA方法每次建立一个页表

2.1 使用remap_pfn_range

int remap_pfn_range(struct vm_area_struct *vma,
    unsigned long virt_addr, unsigned long pfn,
    unsigned long size, pgprot_t port);
int io_remap_page_range(struct vm_area_struct *vma,
    unsigned long virt_addr, unsigned long phys_addr,
    unsigned long size, pgprot_t prot);
vma：虚拟内存区域，在一定范围内的页将被映射到该区域内
virt_addr：重新映射时的起始用户虚拟地址。
pfn：与物理内存对应的页帧号，虚拟内存将要被映射到该物理内存上。
size：以字节为单位，被重新映射的区域大小
prot：新VMA要求的保护属性

2.2 一个简单的实现

如果驱动程序要将设备内存线性地映射到用户地址空间中，程序员基本上就只需要调用remap_pfn_range函数。例子：

static int simple_remap_mmap(struct file *filp, struct vm_area_struct *vma)
{
    if(remap_pfn_range(vma, vma->vm_start, vm->vm_pgoff,
        vma->vm_end - vma->vm_start,
        vma->vm_page_prot))
        return -EAGAIN;

    vma->vm_ops = &simple_remap_vm_ops;
    simple_vma_open(vma);
    return ;
}

2.3 为VMA添加操作

vma_area_struct 包含了一系列针对VMA的操作，当fork进程或者创建一个新的对VMA引用时，随时都会调用open函数。

void simple_vma_open(struct vm_area_struct *vma)
{
    printk(KERN_NOTICE "Simple VMA open, virt %lx, phys %lx\n",
        vma->vm_start, vma->vm_pgoff << PAGE_SHIFT);
}

void simple_vma_close(struct vm_area_struct *vma)
{
    printk(KERN_NOTICE "Simple VMA close.\n");
}

static struct vm_operations_struct simple_remap_vm_ops = {
    .open = simple_vma_open,
    .close = simple_vma_close,
};

使用nopage映射内存

尽管remap_page_range在许多情况下工作良好，但是并不能适应大多数的情况。

如果VMA映射尺寸变小或变大时，使用nopage更适合，不需要做额外的操作。

struct page *(*nopage)(struct vm_area_struct *vma,
    unsigned long address, int *type);
当用户要访问VMA中的页，而该页又不再内存中时，将调用相关的nopage函数
address：包含了引起错误的虚拟地址，被向下圆整到页的开始位置。
nopage：函数必须定位并返回指向用户所需要页的page结构指针。

get_page(struct page *pageptr);
该函数调用get_page宏，用来增加返回的内存页的使用计数

如果使用了nopage，调用mmap的时候，通常只需做一点点工作。

static int simple_nopage_mmap(struct file *filp, struct vm_area_struct *vma)
{
    unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;

    if(offset >= __pa(high_memory) || (filp->f_flags & O_SYNC))
        vma->vm_flags |= VM_IO;
    vma->vm_flags |= VM_RESERVED;

    vma->vm_ops = &simple_nopage_vm_ops;
    simple_vma_open(vma);
    return ;
}

mmap函数将默认的vm_ops指针替换成自己的操作。然后nopage函数小心的每次重新映射一页，并且返回它的page结构指针。

重映射的步骤非常简单：需要的地址定位并返回page结构体的指针，例子如下：

struct page *simple_vma_nopage(struct vm_area_struct *vma,
    unsigned long address, int *type)
{
    struct page *pageptr;
    unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
    unsigned long physaddr = address - vma->vm_start + offset;
    unsigned long pageframe = physaddr >> PAGE_SHIFT;

    if(!pfn_valid(pageframe))
        return NOPAGE_SIGBUS;
    pageptr = pfn_to_page(pageframe);
    get_page(pageptr);
    if(type)
        *type = VM_FAULT_MINOR;
    return pageptr;
}

只是简单的映射了主内存，并增加了计数引用。需要的步骤是：

计算物理地址，然后通过右移PAGE_SHIFT位，将它转换成页帧号。

pfn_valid确保地址的合理性，超过范围返回NOPAGE_SIGBUS

重映射特定的I/O区域

所有例子都是对/dev/mem的再次实现，一个典型的驱动程序只映射与其外围设备相关的一小段地址，而不是映射全部地址。

下面代码揭示了驱动程序如何对起始于物理地址simple_region_start、大小为simple_region_size字节的区域进行映射的工作过程。

unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
unsigned long physical = simple_region_start + off;
unsigned long vsize = vma->vm_end - vma->vm_start;
unsigned long psize = simpel_region_size - off;

if(vsize > psize)
    return -EINVAL;    /* 跨度过大 */
remap_pfn_range(vma, vma->vm_start, physical, visze, vma->vm_page_prot);

为防止扩展映射最简单的办法是实现一个简单的nopage方法，它会产生一个总线信号传递给故障进程。

struct page *simple_nopage(struct vm_area_struct *vma,
    unsigned long address, int *type)
{    return NOPAGE_SIGBUS; /* 发送SIGBUS */ }

重新映射RAM

remap_pfn_range函数的一个限制是：它只能访问保留页和超出物理内存的物理地址。

在Linux中，在内存映射时，物理地址页被标记为“保留的，表示内存管理对其不起作用”。

使用nopage方法重映射RAM

struct page *scullp_vma_nopage(struct vm_area_struct *vma, unsigned long address, int *type)
{
    unsigned long offset;
    struct scull_dev *ptr, *dev = vma->vm_private_data;
    struct page *page = NOPAGE_SIGBUS;
    void *pageptr = NULL;       /* 默认值是没有 */

    down(&dev->sem);
    offset = (address - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
    if(offset >= dev->size) goto out;       /* 超出范围 */

    offset >= PAGE_SHIFT;               /* offset是页号 */
    for(ptr=dev;ptr && offset >= dev->qset;) {
        ptr = ptr->next;
        offset -= dev->qset;
    }
    if(ptr && ptr->data) pageptr = ptr->data[offset];
    if(!pageptr)    goto out;           /* 空白区或者文件末尾 */
    page = virt_to_page(pageptr);

    /* 获得该值，现在可以增加计数了 */
    get_page(page);
    if(type)
        *type = VM_FAULT_MINOR;

out:
    up(&dev->sem);
    return page;
}

scullp_vma_nopage

重新映射内核虚拟地址

page = vmalloc_to_page(pageptr);

get_page(page);
if(type)
    *type = VM_FAULT_MINOR;

out:
    up(&dev->sem);
    return page;

三、执行直接I/O访问

无论如何，在字符设别中执行直接I/O是不可行的，也是有害的。只有确定执行设置缓冲I/O的开销特别巨大，才使用直接I/O。请注意块设备和网络设备根本不用担心实现直接I/O的问题。

在这两种情况中，内核中高层代码设置和使用了直接I/O，而驱动程序级的代码升值不需要知道已经执行了直接I/O

2.6中实现直接I/O的关键是名为get_user_pages的函数，它定义在<linux/mm.h>中，原型如下：

int get_user_page(struct task_struct *tsk,
    struct mm_struct *mm,
    unsigned long start,
    int len,
    int write,
    int force,
    struct page **pages,
    struct vm_area_struct **vmas);

tsk：指向执行I/O的任务指针，主要目的是告诉内核，当设置缓冲区时，谁负责解决页错误的问题。
mm：知悉将描述被映射地址空间的内存你管理结构的指针。
start
len：start是用户空间缓冲区的地址，len是页内的缓冲区长度
write
force：如果write非零，对映射的页有写权限（意味着用户空间执行了读操作）
pages
vmas：输出参数。如果调用成功，pages中包含一个描述用户空间缓冲区page结构的指针列表，vmas包含了相应VMA的指针。

get_user_page

get_user_pages函数是一个底层内存管理函数，使用了比较复杂的接口。

它还需要在调用前，将mmap为获得地址空间的读取者/写入者信号量设置为读模式。因此有：

down_read(&cuurent->mm->mmap_sem);
result = get_user_pages(current, current->mm, ...);
up_read(&current->mm->mmap_sem);

result返回一个实际被调用的页数，它可能比请求的数量少，但大于0

1、调用成功后，就有了一个用户空间缓冲区的页数组，它将被锁在内存中。

2、为了能直接操作缓冲区，内核空间的代码必须用kmap或者kmap_atomic函数将每个page结构指针转换成内核虚拟地址。

3、使用直接I/O通常使用DMA操作，因此驱动程序要从page结构指针数组中创建一个分散/聚合链表。

4、一旦直接操作I/O完成，必须是释放用户内存页。如果改变了页的内容，必须通知内核，确保内核认为它是“干净”的

void SetPageDirty(struct page *page);

宏在头文件<linux/page-flags.h>中。使用例子如下：

if(!PageReserved(page))
    SetPageDirty(page);

不管页是否被改变，他们都必须从也缓存中释放，否则他们会永远存在那里，函数：

void page_cache_release(struct page *page);

异步I/O

2.6的新特性是异步I/O，异步I/O允许用户空间初始化操作，但不必等待它们完成，这样执行异步I/O时，应用程序可以进行其他的操作。

字符设备驱动吗程序需要清楚地表示需要异步I/O的支持。如果有恰当的理由需要在同一时刻执行多余一个的I/O操作，则字符设备将会从异步I/O中受益。

支持异步I/O的驱动程序应该包括<linux/aio.h>，有三个用于实现异步I/O的file_operations方法：

ssize_t (*aio_read)(struct kiocb *iocb, char *buffer,
    size_t count, loff_t offset);
ssize_t (*aio_write)(struct kiocb *iocb, const char *buffer,
    size_t count, loff_t offset);
int (*aio_fsync)(struct kiocb *iocb, int datasync);
aio_fsync操作只对文件系统有意义
aio_write与常用的read和write函数非常相似，也有一些不同。
其中一个不同是：offset参数是一个值，异步操作从不改变文件的位置，因此没有必要向它传递指针。

异步I/O

异步I/O的例子：

static ssize_t scullp_aio_read(struct kiocb *iocb, char *buf, size_t count,
    loff_t pos)
{
    return scullp_defer_op(, iocb, buf, count, pos);
}

static ssize_t scullp_aio_write(struct kiocb *iocb, const char *buf, size_t count, loff_t pos)
{
    return scullp_defer_op(, iocb, (char *)buf, count, pos);
}

struct async_work{
    struct kiocb *iocb;
    int result;
    struct work_struct work;
}

static int scullp_defer_op(int write, struct kiocb *iocb, char *buf,
    size_t count, loff_t pos)
{
    struct async_work *stuff;
    int result;
    /* 虽然可以访问缓冲区，但现在要进行拷贝操作 */
    if(write)
        result = scullp_write(iocb->ki_filp, buf, count, &pos);
    else
        result = scullp_read(iocb->ki_filp, buf, count, &pos);

    /* 如果这是一个同步的IOCB，则现在反悔状态值 */
    if(is_sync_kiocb(iocb))
        return result;

    /* 否则把完成操作向后推迟几毫秒 */
    stuff = kmalloc(sizeof(*stuff), GFP_KERNEL);
    if(stuff == NULL)
        return result;
    /* 没有可用内存了，使之完成 */
    stuff->iocb = iocb;
    stuff->result = result;
    INIT_WORK(&stuff->work, scullp_do_deferred_op, stuff);
    schedule_delayed_work(&stuff->work, HZ/);
    return -EIOCBQUEUED;
}

static void scullp_do_defered_op(void *p)
{
    struct async_work *stuff = (struct async_work *)p;
    aio_complete(stuff->iocb, stuff->result, );
    kfree(stuff);
}

异步I/O例子

四、直接访问内存

直接访问内存，或者DMA。是内存中的高级部分。

DMA数据传输概览

第一种情况中，所需要的步骤概括如下：

1.当进程调用read，驱动程序函数分配一个DMA缓冲区，并让硬件将数据传输到这个缓冲区中，进程处于睡眠状态

2.硬件将数据写入到DMA缓冲区中，当写入完毕，产生一个中断

3.中断处理程序获得输入的数据，应答中断，并且唤醒进程，该进程现在即可读取数据。

分配DMA缓冲区

使用DMA缓冲区的主要问题是：当大于一页时，他们必须占据连续的物理页，这是因为设备使用ISA或者PCI系统总线传输数据，而这两种方式使用的都是物理地址。

DIY分配

get_free_pages函数可以分配多达几M字节的内存，但是对较大数量的请求，甚至是远少于129KB的请求也通常会失败。

在引导时，我们可以通过内核传递"mem=参数"的办法保留顶部的RAM。比如系统有256MB内存，参数"mem=255M"将使内核不能使用顶部的1M字节。

dmabuf = ioremap(0xFF00000 /* 255M */, 0x100000 /* 1M */);

总线地址

使用DMA的设备驱动后曾虚将于连接到总线接口上的硬件通信，硬件使用的是物理地址，而程序代码使用的是虚拟地址。

不推荐使用这些函数，在<ams/io.h>中定义的函数：

unsigned long virt_to_bus(volatile void *address);
void *bus_to_virt(unsigned long address);

通用DMA层

DMA操作最终会分配缓冲区，并将总线地址传递给设备。一个可移植的驱动程序要求对所有体系架构都能安全而正确的执行DMA操作，编写这样一个驱动程序的难度超出了一般人的想象。

幸运的是内核提供了一个与总线-----体系架构无关的DMA层，他会隐藏大多数问题。强烈建议使用该层编写。

涉及到的device结构指针，需要包含文件<linux/dma-mapping.h>

处理复杂的硬件

在执行DMA之前，必须确定给定设备是否有能力执行该操作。

默认情况下，内核假设设备都能在32为地址上执行DMA。如果不是这样应该调用下面的函数通知内核：

int dma_set_mask(struct device *dev, u64 mask);

因此一个受限的24位DMA操作应该为：

if(dma_set_mask(dev, 0xffffff))
    card->use_dma = ;
else {
    card->use_dma = ;
    printk(KERN_WARN, "mydev: DMA not supported\n");
}

如何设备支持常见的23位DMA操作，则没有必要调用dma_set_mask。

DMA映射

一个DMA映射是 要分配的DMA缓冲区 与 为该缓冲区生成的、设备可访问地址的组合。

DMA映射必须解决缓存一致性的问题。如果设备改变了主内存找那个的区域，则任何覆盖该区域的处理器缓存都将无效。

否则处理器将使用不正确的主内存映射，从而产生不正确的数据。

DMA映射建立一个新的结构类型------dma_addr_t表示总线地址。

dma_addr_t类型的变量对驱动程序是不透明的，唯一允许的操作是将他们传递给DMA支持例程以及设备本身。

PCI代码区分两种类型的DMA映射：

1.一致性DMA映射

2.流式DM映射

建立一致性DMA映射

驱动程序可调用pci_alloc_consistent函数建立一致性映射：

void *dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, int flag);
前两个参数是device结构和所需缓冲区的大小
函数在两处返回DMA映射的结果。返回值是缓冲区的内核虚拟地址。
而与其相关的总线地址，返回时保存在dma_handle中
flag参数通常是描述如何分配内存的GFP_值，GFP_KERNEL或者GFP_ATOMIC

当不再需要缓冲区时，调用dma_free_coherent向系统返回缓冲区：

void dma_free_coherent(struct device *dev, size_t size, void *vaddr, dma_addr_t dma_handle);
和通用DMA函数一样，需要提供缓冲区大小、CPU地址、总线地址等参数

DMA池

DMA池是一个生成小型、一致性DMA映射的机制。调用dma_alloc_coherent函数获得最小单位为页的映射。

如果需要再小，就需要DMA池了。在头文件<linux/dmapool.h>中定义了DMA池的函数：

struct dma_pool *dma_pool_create(const char *name, struct device *dev, size_t size, size_t align, size_t allocation);
name：DMA的名字
dev：device结构
size：是从该池中分配的缓冲区的大小
align：是该池分配操作所必须遵守的硬件对齐原则
allocation：如果不为零，表示内存边界不能超越allocation

用完DMA池后，需要调用函数释放：

void dma_pool_destroy(struct dma_pool *pool);
销毁之前必须分返回所有分配的内存
void *dma_pool_alloc(struct dma_pool *pool, int mem_flags, dma_addr_t *handle);
mem_flags：通常设置为GFP_分配标志
返回的DMA地址是内核虚拟地址，并作为总线地址保存在handle中

使用下面函数返回不需要的缓冲区
void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);

建立流式DMA映射

只有一个缓冲区要被传输的时候，使用dma_map_single函数映射它：

dma_addr_t dma_map_single(struct device *dev, void *buffer, size_t size, enum dma_data_direction direction);
返回值是总线地址，可以把它传递给设备，如果执行错误，返回NULL

当传输完毕后，使用dma_unmap_signle(strcut device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction);
size和direction采纳数必须与映射缓冲区的参数像匹配

驱动程序需要不经过撤销映射就访问流式DMA缓冲区的内容，内核提供如下调用：

void dma_sync_signle_for_cpu(struct device *dev, dma_handle_t bus_addr,
    size_t size, enum dma_data_direction direction);

在设备访问缓冲区前，应该调用下面的函数将所有权交还给设备
void dma_sync_single_for_device(struct device *dev, dma_handle_t bus_addr,
    size_t size, enum dma_data_direction direction);
处理器在调用该函数后，不能再访问DMA缓冲区了

单页流式映射

dma_addr_t dma_map_page(struct device *dev, struct page *page,
    unsigned long offset, size_t size, enum dma_data_direction direction);

void dma_unmap_page(strcut device *dev, dma_addr_t dma_address,
    size_t size, enum dma_data_direction direction);

分散/聚集映射

映射分散表的第一步是建立并填充一个描述被传送缓冲区的scatterlist结构的数组。该结构在头文件<linux/scatterlist.h>中描述

struct page *page;　　与在scatter/gather操作中用到缓冲区响应的page结构指针

unsigned int length;

unsigned int offset;　　在页内缓冲区的长度和偏移量

PCI双重地址周期映射

一个简单的PCI DMA例子

ISA设备的DMA

注册DMA

与DMA控制器通信