linux之块设备驱动

    Linux操作系统有两类主要的设备文件：

1.字符设备：以字节为单位进行顺序I/O操作的设备，无需缓冲区且被直接读写。

2.块设备：只能以块单位接收输入返回，对于I/O请求有对应的缓冲区，可以随机访问，块设备的访问位置必须能够在介质的不同区间前后移动。在块设备中，最小的可寻址单元是扇区，扇区的大小一般是2的整数倍，常见的大小为512个字节。

   上图是一个块设备操作的分层实现图

1.当一个进程被Read时，内核会通过VFS层去读取要读的文件块有没有被cache了，这个cache由一个buffer_head结构读取。如果要读取的文件块还没有被cache，则就要从文件系统中去读取，通过一个address_space结构来引用，如果调用文件系统读取函数去读取一个扇区的数据。当它从磁盘读出数据时，将数据页连入到cache中，当下一次在读取时，就不需要从磁盘去读取了。Read完后将请求初始化成一个bio结构，并提交给通用块层。

2.它通过submit_bio()去完成，通用层在调用相应的设备IO调度器，这个调度器的调度算法，将这个bio合并到已经存在的request中，或者创建一个新的request，并将创建的插入到请求队列中，最后就剩下块设备驱动层来完成后面的所有工作。

内核中块得I/O操作的是由bio结构表示的

struct bio {
    sector_t        bi_sector;    /*该BIO结构所要传输的第一个(512字节)扇区*/
    struct bio        *bi_next;    /*请求链表*/
    struct block_device    *bi_bdev;/*相关的块设备*/
    unsigned long        bi_flags;    /*状态和命令的标志*/
    unsigned long        bi_rw;        /*读写*/

    unsigned short        bi_vcnt;    /* bio_vec的偏移个数 */
    unsigned short        bi_idx;        /* bvl_vec */

    unsigned short        bi_phys_segments;

    /* Number of segments after physical and DMA remapping
     * hardware coalescing is performed.
     */
    unsigned short        bi_hw_segments;

    unsigned int        bi_size;    /* residual I/O count */

    /*
     * To keep track of the max hw size, we account for the
     * sizes of the first and last virtually mergeable segments
     * in this bio
     */
    unsigned int        bi_hw_front_size;
    unsigned int        bi_hw_back_size;

    unsigned int        bi_max_vecs;    /* max bvl_vecs we can hold */

    struct bio_vec        *bi_io_vec;    /* the actual vec list */

    bio_end_io_t        *bi_end_io;
    atomic_t        bi_cnt;        /* pin count */

    void            *bi_private;

    bio_destructor_t    *bi_destructor;    /* destructor */
};

此结构体的目的主要是正在执行的I/O操作，其中的bi_io_vecs、bi_vcnt、bi_idx三者都可以相互找到。bio_vec描述一个特定的片段，片段所在的物理页，块在物理页中的偏移页，整个bio_io_vec结构表示一个完整的缓冲区。

struct bio_vec {
    struct page    *bv_page;
    unsigned int    bv_len;
    unsigned int    bv_offset;
};

当一个块被调用内存时，要储存在一个缓冲区，每个缓冲区与一个块对应，所以每一个缓冲区独有一个对应的描述符，该描述符用buffer_head结构表示

struct buffer_head {
    unsigned long b_state;        /* buffer state bitmap (see above) */
    struct buffer_head *b_this_page;/* circular list of page's buffers */
    struct page *b_page;        /* the page this bh is mapped to */

    sector_t b_blocknr;        /* start block number */
    size_t b_size;            /* size of mapping */
    char *b_data;            /* pointer to data within the page */

    struct block_device *b_bdev;
    bh_end_io_t *b_end_io;        /* I/O completion */
     void *b_private;        /* reserved for b_end_io */
    struct list_head b_assoc_buffers; /* associated with another mapping */
    struct address_space *b_assoc_map;    /* mapping this buffer is
                           associated with */
    atomic_t b_count;        /* users using this buffer_head */
};

下面来看看块设备的核心ll_rw_block函数

void ll_rw_block(int rw, int nr, struct buffer_head *bhs[])
{
    int i;

    for (i = 0; i < nr; i  ) {
        struct buffer_head *bh = bhs[i];

        if (!trylock_buffer(bh))
            continue;
        if (rw == WRITE) {
            if (test_clear_buffer_dirty(bh)) {
                bh->b_end_io = end_buffer_write_sync;
                get_bh(bh);
                submit_bh(WRITE, bh);
                continue;
            }
        } else {
            if (!buffer_uptodate(bh)) {
                bh->b_end_io = end_buffer_read_sync;
                get_bh(bh);
                submit_bh(rw, bh);
                continue;
            }
        }
        unlock_buffer(bh);
    }
}

请求块设备驱动将多个物理块读出或者写到块设备，块设备的读写都是在块缓冲区中进行。

int submit_bh(int rw, struct buffer_head * bh)
{
    struct bio *bio;
    int ret = 0;

    BUG_ON(!buffer_locked(bh));
    BUG_ON(!buffer_mapped(bh));
    BUG_ON(!bh->b_end_io);
    BUG_ON(buffer_delay(bh));
    BUG_ON(buffer_unwritten(bh));

    /*
     * Only clear out a write error when rewriting
     */
    if (test_set_buffer_req(bh) && (rw & WRITE))
        clear_buffer_write_io_error(bh);

    /*
     * from here on down, it's all bio -- do the initial mapping,
     * submit_bio -> generic_make_request may further map this bio around
     */
    bio = bio_alloc(GFP_NOIO, 1);

    bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
    bio->bi_bdev = bh->b_bdev;
    bio->bi_io_vec[0].bv_page = bh->b_page;
    bio->bi_io_vec[0].bv_len = bh->b_size;
    bio->bi_io_vec[0].bv_offset = bh_offset(bh);

    bio->bi_vcnt = 1;
    bio->bi_idx = 0;
    bio->bi_size = bh->b_size;

    bio->bi_end_io = end_bio_bh_io_sync;
    bio->bi_private = bh;

    bio_get(bio);
    submit_bio(rw, bio);

    if (bio_flagged(bio, BIO_EOPNOTSUPP))
        ret = -EOPNOTSUPP;

    bio_put(bio);
    return ret;

这个函数主要是调用submit_bio，最终调用generic_make_request去完成将bio传递给驱动去处理。

void generic_make_request(struct bio *bio)
{
    struct bio_list bio_list_on_stack;

    if (!generic_make_request_checks(bio))
        return;


    if (current->bio_list) {
        bio_list_add(current->bio_list, bio);
        return;
    }

    BUG_ON(bio->bi_next);
    bio_list_init(&bio_list_on_stack);
    current->bio_list = &bio_list_on_stack;
    do {
        struct request_queue *q = bdev_get_queue(bio->bi_bdev);

        q->make_request_fn(q, bio);

        bio = bio_list_pop(current->bio_list);
    } while (bio);
    current->bio_list = NULL; /* deactivate */
}

这个函数主要是取出块设备相应的队列中的每个设备，在调用块设备驱动的make_request，如果没有指定make_request就调用内核默认的__make_request，这个函数主要作用就是调用I/O调度算法将bio合并，或插入到队列中合适的位置中去。

整个流程为：

那么request_fn指向那个函数呢？在内核中搜搜request_fn,发现

request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)
{
    return blk_init_queue_node(rfn, lock, -1);
}
EXPORT_SYMBOL(blk_init_queue);

request_queue_t *
blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)
{
    request_queue_t *q = blk_alloc_queue_node(GFP_KERNEL, node_id);

    if (!q)
        return NULL;

    q->node = node_id;
    if (blk_init_free_list(q)) {
        kmem_cache_free(requestq_cachep, q);
        return NULL;
    }


    if (!lock) {
        spin_lock_init(&q->__queue_lock);
        lock = &q->__queue_lock;
    }

    q->request_fn        = rfn;
    q->prep_rq_fn        = NULL;
    q->unplug_fn        = generic_unplug_device;
    q->queue_flags        = (1 << QUEUE_FLAG_CLUSTER);
    q->queue_lock        = lock;

    blk_queue_segment_boundary(q, 0xffffffff);

    blk_queue_make_request(q, __make_request);
    blk_queue_max_segment_size(q, MAX_SEGMENT_SIZE);

    blk_queue_max_hw_segments(q, MAX_HW_SEGMENTS);
    blk_queue_max_phys_segments(q, MAX_PHYS_SEGMENTS);

    q->sg_reserved_size = INT_MAX;

    /*
     * all done
     */
    if (!elevator_init(q, NULL)) {
        blk_queue_congestion_threshold(q);
        return q;
    }

    blk_put_queue(q);
    return NULL;
}

原来request_queue的make_request_fn指向__make_request()函数，这个函数复杂I/O调度，并对bio做些合并等。下面来看看__make_request()做了些什么？

由上面可以分析得出，其中有一个很重要的结构体

struct request {
    struct list_head queuelist;//连接这个请求到请求队列.
//追踪请求硬件完成的扇区的成员. 第一个尚未被传送的扇区被存储到 hard_sector, 已经传送的扇区总数在 ha//rd_nr_sectors, 并且在当前 bio 中剩余的扇区数是 hard_cur_sectors. 这些成员打算只用在块子系统; 驱动//不应当使用它们.
    struct request_queue *q;
    sector_t hard_sector;
    unsigned long hard_nr_sectors;
    unsigned int hard_cur_sectors;
    struct bio *bio;//bio 是给这个请求的 bio 结构的链表. 你不应当直接存取这个成员; 使用 rq_for_each_bio(后面描述) 代替.
    unsigned short nr_phys_segments;//被这个请求在物理内存中占用的独特段的数目, 在邻近页已被合并后
    char *buffer;//随着深入理解,可见到这个成员仅仅是在当前 bio 上调用 bio_data 的结果.
};

request_queue只是一个请求队列，通过可以找到requeue，然后通过bio结构体对应的page读取物理内存中的信息。

下面看看内核使用的块设备的例子

static int jsfd_init(void)
{
    static DEFINE_SPINLOCK(lock);
    struct jsflash *jsf;
    struct jsfd_part *jdp;
    int err;
    int i;

    if (jsf0.base == 0)
        return -ENXIO;

    err = -ENOMEM;
//1. 分配gendisk: alloc_disk
    for (i = 0; i < JSF_MAX; i++) {
        struct gendisk *disk = alloc_disk(1);
        if (!disk)
            goto out;
        jsfd_disk[i] = disk;
    }
//2. 设置,分配/设置队列: request_queue_t  // 它提供读写能力
    if (register_blkdev(JSFD_MAJOR, "jsfd")) {
        err = -EIO;
        goto out;
    }

    jsf_queue = blk_init_queue(jsfd_do_request, &lock);
    if (!jsf_queue) {
        err = -ENOMEM;
        unregister_blkdev(JSFD_MAJOR, "jsfd");
        goto out;
    }
//3. 设置gendisk其他信息             // 它提供属性: 比如容量
    for (i = 0; i < JSF_MAX; i++) {
        struct gendisk *disk = jsfd_disk[i];
        if ((i & JSF_PART_MASK) >= JSF_NPART) continue;
        jsf = &jsf0;    /* actually, &jsfv[i >> JSF_PART_BITS] */
        jdp = &jsf->dv[i&JSF_PART_MASK];

        disk->major = JSFD_MAJOR;
        disk->first_minor = i;
        sprintf(disk->disk_name, "jsfd%d", i);
        disk->fops = &jsfd_fops;
        set_capacity(disk, jdp->dsize >> 9);
        disk->private_data = jdp;
        disk->queue = jsf_queue;
//4 注册: add_disk
        add_disk(disk);
        set_disk_ro(disk, 1);
    }
    return 0;
out:
    while (i--)
        put_disk(jsfd_disk[i]);
    return err;
}