Linux块设备驱动

一、块设备驱动之概念和框架

1.基本概念

块设备（blockdevice）

--- 是一种具有一定结构的随机存取设备，对这种设备的读写是按块进行的，他使用缓冲区来存放暂时的数据，待条件成熟后，从缓存一次性写入设备或者从设备一次性读到缓冲区。

字符设备（Character device）

---是一个顺序的数据流设备，对这种设备的读写是按字符进行的，而且这些字符是连续地形成一个数据流。他不具备缓冲区，所以对这种设备的读写是实时的。

 

扇区(Sectors)：任何块设备硬件对数据处理的基本单位。通常，1个扇区的大小为512byte。（对设备而言）

块  (Blocks)：由Linux制定对内核或文件系统等数据处理的基本单位。通常，1个块由1个或多个扇区组成。（对Linux操作系统而言）

段(Segments)：由若干个相邻的块组成。是Linux内存管理机制中一个内存页或者内存页的一部分。

页、段、块、扇区之间的关系图如下：

2.块设备驱动整体框架

 块设备的应用在Linux中是一个完整的子系统。

在Linux中，驱动对块设备的输入或输出(I/O)操作，都会向块设备发出一个请求，在驱动中用request结构体描述。但对于一些磁盘设备而言请求的速度很慢，这时候内核就提供一种队列的机制把这些I/O请求添加到队列中（即：请求队列），在驱动中用request_queue结构体描述。在向块设备提交这些请求前内核会先执行请求的合并和排序预操作，以提高访问的效率，然后再由内核中的I/O调度程序子系统来负责提交  I/O 请求，  调度程序将磁盘资源分配给系统中所有挂起的块 I/O  请求，其工作是管理块设备的请求队列，决定队列中的请求的排列顺序以及什么时候派发请求到设备。

由通用块层(Generic Block Layer)负责维持一个I/O请求在上层文件系统与底层物理磁盘之间的关系。在通用块层中，通常用一个bio结构体来对应一个I/O请求。

Linux提供了一个gendisk数据结构体，用来表示一个独立的磁盘设备或分区，用于对底层物理磁盘进行访问。在gendisk中有一个类似字符设备中file_operations的硬件操作结构指针，是block_device_operations结构体。

当多个请求提交给块设备时，执行效率依赖于请求的顺序。如果所有的请求是同一个方向（如：写数据），执行效率是最大的。内核在调用块设备驱动程序例程处理请求之前，先收集I/O请求并将请求排序，然后，将连续扇区操作的多个请求进行合并以提高执行效率（内核算法会自己做，不用你管），对I/O请求排序的算法称为电梯算法（elevator algorithm）。电梯算法在I/O调度层完成。内核提供了不同类型的电梯算法，电梯算法有

1 noop（实现简单的FIFO，基本的直接合并与排序）,
2 anticipatory（延迟I/O请求，进行临界区的优化排序），
3 Deadline（针对anticipatory缺点进行改善，降低延迟时间）,
4 Cfq（均匀分配I/O带宽，公平机制）

PS：其实IO调度层（包括请求合并排序算法）是不需要用户管的，内核已经做好

相关数据结构

block_device:      描述一个分区或整个磁盘对内核的一个块设备实例 
gendisk:               描述一个通用硬盘（generic hard disk）对象。
hd_struct:             描述分区应有的分区信息 
bio:                        描述块数据传送时怎样完成填充或读取块给driver
request:                描述向内核请求一个列表准备做队列处理。 
request_queue:  描述内核申请request资源建立请求链表并填写BIO形成队列。

二、块设备之相关结构体

1.块设备对象结构 block_device

内核用结构block_device实例代表一个块设备对象，如：整个硬盘或特定分区。如果该结构代表一个分区，则其成员bd_part指向设备的分区结构。如果该结构代表设备，则其成员bd_disk指向设备的通用硬盘结构gendisk

当用户打开块设备文件时，内核创建结构block_device实例，设备驱动程序还将创建结构gendisk实例，分配请求队列并注册结构block_device实例。

块设备对象结构block_device列出如下（在include/linux/fs.h中）

struct block_device {  
dev_t bd_dev;  /* not a kdev_t - it's a search key */  
struct inode * bd_inode; /* 分区节点 */  
struct super_block * bd_super;  
int bd_openers;  
struct mutex bd_mutex;/* open/close mutex 打开与关闭的互斥量*/  
struct semaphore bd_mount_sem;    /*挂载操作信号量*/   
struct list_head bd_inodes;  
void * bd_holder;  
int bd_holders;  
#ifdef CONFIG_SYSFS  
struct list_head bd_holder_list;  
#endif  
struct block_device * bd_contains;  
unsigned bd_block_size;     /*分区块大小*/  
struct hd_struct * bd_part;  
unsigned bd_part_count;   /*打开次数*/  
int bd_invalidated;  
struct gendisk * bd_disk; /*设备为硬盘时，指向通用硬盘结构*/  
struct list_head bd_list;  
struct backing_dev_info *bd_inode_backing_dev_info;  
unsigned long bd_private;  
/* The counter of freeze processes */  
int bd_fsfreeze_count;  
/* Mutex for freeze */  
struct mutex bd_fsfreeze_mutex;  
}; 

2.通用硬盘结构 gendisk

结构体gendisk代表了一个通用硬盘（generic hard disk）对象，它存储了一个硬盘的信息，包括请求队列、分区链表和块设备操作函数集等。块设备驱动程序分配结构gendisk实例，装载分区表，分配请求队列并填充结构的其他域。

支持分区的块驱动程序必须包含 <linux/genhd.h> 头文件，并声明一个结构gendisk，内核还维护该结构实例的一个全局链表gendisk_head，通过函数add_gendisk、del_gendisk和get_gendisk维护该链表。

结构gendisk列出如下（在include/linux/genhd.h中）：

struct gendisk {  
    int major;            /* 驱动程序的主设备号 */  
    int first_minor;       /*第一个次设备号*/  
    int minors;          /*次设备号的最大数量，没有分区的设备，此值为1 */  
    char disk_name[32];  /* 主设备号驱动程序的名字*/  
    struct hd_struct **part;   /* 分区列表，由次设备号排序 */  
    struct block_device_operations *fops;  /*块设备操作函数集*/  
    struct request_queue *queue;         /*请求队列*/  
    struct blk_scsi_cmd_filter cmd_filter;  
    void *private_data;                 /*私有数据*/  
    sector_t capacity;     /* 函数set_capacity设置的容量，以扇区为单位*/  
    int flags;                 /*设置驱动器状态的标志，如：可移动介质为 
GENHD_FL_REMOVABLE*/  
    struct device dev;                 /*从设备驱动模型基类结构device继承*/  
    struct kobject *holder_dir;  
    struct kobject *slave_dir;  
 struct timer_rand_state *random;  
    int policy;   
    atomic_t sync_io;        /* RAID */  
    unsigned long stamp;  
    int in_flight;  
#ifdef  CONFIG_SMP  
    struct disk_stats *dkstats;    
#else  
/*硬盘统计信息，如：读或写的扇区数、融合的扇区数、在请求队列的时间等*/  
    struct disk_stats dkstats;  
#endif  
    struct work_struct async_notify;  
#ifdef  CONFIG_BLK_DEV_INTEGRITY  
    struct blk_integrity *integrity;   /*用于数据完整性扩展*/  
#endif  
}; 

Linux内核提供了一组函数来操作gendisk，主要包括：
分配gendisk
struct gendisk *alloc_disk(int minors);
minors 参数是这个磁盘使用的次设备号的数量，一般也就是磁盘分区的数量，此后minors不能被修改。
增加gendisk
gendisk结构体被分配之后，系统还不能使用这个磁盘，需要调用如下函数来注册这个磁盘设备：
void add_disk(struct gendisk *gd);
特别要注意的是对add_disk()的调用必须发生在驱动程序的初始化工作完成并能响应磁盘的请求之后。

 释放gendisk
当不再需要一个磁盘时，应当使用如下函数释放gendisk：
void del_gendisk(struct gendisk *gd);

设置gendisk容量
void set_capacity(struct gendisk *disk, sector_t size);
块设备中最小的可寻址单元是扇区，扇区大小一般是2的整数倍，最常见的大小是512字节。扇区的大小是设备的物理属性，扇区是所有块设备的基本单元，块设备 无法对比它还小的单元进行寻址和操作，不过许多块设备能够一次就传输多个扇区。虽然大多数块设备的扇区大小都是512字节，不过其它大小的扇区也很常见， 比如，很多CD-ROM盘的扇区都是2K大小。不管物理设备的真实扇区大小是多少，内核与块设备驱动交互的扇区都以512字节为单位。因此，set_capacity()函数也以512字节为单位。

分区结构hd_struct代表了一个分区对象，它存储了一个硬盘的一个分区的信息，驱动程序初始化时，从硬盘的分区表中提取分区信息，存放在分区结构实例中。

3.块设备操作函数集结构 block_device_operations

字符设备通过 file_operations 操作结构使它们的操作对系统可用. 一个类似的结构用在块设备上是 struct block_device_operations,
定义在 <linux/fs.h>. 
int (*open)(struct inode *inode, struct file *filp); 
int (*release)(struct inode *inode, struct file *filp); 
就像它们的字符驱动对等体一样工作的函数; 无论何时设备被打开和关闭都调用它们. 一个字符驱动可能通过启动设备或者锁住门(为可移出的介质)来响应一个 open 调用. 如果你将介质锁入设备, 你当然应当在 release 方法中解锁.
int (*ioctl)(struct inode *inode, struct file *filp, 
                          unsigned int cmd, unsigned long arg); 
实现 ioctl 系统调用的方法. 但是, 块层首先解释大量的标准请求; 因此大部分的块驱动 ioctl 方法相当短.

PS：在block_device_operations中没有实际读或写数据的函数. 在块 I/O 子系统, 这些操作由请求函数处理

4.请求结构request

结构request代表了挂起的I/O请求，每个请求用一个结构request实例描述，存放在请求队列链表中，由电梯算法进行排序，每个请求包含1个或多个结构bio实例

struct request {  
    //用于挂在请求队列链表的节点，使用函数blkdev_dequeue_request访问它，而不能直接访  
问  
    struct list_head queuelist;   
    struct list_head donelist;  /*用于挂在已完成请求链表的节点*/  
    struct request_queue *q;   /*指向请求队列*/  
    unsigned int cmd_flags;    /*命令标识*/  
    enum rq_cmd_type_bits cmd_type;  /*命令类型*/  
    /*各种各样的扇区计数*/  
   /*为提交i/o维护bio横断面的状态信息，hard_*成员是块层内部使用的，驱动程序不应该改变 
它们*/  
    sector_t sector;     /*将提交的下一个扇区*/  
    sector_t hard_sector;        /* 将完成的下一个扇区*/  
    unsigned long nr_sectors;  /* 整个请求还需要传送的扇区数*/  
    unsigned long hard_nr_sectors; /* 将完成的扇区数*/  
 /*在当前bio中还需要传送的扇区数 */  
    unsigned int current_nr_sectors;  
    /*在当前段中将完成的扇区数*/  
    unsigned int hard_cur_sectors;  
    struct bio *bio;     /*请求中第一个未完成操作的bio*、 
    struct bio *biotail; /*请求链表中末尾的bio*、 
    struct hlist_node hash;  /*融合 hash */  
    /* rb_node仅用在I/O调度器中，当请求被移到分发队列中时， 
请求将被删除。因此，让completion_data与rb_node分享空间*/      
    union {  
        struct rb_node rb_node;   /* 排序/查找*/  
        void *completion_data;  
    }; 

request结构体的主要成员包括：
 sector_t hard_sector; 
unsigned long hard_nr_sectors; 
unsigned int hard_cur_sectors; 
上述3个成员标识还未完成的扇区，hard_sector是第1个尚未传输的扇区，hard_nr_sectors是尚待完成的扇区数，hard_cur_sectors是并且当前I/O操作中待完成的扇区数。这些成员只用于内核块设备层，驱动不应当使用它们。

 sector_t sector; 
unsigned long nr_sectors; 
unsigned int current_nr_sectors; 
驱动中会经常与这3个成员打交道，这3个成员在内核和驱动交互中发挥着重大作用。它们以512字节大小为1个扇区，如果硬件的扇区大小不是512字节，则需要进行相应的调整。例如，如果硬件的扇区大小是2048字节，则在进行硬件操作之前，需要用4来除起始扇区号。

 hard_sector、hard_nr_sectors、hard_cur_sectors与sector、nr_sectors、current_nr_sectors之间可认为是“副本”关系。

struct bio *bio; 
bio是这个请求中包含的bio结构体的链表，驱动中不宜直接存取这个成员，而应该使用后文将介绍的rq_for_each_bio()。

5.请求队列结构request_queue

每个块设备都有一个请求队列，每个请求队列单独执行I/O调度，请求队列是由请求结构实例链接成的双向链表，链表以及整个队列的信息用结构request_queue描述，称为请求队列对象结构或请求队列结构。它存放了关于挂起请求的信息以及管理请求队列（如：电梯算法）所需要的信息。结构成员request_fn是来自设备驱动程序的请求处理函数。

请求队列结构request_queue列出如下（在/include/linux/blk_dev.h中）

太长了，此处略，其实也看不懂，- -#

6.Bio结构

通常1个bio对应1个I/O请求，IO调度算法可将连续的bio合并成1个请求。所以，1个请求可以包含多个bio。

内核中块I/O操作的基本容器由bio结构体表示，定义 在<linux/bio.h>中，该结构体代表了正在现场的（活动的）以片段（segment）链表形式组织的块I/O操作。一个片段是一小 块连续的内存缓冲区。这样的好处就是不需要保证单个缓冲区一定要连续。所以通过片段来描述缓冲区，即使一个缓冲区分散在内存的多个位置上，bio结构体也 能对内核保证I/O操作的执行，这样的就叫做聚散I/O.

bio为通用层的主要数据结构，既描述了磁盘的位置，又描述了内存的位置，是上层内核vfs与下层驱动的连接纽带

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_vesc偏移的个数  
unsigned short        bi_idx;    //bi_io_vec的当前索引  
unsigned short        bi_phys_segments;//结合后的片段数目  
unsigned short        bi_hw_segments;//重映射后的片段数目  
unsigned int        bi_size;    //I/O计数  
unsigned int        bi_hw_front_size;//第一个可合并的段大小;  
unsigned int        bi_hw_back_size;//最后一个可合并的段大小  
unsigned int        bi_max_vecs;    //bio_vecs数目上限  
struct bio_vec        *bi_io_vec;    //bio_vec链表：内存的位置  
bio_end_io_t        *bi_end_io;//I/O完成方法  
atomic_t        bi_cnt; //使用计数  
void            *bi_private; //拥有者的私有方法  
bio_destructor_t    *bi_destructor;    //销毁方法  
}; 

7.内存数据段结构bio_vec

       结构bio_vec代表了内存中的一个数据段，数据段用页、偏移和长度描
述。I/O需要执行的内存位置用段表示，结构bio指向了一个段的数组。
结构bio_vec列出如下（在include/linux/bio.h中）：
struct bio_vec {
       struct page     *bv_page;   /*数据段所在的页*/
       unsigned short  bv_len;     /*数据段的长度*/
       unsigned short  bv_offset;  /*数据段页内偏移*/
};

块设备各个结构体间关系

三、块设备之程序设计

1.块设备驱动注册与注销

块设备驱动中的第1个工作通常是注册它们自己到内核，完成这个任务的函数是 register_blkdev()，其原型为：
int register_blkdev(unsigned int major, const char *name);

major 参数是块设备要使用的主设备号，name为设备名，它会在/proc/devices中被显示。 如果major为0，内核会自动分配一个新的主设备号register_blkdev()函数的返回值就是这个主设备号。如果返回1个负值，表明发生了一个错误。

与register_blkdev()对应的注销函数是unregister_blkdev()，其原型为：
int unregister_blkdev(unsigned int major, const char *name);
这里，传递给register_blkdev()的参数必须与传递给register_blkdev()的参数匹配，否则这个函数返回-EINVAL。

2.块设备的请求队列操作

标准的请求处理程序能排序请求，并合并相邻的请求，如果一个块设备希望使用标准的请求处理程序，那它必须调用函数blk_init_queue来初始化请求队列。当处理在队列上的请求时，必须持有队列自旋锁。初始化请求队列
request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock);

该函数的第1个参数是请求处理函数的指针，第2个参数是控制访问队列权限的自旋锁，这个函数会发生内存分配的行为，故它可能会失败，函数调用成
功时，它返回指向初始化请求队列的指针，否则，返回NULL。这个函数一般在块设备驱动的模块加载函数中调用。清除请求队列
void blk_cleanup_queue(request_queue_t * q);

这个函数完成将请求队列返回给系统的任务，一般在块设备驱动模块卸载函数中调用。

提取请求
struct request *elv_next_request(request_queue_t *queue); 
上述函数用于返回下一个要处理的请求（由 I/O 调度器决定），如果没有请求则返回NULL。

去除请求
void blkdev_dequeue_request(struct request *req); 
上述函数从队列中去除1个请求。如果驱动中同时从同一个队列中操作了多个请求，它必须以这样的方式将它们从队列中去除。

 

分配“请求队列”
request_queue_t *blk_alloc_queue(int gfp_mask);
对于FLASH、RAM盘等完全随机访问的非机械设备，并不需要进行复杂的I/O调度，这个时候，应该使用上述函数分配1个“请求队列”，并使用如下函数来绑定“请求队列”和“制造请求”函数。
void blk_queue_make_request(request_queue_t * q, 
make_request_fn * mfn);

void blk_queue_hardsect_size(request_queue_t *queue, 
unsigned short max); 
该函数用于告知内核块设备硬件扇区的大小，所有由内核产生的请求都是这个大小的倍数并且被正确对界。但是，内核块设备层和驱动之间的通信还是以512字节扇区为单位进行。

步骤：

在块设备驱动的模块加载函数中通常需要完成如下工作：
① 分配、初始化请求队列，绑定请求队列和请求函数。
② 分配、初始化gendisk，给gendisk的major、fops、queue等成
员赋值，最后添加gendisk。
③ 注册块设备驱动。
在块设备驱动的模块卸载函数中通常需要与模块加载函数相反的工作：
① 清除请求队列。
② 删除gendisk和对gendisk的引用。
③ 删除对块设备的引用，注销块设备驱动。

总结：

块设备的I/O操作方式与字符设备存在较大的不同，因而引入了request_queue、request、bio等一系列数据结构。在整个块设备的I/O操作中，贯穿于始终的就是“请求”，字符设备的I/O操作则是直接进行不绕弯，块设备的I/O操作会排队和整合。

驱动的任务是处理请求，对请求的排队和整合由I/O调度算法解决，因此，块设备驱动的核心就是请求处理函数或“制造请求”函数。

尽管在块设备驱动中仍然存在block_device_operations结构体及其成员函数，但其不再包含读写一类的成员函数，而只是包含打开、释放及I/O控制等与具体读写无关的函数。块设备驱动的结构相当复杂的，但幸运的是，块设备不像字符设备那么包罗万象，它通常就是存储设备，而且驱动的主体已经由Linux内核提供，针对一个特定的硬件系统，驱动工程师所涉及到的工作往往只是编写少量的与硬件直接交互的代码。

#include <linux/init.h>    
#include <linux/module.h>    
#include <linux/kernel.h>    
#include <linux/fs.h>  
#include <asm/uaccess.h>  
#include <linux/spinlock.h>  
#include <linux/sched.h>  
#include <linux/types.h>  
#include <linux/fcntl.h>  
#include <linux/hdreg.h>  
#include <linux/genhd.h>  
#include <linux/blkdev.h>  
  
#define MAXBUF 1024   
  
  
#define BLK_MAJOR 253  
  
char blk_dev_name[]="blk_dev";  
static char flash[1024*16];  
  
  
int major;  
spinlock_t lock;  
struct gendisk *gd;  
  
  
  
/*块设备数据传输*/  
static void blk_transfer(unsigned long sector, unsigned long nsect, char *buffer, int write)  
{  
    int read = !write;  
    if(read)  
    {  
        memcpy(buffer, flash+sector*512, nsect*512);  
    }  
    else  
    {  
        memcpy(flash+sector*512, buffer, nsect*512);  
    }  
}  
  
/*块设备请求处理函数*/  
static void blk_request_func(struct request_queue *q)  
{  
    struct request *req;  
    while((req = elv_next_request(q)) != NULL)    
    {  
        if(!blk_fs_request(req))  
        {  
            end_request(req, 0);  
            continue;  
        }  
          
        blk_transfer(req->sector, req->current_nr_sectors, req->buffer, rq_data_dir(req));  
        /*rq_data_dir从request获得数据传送的方向*/  
        /*req->current_nr_sectors 在当前段中将完成的扇区数*/  
        /*req->sector 将提交的下一个扇区*/  
        end_request(req, 1);  
    }  
}  
  
/*strcut block_device_operations*/  
static  int blk_ioctl(struct block_device *dev, fmode_t no, unsigned cmd, unsigned long arg)  
{  
       return -ENOTTY;  
}  
  
static int blk_open (struct block_device *dev , fmode_t no)  
{  
    printk("blk mount succeed\n");  
    return 0;  
}  
static int blk_release(struct gendisk *gd , fmode_t no)  
{  
    printk("blk umount succeed\n");  
    return 0;  
}  
struct block_device_operations blk_ops=  
{  
    .owner = THIS_MODULE,  
    .open = blk_open,  
    .release = blk_release,  
    .ioctl = blk_ioctl,  
};  
  
//-----------------------------------------------  
  
static int __init block_module_init(void)  
{  
      
      
    if(!register_blkdev(BLK_MAJOR, blk_dev_name)) //注册一个块设备  
    {  
        major = BLK_MAJOR;    
        printk("regiser blk dev succeed\n");  
    }  
    else  
    {  
        return -EBUSY;  
    }  
    gd = alloc_disk(1);  //分配一个gendisk，分区是一个  
    spin_lock_init(&lock); //初始化一个自旋锁  
    gd->major = major;  
    gd->first_minor = 0;   //第一个次设备号  
    gd->fops = &blk_ops;   //关联操作函数  
  
    gd->queue = blk_init_queue(blk_request_func, &lock); //初始化请求队列并关联到gendisk  
  
    snprintf(gd->disk_name, 32, "blk%c", 'a');    
    blk_queue_hardsect_size(gd->queue, 512);  //设置扇区大小512字节  
    set_capacity(gd, 32);  //设置块设备大小 512*32=16K  
    add_disk(gd);  
    printk("gendisk init success!\n");  
    return 0;  
}  
static void __exit block_module_exit(void)  
{  
    blk_cleanup_queue(gd->queue);  
    del_gendisk(gd);   
    unregister_blkdev(BLK_MAJOR, blk_dev_name);  
    printk("block module exit succeed!\n");  
}  
  
module_init(block_module_init);  
module_exit(block_module_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("gec"); 

四、块设备之自造请求

前面, 我们已经讨论了内核所作的在队列中优化请求顺序的工作; 这个工作包括排列请求和, 或许, 甚至延迟队列来允许一个预期的请求到达. 这些技术在处理一个真正的旋转的磁盘驱动器时有助于系统的性能. 但是, 许多面向块的设备, 例如闪存阵列, 用于数字相机的存储卡的读取器、u盘等, 并且 RAM 盘真正地有随机存取的性能, 包含从高级的请求队列逻辑中获益. 其他设备, 例如软件 RAID 阵列或者被逻辑卷管理者创建的虚拟磁盘, 没有这个块层的请求队列被优化的性能特征. 对于这类设备, 它最好直接从块层接收请求, 并且根本不去烦请求队列.

这时候我们就不用内核提供的IO调度器来优化排列和合并请求，不用内核的__make_request 帮我们处理bio，而是我们自己处理bio

1.数据流程

当我们初始化一个请求队列

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

把请求队列和这个内核已经实现好的函数绑定起来，__make_request就是负责制造请求request 的

blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)  
{  
    struct request_queue *q = blk_alloc_queue_node(GFP_KERNEL, node_id);  
    ......  
    blk_queue_make_request(q, __make_request);  
    ......  
} 

static int __make_request(struct request_queue *q, struct bio *bio) 

这个bio就是最基本的读写不同扇区的请求，经过__make_request处理后，经过优化返回request

但是，在这里已经不需要了，我们要直接处理bio，来一个处理一个。

2.分配“请求队列”

request_queue_t *blk_alloc_queue(int gfp_mask);
对于FLASH、RAM盘等完全随机访问的非机械设备，并不需要进行复杂的I/O调度，这个时候，应该使用上述函数分配1个“请求队列”，并使用如下函数来绑定“请求队列”和“制造请求”函数。
void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn);

void blk_queue_hardsect_size(request_queue_t *queue, unsigned short max); 
该函数用于告知内核块设备硬件扇区的大小，所有由内核产生的请求都是这个大小的倍数并且被正确对界。但是，内核块设备层和驱动之间的通信还是以512字节扇区为单位进行。

绑定请求队列和“制造请求”函数

void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)

一个"制造请求"函数来处理bio， make_request 函数有这个原型:

typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);  

参考代码：

#include <linux/init.h>  
#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/fs.h>  
#include <linux/errno.h>  
#include <linux/types.h>  
#include <linux/fcntl.h>  
#include <linux/vmalloc.h>  
#include <linux/hdreg.h>  
#include <linux/blkdev.h>  
#include <linux/blkpg.h>  
#include <asm/uaccess.h>  
  
#define BLK_NAME "ram_blk"  
#define BLK_MAJOR 222  
#define DISK_SECTOR_SIZE 512 //每扇区大小  
#define DISK_SECTOR 1024  //总扇区数，  
#define DISK_SIZE (DISK_SECTOR_SIZE*DISK_SECTOR)//总大小，共0.5M  
  
typedef struct//设备结构体  
{  
       unsigned char          *data;  
       struct request_queue   *queue;  
       struct gendisk         *gd;  
} disk_dev;  
  
disk_dev device;//定义设备结构体  
  
//--------------------------------------------------------------------------  
//在硬盘等带柱面扇区等的设备上使用request，可以整理队列。但是ramdisk等可以  
//使用make_request  
static int disk_make_request(struct request_queue *q,struct bio *bio)  
{  
       int i;  
       char *mem_pbuf;  
       char *disk_pbuf;  
       disk_dev *pdevice;  
       struct bio_vec *pbvec;  
       /*在遍历段之前先判断要传输数据的总长度大小是否超过范围*/  
       i=bio->bi_sector*DISK_SECTOR_SIZE+bio->bi_size;  
       if(i>DISK_SIZE)//判断是否超出范围  
              goto fail;  
         
       pdevice=(disk_dev*)bio->bi_bdev->bd_disk->private_data;//得到设备结构体  
       disk_pbuf=pdevice->data+bio->bi_sector*DISK_SECTOR_SIZE;//得到要读写的起始位置  
         
       /*开始遍历这个bio中的每个bio_vec*/  
       bio_for_each_segment(pbvec,bio,i)//循环分散的内存segment  
       {  
              mem_pbuf=kmap(pbvec->bv_page)+pbvec->bv_offset;//获得实际内存地址  
              switch(bio_data_dir(bio))  
              {//读写  
                     case READA:  
                     case READ:  
                            memcpy(mem_pbuf,disk_pbuf,pbvec->bv_len);  
                            break;  
                     case WRITE:  
                            memcpy(disk_pbuf,mem_pbuf,pbvec->bv_len);  
                            break;  
                     default:  
                            kunmap(pbvec->bv_page);  
                            goto fail;  
              }  
              kunmap(pbvec->bv_page);//清除映射  
              disk_pbuf+=pbvec->bv_len;  
       }  
       bio_endio(bio,0);//这个函数2.6.25和2.6.4是不一样的，  
       return 0;  
fail:  
       bio_io_error(bio);//这个函数2.6.25和2.6.4是不一样的，  
       return 0;  
}  
  
int blk_open(struct block_device *dev, fmode_t no)   
{  
       return 0;  
}  
  
int blk_release(struct gendisk *gd, fmode_t no)  
{  
       return 0;  
}  
  
int blk_ioctl(struct block_device *dev, fmode_t no, unsigned cmd, unsigned long arg)  
{  
       return -ENOTTY;  
}  
  
static struct block_device_operations blk_fops=  
{  
       .owner=THIS_MODULE,  
       .open=blk_open,//  
       .release=blk_release,//  
       .ioctl=blk_ioctl,//   
};  
  
int disk_init(void)  
{  
        if(!register_blkdev(BLK_MAJOR,BLK_NAME));//注册驱动  
    {  
         printk("register blk_dev succeed\n");  
    }  
      
       device.data=vmalloc(DISK_SIZE);  
       device.queue=blk_alloc_queue(GFP_KERNEL);//生成队列  
       blk_queue_make_request(device.queue,disk_make_request);/*注册make_request  绑定请求制造函数*/  
  
    printk("make_request succeed\n");  
  
       device.gd=alloc_disk(1);//生成gendisk  
       device.gd->major=BLK_MAJOR;//主设备号  
       device.gd->first_minor=0;//此设备号  
       device.gd->fops=&blk_fops;//块文件结构体变量  
       device.gd->queue=device.queue;//请求队列  
       device.gd->private_data=&device;  
       sprintf(device.gd->disk_name,"disk%c",'a');//名字  
       set_capacity(device.gd,DISK_SECTOR);//设置大小  
       add_disk(device.gd);//注册块设备信息  
    printk("gendisk succeed\n");      
       return 0;  
}  
  
void disk_exit(void)  
{  
      
       del_gendisk(device.gd);  
       put_disk(device.gd);  
       unregister_blkdev(BLK_MAJOR,BLK_NAME);  
       vfree(device.data);  
        printk("free succeed\n");  
      
}  
  
module_init(disk_init);  
module_exit(disk_exit);  
  
MODULE_LICENSE("Dual BSD/GPL");