1）实验平台：正点原子ATK-DLRK3568开发板
2）平台购买地址：https://detail.tmall.com/item.htm?id=731866264428
3）全套实验源码+手册+视频下载地址： http://www.openedv.com/docs/boards/xiaoxitongban
第三十五章 Linux块设备驱动实验
本章我们来学习一下块设备驱动框架，块设备驱动是Linux三大驱动类型之一。块设备驱动远比字符设备驱动复杂得多，不同类型的存储设备又对应不同的驱动子系统，本章我们重点学习一下块设备相关驱动驱动概念，不涉及到具体的存储设备。最后，我们使用ATK-DLRK3568开发板板载RAM模拟一个块设备，学习块设备驱动框架的使用。
35.1 什么是块设备
块设备是针对存储设备的，比如 SD 卡、EMMC、NAND Flash、Nor Flash、SPI Flash、机械硬盘、固态硬盘等。因此块设备驱动其实就是这些存储设备驱动，块设备驱动相比字符设备驱动的主要区别如下：
①、块设备只能以块为单位进行读写访问，块是 linux 虚拟文件系统(VFS)基本的数据传输单位。字符设备是以字节为单位进行数据传输的，不需要缓冲。
②、块设备在结构上是可以进行随机访问的，对于这些设备的读写都是按块进行的，块设备使用缓冲区来暂时存放数据，等到条件成熟以后再一次性将缓冲区中的数据写入块设备中。这么做的目的为了提高块设备寿命，大家如果仔细观察的话就会发现有些硬盘或者 NAND Flash就会标明擦除次数(flash 的特性，写之前要先擦除)，比如擦除 100000 次等。因此，为了提高块设备寿命而引入了缓冲区，数据先写入到缓冲区中，等满足一定条件后再一次性写入到真正的物理存储设备中，这样就减少了对块设备的擦除次数，提高了块设备寿命。
字符设备是顺序的数据流设备，字符设备是按照字节进行读写访问的。字符设备不需要缓冲区，对于字符设备的访问都是实时的，而且也不需要按照固定的块大小进行访问。
块设备结构的不同其 I/O 算法也会不同，比如对于 EMMC、SD 卡、NAND Flash 这类没有任何机械设备的存储设备就可以任意读写任何的扇区(块设备物理存储单元)。但是对于机械硬盘这样带有磁头的设备，读取不同的盘面或者磁道里面的数据，磁头都需要进行移动，因此对于机械硬盘而言，将那些杂乱的访问按照一定的顺序进行排列可以有效提高磁盘性能，linux 里面针对不同的存储设备实现了不同的 I/O 调度算法。
35.2 块设备驱动框架
35.2.1 block_device 结构体
Linux内核使用block_device表示块设备，block_device为一个结构体，定义在include/linux/fs.h文件中，结构体内容如下所示：
示例代码35.2.1.1 block_device结构体
1 struct block_device {
2 dev_t bd_dev; /* not a kdev_t - it's a search key */
3 int bd_openers;
4 struct inode * bd_inode; /* will die */
5 struct super_block * bd_super;
6 struct mutex bd_mutex; /* open/close mutex */
7 void * bd_claiming;
8 void * bd_holder;
9 int bd_holders;
10 bool bd_write_holder;
11 #ifdef CONFIG_SYSFS
12 struct list_head bd_holder_disks;
13 #endif
14 struct block_device * bd_contains;
15 unsigned bd_block_size;
16 u8 bd_partno;
17 struct hd_struct * bd_part;
18 /* number of times partitions within this device have been opened. */
19 unsigned bd_part_count;
20 int bd_invalidated;
21 struct gendisk * bd_disk;
22 struct request_queue * bd_queue;
23 struct backing_dev_info *bd_bdi;
24 struct list_head bd_list;
25 /*
26 * Private data. You must have bd_claim'ed the block_device
27 * to use this. NOTE: bd_claim allows an owner to claim
28 * the same device multiple times, the owner must take special
29 * care to not mess up bd_private for that case.
30 */
31 unsigned long bd_private;
32
33 /* The counter of freeze processes */
34 int bd_fsfreeze_count;
35 /* Mutex for freeze */
36 struct mutex bd_fsfreeze_mutex;
37
38 ANDROID_KABI_RESERVE(1);
39 ANDROID_KABI_RESERVE(2);
40 ANDROID_KABI_RESERVE(3);
41 ANDROID_KABI_RESERVE(4);
42 } __randomize_layout;
对于block_device结构体，我们重点关注一下第21行的bd_disk成员变量，此成员变量为gendisk结构体指针类型，内核使用block_device来表示一个具体的块设备对象，比如一个硬盘或者分区，如果是硬盘的话，bd_disk就指向通用磁盘结构gendisk。
1 、注册块设备
和字符设备驱动一样，我们需要向内核注册新的块设备、申请设备号，块设备注册函数为register_blkdev，函数原型如下：
int register_blkdev(unsigned int major, const char *name)
函数参数和返回值含义如下：
major ：主设备号。
name ：块设备名字。
返回值：如果参数 major 在 1~(BLKDEV_MAJOR_MAX-1)之间的话表示自定义主设备号，那么返回 0 表示注册成功，如果返回负值的话表示注册失败。如果 major 为 0 的话表示由系统自动分配主设备号，那么返回值就是系统分配的主设备号，如果返回负值那就表示注册失败。
2 、注销块设备
和字符设备驱动一样，如果不使用某个块设备了，那么就需要注销掉，函数为unregister_blkdev，函数原型如下：
void unregister_blkdev(unsigned int major, const char *name)
函数参数和返回值含义如下：
major ：要注销的块设备主设备号。
name： ： 要注销的块设备名字。
返回值：无。
35.2.2 gendisk结构体
Linux内核使用gendisk来描述一个磁盘设备，这是一个结构体，定义在include/linux/genhd.h中，内容如下所示：
示例代码35.2.2.1 gendisk结构体
1 struct gendisk {
2 /* major, first_minor and minors are input parameters only,
3 * don't use directly. Use disk_devt() and disk_max_parts().
4 */
5 int major; /* major number of driver */
6 int first_minor;
7 int minors; /* maximum number of minors, =1 for
8 * disks that can't be partitioned. */
9
10 char disk_name[DISK_NAME_LEN]; /* name of major driver */
11 char *(*devnode)(struct gendisk *gd, umode_t *mode);
12
13 unsigned short events; /* supported events */
14 unsigned short event_flags;
15
16 /* Array of pointers to partitions indexed by partno.
17 * Protected with matching bdev lock but stat and other
18 * non-critical accesses use RCU. Always access through
19 * helpers.
20 */
21 struct disk_part_tbl __rcu *part_tbl;
22 struct hd_struct part0;
23
24 const struct block_device_operations *fops;
25 struct request_queue *queue;
26 void *private_data;
27
28 int flags;
29 struct rw_semaphore lookup_sem;
30 struct kobject *slave_dir;
31
32 struct timer_rand_state *random;
33 atomic_t sync_io; /* RAID */
34 struct disk_events *ev;
35 #ifdef CONFIG_BLK_DEV_INTEGRITY
36 struct kobject integrity_kobj;
37 #endif /* CONFIG_BLK_DEV_INTEGRITY */
38 int node_id;
39 struct badblocks *bb;
40 struct lockdep_map lockdep_map;
41
42 ANDROID_KABI_RESERVE(1);
43 ANDROID_KABI_RESERVE(2);
44 ANDROID_KABI_RESERVE(3);
45 ANDROID_KABI_RESERVE(4);
46 };
我们简单看一下 gendisk 结构体中比较重要的几个成员变量：
第 5 行，major 为磁盘设备的主设备号。
第 6 行，first_minor 为磁盘的第一个次设备号。
第 7 行，minors 为磁盘的此设备号数量，也就是磁盘的分区数量，这些分区的主设备号一样，此设备号不同。
第 21 行，part_tbl 为磁盘对应的分区表，为结构体 disk_part_tbl 类型，disk_part_tbl 的核心是一个 hd_struct 结构体指针数组，此数组每一项都对应一个分区信息。
第 24 行，fops 为块设备操作集，为 block_device_operations 结构体类型。和字符设备操作集 file_operations 一样，是块设备驱动中的重点！
第 25 行，queue 为磁盘对应的请求队列，所以针对该磁盘设备的请求都放到此队列中，驱动程序需要处理此队列中的所有请求。
编写块的设备驱动的时候需要分配并初始化一个 gendisk，linux 内核提供了一组 gendisk 操作函数，我们来看一下一些常用的 API 函数。
1、申请 gendisk
使用 gendisk 之前要先申请，allo_disk 函数用于申请一个 gendisk，函数原型如下：
struct gendisk *alloc_disk(int minors)
函数参数和返回值含义如下：
minors：次设备号数量，也就是 gendisk 对应的分区数量。
返回值：成功：返回申请到的 gendisk，失败：NULL。
2、删除 gendisk
如果要删除 gendisk 的话可以使用函数 del_gendisk，函数原型如下：
void del_gendisk(struct gendisk *gp)
函数参数和返回值含义如下：
gp: 删除的 gendisk。
返回值：无。
3、将 gendisk 添加到内核
使用 alloc_disk 申请到 gendisk 以后系统还不能使用，必须使用 add_disk 函数将申请到的gendisk 添加到内核中，add_disk 函数原型如下：
void add_disk(struct gendisk disk)
函数参数和返回值含义如下：
disk: 添加到内核的 gendisk。
返回值：无。
4、设置 gendisk 容量
每一个磁盘都有容量，所以在初始化 gendisk 的时候也需要设置其容量，使用函数set_capacity，函数原型如下：
void set_capacity(struct gendisk disk, sector_t size)
函数参数和返回值含义如下：
disk: 设置容量的 gendisk。
size：盘容量大小，注意这里是扇区数量。块设备中最小的可寻址单元是扇区，一个扇区一般是 512 字节，有些设备的物理扇区可能不是 512 字节。不管物理扇区是多少，内核和块设备驱动之间的扇区都是 512 字节。所以 set_capacity 函数设置的大小就是块设备实际容量除以512 字节得到的扇区数量。比如一个 2MB 的磁盘，其扇区数量就是(210241024)/512=4096。
返回值：无。
5、调整 gendisk引用计数
内核会通过 get_disk_and_module 和 put_disk 这两个函数来调整 gendisk 的引用计数，根据名字就可以知道，get_disk_and_module是增加 gendisk 的引用计数，put_disk 是减少 gendisk 的引用计数，这两个函数原型如下所示：
truct kobject * get_disk_and_module (struct gendisk *disk)
void put_disk(struct gendisk *disk)
35.2.3 block_device_operations结构体
和字符设备的file_operations一样，块设备也有操作集，为结构体block_device_operations，此结构定于在include/linux/blkdev.h中，结构体内容如下：
示例代码35.2.3.1 block_device_operations结构体
1 struct block_device_operations {
2 int (*open) (struct block_device *, fmode_t);
3 void (*release) (struct gendisk *, fmode_t);
4 int (*rw_page)(struct block_device *, sector_t, struct page *,
unsigned int);
5 int (*ioctl) (struct block_device *, fmode_t, unsigned,
unsigned long);
6 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned,
unsigned long);
7 unsigned int (*check_events) (struct gendisk *disk,
8 unsigned int clearing);
9 /* ->media_changed() is DEPRECATED, use ->check_events() instead */
10 int (*media_changed) (struct gendisk *);
11 void (*unlock_native_capacity) (struct gendisk *);
12 int (*revalidate_disk) (struct gendisk *);
13 int (*getgeo)(struct block_device *, struct hd_geometry *);
14 /* this callback is with swap_lock and sometimes page table lock held */
15 void (*swap_slot_free_notify) (struct block_device *, unsigned long);
16 struct module *owner;
17 const struct pr_ops *pr_ops;
18 };
可以看出，block_device_operations结构体里面的操作集函数和字符设备的file_operations操作集基本类似，但是块设备的操作集函数比较少，我们来看一下其中比较重要的几个成员函数：
第2行，open函数用于打开指定的设备。
第3行，release函数用于关闭（释放）指定的块设备。
第4行，rw_page函数用于读写指定的页。
第5行，ioctl函数用于块设备I/O控制。
第6行，compat_ioctl函数与ioctl函数一样，都是用于块设备的I/O控制。区别在于在 64位系统上，32 位应用程序的 ioctl 会调用 compat_iotl 函数。在 32 位系统上运行的 32 位应用程序调用的就是 ioctl 函数。
第13行，getgeo 函数用于获取磁盘信息，包括磁头、柱面和扇区等信息。
第 16 行，owner 表示此结构体属于哪个模块，一般直接设置为 THIS_MODULE。
35.2.4 块设备I/O请求过程
大家如果仔细观察的话会在block_device_operations结构体中并没有找到read和write这样的读写函数，那么块设备是怎么从物理块设备中读写数据？这里就引处理块设备驱动中非常重要的request_queue、request和bio。
1、请求队列request_queue
内核将对块设备的读写都发送到请求队列request_queue中，request_queue中是大量的request(请求结构体)，而request又包含了bio，bio保存了读写相关数据，比如从块设备的哪个地址开始读取、读取的数据长度，读取到哪里，如果是写的话还包括要写入的数据等。我们先来看一下request_queue，这是一个结构体，定义在文件include/linux/blkdev.h中，由于request_queue结构体比较长，这里就不列出来了。大家回过头看一下示例代码35.2.2.1的gendisk结构体就会发现里面有一个request_queue结构体指针类型成员变量queue，也就说在编写块设备驱动的时候，每个磁盘(gendisk)都要分配一个request_queue。
①、初始化请求队列
初始化请求队列可以分为两部分，第一部分是创建blk_mq_tag_set结构体，然后使用blk_mq_alloc_tag_set函数初始化blk_mq_tag_set对象。第二部分使用blk_mq_init_queue函数获取request_queue。
blk_mq_tag_set结构体定义在include/linux/blk-mq.h中，如下示例代码所示：
示例代码35.2.4.1 blk_mq_tag_set结构体
1 struct blk_mq_tag_set {
2 unsigned int *mq_map;
3 const struct blk_mq_ops *ops;
4 unsigned int nr_hw_queues;
5 unsigned int queue_depth; /* max hw supported */
6 unsigned int reserved_tags;
7 unsigned int cmd_size; /* per-request extra data */
8 int numa_node;
9 unsigned int timeout;
10 unsigned int flags; /* BLK_MQ_F_* */
11 void *driver_data;
12
13 struct blk_mq_tags **tags;
14
15 struct mutex tag_list_lock;
16 struct list_head tag_list;
17 };
第3行，ops为驱动实现的操作集合，会被request_queue继承。
第4行，nr_hw_queues为硬件队列个数。
第5行，queue_depth为队列的深度，即队列中可以存在的最大请求数。
第6行，reserved_tags为保留的标签数。
第8行，numa_node为队列所属的numa节点。
第10行，flags为属性标志，一般为BLK_MQ_F_SHOULD_MERGE，想了解跟多的标志位可以去看include/linux/blk-mq.h文件。
接着我们去看看blk_mq_ops结构体，结构体原型如下所示(有省略)：
示例代码35.2.4.2 blk_mq_ops结构体
1 struct blk_mq_ops {
2 queue_rq_fn *queue_rq;
3 }
这里只是列出queue_rq成员，因为本章例程只用到它。queue_rq这是一个queue_rq_fn类型的指针，queue_rq_fn类型定义如下：
typedef blk_status_t (queue_rq_fn)(struct blk_mq_hw_ctx *,const struct blk_mq_queue_data *);
queue_rq请求处理函数指针，此函数需要驱动人员自行实现。注意：函数的两个形参就不要管了，只要知道可以通过第二形参获取request结构体。
编写块设备的请求队列驱动的时候需要分配并初始化一个blk_mq_tag_set，linux内核提供了一组blk_mq_tag_set操作相关的函数，我们来看一下一些常用的API函数。
1）、为一个或多个请求队列分配tag集合
给blk_mq_tag_set对象赋值后，要使用blk_mq_alloc_tag_set函数为一个或多个请求队列分配tag和request集合，函数原型如下：
int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set);
函数参数和返回值含义如下：
set：需要分配tag集合的blk_mq_tag_set。
返回值：0表示成功，非0表示失败。
2）、释放请求队列中的tag集合
如果要释放请求队列中的tag集合，可以使用blk_mq_free_tag_set，函数原型如下：
void blk_mq_free_tag_set(struct blk_mq_tag_set *set);
函数参数和返回值含义如下：
set：要释放tag集合的blk_mq_tag_set。
返回值：无。
最后我们需要通过blk_mq_init_queue函数来初始化IO请求队列request_queue，此函数会申请request_queue，然后返回，函数原型如下：
struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *);
函数参数和返回值含义如下：
set：blk_mq_tag_set对象。
返回值：初始化以后的request_queue的地址。
Linux内核也提供了一步创建request_queue队列的函数：blk_mq_init_sq_queue，使用此函数可以一步创建请求队列，函数原型如下：
struct request_queue *blk_mq_init_sq_queue(struct blk_mq_tag_set *set,
const struct blk_mq_ops *ops,
unsigned int queue_depth,
unsigned int set_flags)
函数参数和返回值含义如下：
set：blk_mq_tag_set对象。
ops：操作函数。
queue_depth：队列深度。
set_flags：标志。
返回值：request_queue的地址。
②、删除请求队列
当卸载块设备驱动的时候我们还需要删除掉前面申请到的request_queue，删除请求队列使用函数blk_cleanup_queue，函数原型如下：
void blk_cleanup_queue(struct request_queue *q)
函数参数和返回值含义如下：
q：需要删除的请求队列。
返回值：无。
③、分配请求队列并绑定制造请求函数
blk_mq_init_queue函数完成了请求队列的申请以及请求处理函数的绑定，这个一般用于像机械硬盘这样的存储设备，需要I/O调度器来优化数据读写过程。但是对于EMMC、SD卡这样的非机械设备，可以进行完全随机访问，所以就不需要复杂的I/O调度器了。对于非机械设备我们可以先申请request_queue，然后将申请到的request_queue与“制造请求”函数绑定在一起。先来看一下request_queue申请函数blk_alloc_queue，函数原型如下：
struct request_queue *blk_alloc_queue(gfp_t gfp_mask)
函数参数和返回值含义如下：
gfp_mask：内存分配掩码，具体可选择的掩码值请参考include/linux/gfp.h中的相关宏定义，一般为GFP_KERNEL。
返回值：申请到的无I/O调度的request_queue。
我们需要为申请到的请求队列绑定一个“制造请求”函数(其他参考资料将其直接翻译为“制造请求”函数)。这里我们需要用到函数blk_queue_make_request，函数原型如下：
void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
函数参数和返回值含义如下：
q：需要绑定的请求队列，也就是blk_alloc_queue申请到的请求队列。
mfn：需要绑定的“制造”请求函数，函数原型如下：
void (make_request_fn) (struct request_queue *q, struct bio *bio)
“制造请求”函数需要驱动编写人员实现。
返回值：无。
一般blk_alloc_queue和blk_queue_make_request是搭配在一起使用的，用于那些非机械的存储设备、无需I/O调度器，比如EMMC、SD卡等。blk_init_queue函数会给请求队列分配一个I/O调度器，用于机械存储设备，比如机械硬盘等。
2、请求request
请求队列(request_queue)里面包含的就是一系列的请求(request)，request是一个结构体，定义在include/linux/blkdev.h里面，这里就不展开request结构体了，太长了。request里面有一个名为“bio”的成员变量，类型为bio结构体指针。前面说了，真正的数据就保存在bio里面，所以我们需要从request_queue中取出一个一个的request，然后再从每个request里面取出bio，最后根据bio的描述讲数据写入到块设备，或者从块设备中读取数据。
①、开启请求
当有请求处理的时候，我们要用blk_mq_start_request函数开启请求处理，函数原型如下：
void blk_mq_start_request(struct request *rq);
函数参数和返回值含义如下：
rq：指定request_queue。
返回值：无。
②、结束请求
我们不用处理请求的时候，要使用blk_mq_end_request函数结束请求处理，函数原型如下：
void blk_mq_end_request(struct request *rq, blk_status_t error);
函数参数和返回值含义如下：
rq：需要结束的请求(request)。
error：0表示正确的退出结束请求处理，非0错误退出结束请求处理。
返回值：无。
这里我们先总结一下是如何使用这个两个函数去处理请求数据的，示例代码如下所示：
示例代码35.2.4.3 处理请求模型
1 static int ramdisk_transfer(struct request *req)
2 {
3 /* 此函数要实现把数据拷贝到硬盘 */
4 reutrn 0;
5 }
6
7 static blk_status_t _queue_rq(struct blk_mq_hw_ctx *hctx,
const struct blk_mq_queue_data* bd)
8 {
9 struct request *req = bd->rq;
10 int ret;
11 /* 开启请求处理 */
12 blk_mq_start_request(req);
13
14 /* 处理请求 */
15 ret = ramdisk_transfer(req);
16
17 /* 结束请求处理 */
18 blk_mq_end_request(req, ret);
19
20 return 0;
21 }
3、bio结构
每个request里面里面会有多个bio，bio保存着最终要读写的数据、地址等信息。上层应用程序对于块设备的读写会被构造成一个或多个bio结构，bio结构描述了要读写的起始扇区、要读写的扇区数量、是读取还是写入、页便宜、数据长度等等信息。上层会将bio提交给I/O调度器，I/O调度器会将这些bio构造成request结构， request_queue里面顺序存放着一系列的request。新产生的bio可能被合并到request_queue里现有的request中，也可能产生新的request，然后插入到request_queue中合适的位置，这一切都是由I/O调度器来完成的。request_queue、request和bio之间的关系如图35.2.4.1所示：
图35.2.4.1 request_queue、request和bio之间的关系
bio是个结构体，定义在include/linux/blk_types.h中，结构体内容如下(有缩减)：
示例代码35.2.4.4 bio结构体
1 struct bio {
2 struct bio *bi_next; /* 请求队列的下一个 bio */
3 struct gendisk *bi_disk;
4 unsigned int bi_opf; /* bottom bits req flags,
5 * top bits REQ_OP. Use
6 * accessors.
7 */
8 unsigned short bi_flags; /* bio 状态等信息 */
9 unsigned short bi_ioprio;
10 unsigned short bi_write_hint;
11 blk_status_t bi_status;
12 u8 bi_partno;
13 struct bvec_iter bi_iter; /* I/O 操作,读或写 */
14 atomic_t __bi_remaining;
15 bio_end_io_t *bi_end_io;
16 void *bi_private;
17 unsigned short bi_vcnt; /* bio_vec 列表中元素数量 */
18
19 /*
20 * Everything starting with bi_max_vecs will be preserved by
bio_reset()
21 */
22
23 unsigned short bi_max_vecs; /* bio_vec 列表长度 */
24 atomic_t __bi_cnt; /* pin count */
25 struct bio_vec *bi_io_vec; /* bio_vec 列表 */
26 struct bio_set *bi_pool;
27
28 /*
29 * We can inline a number of vecs at the end of the bio, to avoid
30 * double allocations for a small number of bio_vecs. This member
31 * MUST obviously be kept at the very end of the bio.
32 */
33 struct bio_vec bi_inline_vecs[0];
34 };
重点来看一下第 13 行和第 25 行，第 13行为 bvec_iter 结构体类型的成员变量，第 25行为bio_vec 结构体指针类型的成员变量。
bvec_iter结构体描述了要操作的设备扇区等信息，结构体内容如下：
示例代码35.2.4.5 bvec_iter结构体
1 struct bvec_iter {
2 sector_t bi_sector; /* I/O 请求的设备起始扇区(512 字节) */
3 unsigned int bi_size; /* 剩余的 I/O 数量 */
4 unsigned int bi_idx; /* blv_vec 中当前索引 */
5 unsigned int bi_bvec_done; /* 当前 bvec 中已经处理完成的字节数 */
6 };
bio_vec 结构体描述了内容如下：
示例代码35.2.4.6 bio_vec结构体
1 struct bio_vec {
2 struct page *bv_page; /* 页 */
3 unsigned int bv_len; /* 长度 */
4 unsigned int bv_offset; /* 偏移 */
5 }
可以看出 bio_vec 就是“page,offset,len”组合，page 指定了所在的物理页，offset 表示所处页的偏移地址，len 就是数据长度。
我们对于物理存储设备的操作不外乎就是将 RAM 中的数据写入到物理存储设备中，或者将物理设备中的数据读取到 RAM 中去处理。数据传输三个要求：数据源、数据长度以及数据目的地，也就是你要从物理存储设备的哪个地址开始读取、读取到 RAM 中的哪个地址处、读取的数据长度是多少。既然 bio 是块设备最小的数据传输单元，那么 bio 就有必要描述清楚这些信息，其中 bi_iter 这个结构体成员变量就用于描述物理存储设备地址信息，比如要操作的扇区地址。bi_io_vec 指向 bio_vec 数组首地址，bio_vec 数组就是 RAM 信息，比如页地址、页偏移以及长度，“页地址”是 linux 内核里面内存管理相关的概念，这里我们不深究 linux 内存管理，我们只需要知道对于 RAM 的操作最终会转换为页相关操作。
bio、bvec_iter以及bio_vec这三个结构体之间的关系如图35.2.4.2所示：
图35.2.4.2 bio、bio_iter与bio_vec之间的关系
①、遍历请求中的bio
前面说了，请求中包含有大量的bio，因此就涉及到遍历请求中所有bio并进行处理。遍历请求中的bio使用函数__rq_for_each_bio，这是一个宏，内容如下：
示例代码35.2.4.7 __rq_for_each_bio函数
#define __rq_for_each_bio(_bio, rq)
if ((rq->bio))
for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
_bio就是遍历出来的每个bio，rq是要进行遍历操作的请求，_bio参数为bio结构体指针类型，rq参数为request结构体指针类型。
②、遍历bio中的所有段
bio包含了最终要操作的数据，因此还需要遍历bio中的所有段，这里要用到bio_for_each_segment函数，此函数也是一个宏，内容如下：
示例代码35.2.4.8 bio_for_each_segment函数
#define bio_for_each_segment(bvl, bio, iter) \
__bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)
第一个bvl参数就是遍历出来的每个bio_vec，第二个bio参数就是要遍历的bio，类型为bio结构体指针，第三个iter参数保存要遍历的bio中bio_iter成员变量。
③、通知bio处理结束
如果使用“制造请求”，也就是抛开I/O调度器直接处理bio的话，在bio处理完成以后要通过内核bio处理完成，使用bio_endio函数，函数原型如下：
bvoid bio_endio(struct bio *bio, int error)
函数参数和返回值含义如下：
bio：要结束的bio。
error：如果bio处理成功的话就直接填0，如果失败的话就填个负值，比如-EIO。
返回值：无
35.3 使用请求队列实验
关于块设备架构就讲解这些，接下来我们使用开发板上的RAM模拟一段块设备，也就是ramdisk，然后编写块设备驱动。
35.3.1 实验程序编写
本实验对应的例程代码路径为：开发板光盘06程序源码3、Linux驱动例程 21_ramdisk_withrequest。
新建名为“20_ramdisk_withrequest”文件夹，然后在20_ramdisk_withrequest文件夹里面创建vscode工程，工作区名为“ramdisk_withrequest”。工程创建好以后新建ramdisk_withrequest.c文件，在ramdisk_withrequest.c里面输入如下内容：
示例代码35.3.1.1 ramdisk_withrequest.c
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : ramdisk_withrequest.c
作者 : 正点原子Linux团队
版本 : V1.0
描述 : 块设备请求队列驱动程序
其他 : 无
论坛 : www.openedv.com
日志 : 初版 V1.0 2023/08/15 正点原子Linux团队创建
***************************************************************/
1 #include <linux/module.h>
2 #include <linux/moduleparam.h>
3 #include <linux/init.h>
4 #include <linux/sched.h>
5 #include <linux/kernel.h>
6 #include <linux/slab.h>
7 #include <linux/fs.h>
8 #include <linux/errno.h>
9 #include <linux/types.h>
10 #include <linux/fcntl.h>
11 #include <linux/hdreg.h>
12 #include <linux/kdev_t.h>
13 #include <linux/vmalloc.h>
14 #include <linux/genhd.h>
15 #include <linux/blk-mq.h>
16 #include <linux/buffer_head.h>
17 #include <linux/bio.h>
18
19 #define RAMDISK_SIZE (2 * 1024 * 1024) /* 容量大小为2MB */
20 #define RAMDISK_NAME "ramdisk" /* 名字 */
21 #define RADMISK_MINOR 3 /* 表示有三个磁盘分区！不是次设备号为3！*/
22
23 /* ramdisk设备结构体 */
24 struct ramdisk_dev{
25 int major; /* 主设备号 */
26 unsigned char *ramdiskbuf; /* ramdisk内存空间,用于模拟块设备 */
27 struct gendisk *gendisk; /* gendisk */
28 struct request_queue *queue; /* 请求队列 */
29 struct blk_mq_tag_set tag_set; /* blk_mq_tag_set */
30 spinlock_t lock; /* 自旋锁 */
31 };
32
33 struct ramdisk_dev *ramdisk = NULL; /* ramdisk设备指针 */
34
35 /*
36 * @description : 处理传输过程
37 * @param-req : 请求
38 * @return : 0，成功；其它表示失败
39 */
40 static int ramdisk_transfer(struct request *req)
41 {
42 unsigned long start = blk_rq_pos(req) << 9; /* blk_rq_pos获取到的是扇区地址，左移9位转换为字节地址 */
43 unsigned long len = blk_rq_cur_bytes(req); /* 大小 */
44
45
46 /* bio中的数据缓冲区
47 * 读：从磁盘读取到的数据存放到buffer中
48 * 写：buffer保存这要写入磁盘的数据
49 */
50 void *buffer = bio_data(req->bio);
51
52 if(rq_data_dir(req) == READ) /* 读数据 */
53 memcpy(buffer, ramdisk->ramdiskbuf + start, len);
54 else if(rq_data_dir(req) == WRITE) /* 写数据 */
55 memcpy(ramdisk->ramdiskbuf + start, buffer, len);
56
57 return 0;
58
59 }
60
61 /*
62 * @description : 开始处理传输数据的队列
63 * @hctx : 硬件相关的队列结构体
64 * @bd : 数据相关的结构体
65 * @return : 0，成功；其它值为失败
66 */
67 static blk_status_t _queue_rq(struct blk_mq_hw_ctx *hctx, const
struct blk_mq_queue_data* bd)
68 {
69 struct request *req = bd->rq; /* 通过bd获取到request队列*/
70 struct ramdisk_dev *dev = req->rq_disk->private_data;
71 int ret;
72
73 blk_mq_start_request(req); /* 开启处理队列 */
74 spin_lock(&dev->lock);
75 ret = ramdisk_transfer(req); /* 处理数据 */
76 blk_mq_end_request(req, ret); /* 结束处理队列 */
77 spin_unlock(&dev->lock);
78
79 return BLK_STS_OK;
80
81 }
82 /*
83 * 队列操作函数
84 */
85 static struct blk_mq_ops mq_ops = {
86 .queue_rq = _queue_rq,
87 };
88
89 /*
90 * @description : 打开块设备
91 * @param - dev : 块设备
92 * @param - mode : 打开模式
93 * @return : 0 成功;其他 失败
94 */
95 int ramdisk_open(struct block_device *dev, fmode_t mode)
96 {
97 printk("ramdisk open\r\n");
98 return 0;
99 }
100
101 /*
102 * @description : 释放块设备
103 * @param - disk : gendisk
104 * @param - mode : 模式
105 * @return : 0 成功;其他 失败
106 */
107 void ramdisk_release(struct gendisk *disk, fmode_t mode)
108 {
109 printk("ramdisk release\r\n");
110 }
111
112 /*
113 * @description : 获取磁盘信息
114 * @param - dev : 块设备
115 * @param - geo : 模式
116 * @return : 0 成功;其他 失败
117 */
118 int ramdisk_getgeo(struct block_device *dev, struct hd_geometry *geo)
119 {
120 /* 这是相对于机械硬盘的概念 */
121 geo->heads = 2; /* 磁头 */
122 geo->cylinders = 32; /* 柱面 */
123 geo->sectors = RAMDISK_SIZE / (2 * 32 *512); /* 一个磁道上的扇区数量 */
124 return 0;
125 }
126
127 /*
128 * 块设备操作函数
129 */
130 static struct block_device_operations ramdisk_fops =
131 {
132 .owner = THIS_MODULE,
133 .open = ramdisk_open,
134 .release = ramdisk_release,
135 .getgeo = ramdisk_getgeo,
136 };
137
138 /*
139 * @description : 初始化队列相关操作
140 * @set : blk_mq_tag_set对象
141 * @return : request_queue的地址
142 */
143 static struct request_queue * create_req_queue(struct blk_mq_tag_set *set)
144 {
145 struct request_queue *q;
146
147 #if 0
148
149 /*
150 *这里是使用了blk_mq_init_sq_queue 函数
151 *进行初始化的。
152 */
153 q = blk_mq_init_sq_queue(set, &mq_ops, 2, BLK_MQ_F_SHOULD_MERGE);
154
155 #else
156 int ret;
157
158 memset(set, 0, sizeof(*set));
159 set->ops = &mq_ops; //操作函数
160 set->nr_hw_queues = 2; //硬件队列
161 set->queue_depth = 2; //队列深度
162 set->numa_node = NUMA_NO_NODE;//numa节点
163 set->flags = BLK_MQ_F_SHOULD_MERGE; //标记在bio下发时需要合并
164
165 ret = blk_mq_alloc_tag_set(set); //使用函数进行再次初始化
166 if (ret) {
167 printk(KERN_WARNING "sblkdev: unable to allocate tag set\n");
168 return ERR_PTR(ret);
169 }
170
171 q = blk_mq_init_queue(set); //分配请求队列
172 if(IS_ERR(q)) {
173 blk_mq_free_tag_set(set);
174 return q;
175 }
176 #endif
177
178 return q;
179 }
180
181 /*
182 * @description : 创建块设备，为应用层提供接口。
183 * @set : ramdisk_dev对象
184 * @return : 0，表示成功;其它值为失败
185 */
186 static int create_req_gendisk(struct ramdisk_dev *set)
187 {
188 struct ramdisk_dev *dev = set;
189
190 /* 1、分配并初始化 gendisk */
191 dev->gendisk = alloc_disk(RADMISK_MINOR);
192 if(dev == NULL)
193 return -ENOMEM;
194
195 /* 2、添加(注册)disk */
196 dev->gendisk->major = ramdisk->major; /* 主设备号 */
197 dev->gendisk->first_minor = 0; /* 起始次设备号 */
198 dev->gendisk->fops = &ramdisk_fops; /* 操作函数 */
199 dev->gendisk->private_data = set; /* 私有数据 */
200 dev->gendisk->queue = dev->queue; /* 请求队列 */
201 sprintf(dev->gendisk->disk_name, RAMDISK_NAME); /* 名字 */
202 set_capacity(dev->gendisk, RAMDISK_SIZE/512); /* 设备容量(单位为扇区)*/
203 add_disk(dev->gendisk);
204 return 0;
205 }
206
207 /*
208 * @description : 驱动出口函数
209 * @param : 无
210 * @return : 无
211 */
212 static int __init ramdisk_init(void)
213 {
214 int ret = 0;
215 struct ramdisk_dev * dev;
216 printk("ramdisk init\r\n");
217
218 /* 1、申请内存 */
219 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
220 if(dev == NULL) {
221 return -ENOMEM;
222 }
223
224 dev->ramdiskbuf = kmalloc(RAMDISK_SIZE, GFP_KERNEL);
225 if(dev->ramdiskbuf == NULL) {
226 printk(KERN_WARNING "dev->ramdiskbuf: vmalloc failure.\n");
227 return -ENOMEM;
228 }
229 ramdisk = dev;
230
231 /* 2、初始化自旋锁 */
232 spin_lock_init(&dev->lock);
233
234 /* 3、注册块设备 */
235 dev->major = register_blkdev(0, RAMDISK_NAME); /* 由系统自动分配主设备号 */
236 if(dev->major < 0) {
237 goto register_blkdev_fail;
238 }
239
240 /* 4、创建多队列 */
241 dev->queue = create_req_queue(&dev->tag_set);
242 if(dev->queue == NULL) {
243 goto create_queue_fail;
244 }
245
246 /* 5、创建块设备 */
247 ret = create_req_gendisk(dev);
248 if(ret < 0)
249 goto create_gendisk_fail;
250
251 return 0;
252
253 create_gendisk_fail:
254 blk_cleanup_queue(dev->queue);
255 blk_mq_free_tag_set(&dev->tag_set);
256 create_queue_fail:
257 unregister_blkdev(dev->major, RAMDISK_NAME);
258 register_blkdev_fail:
259 kfree(dev->ramdiskbuf);
260 kfree(dev);
261 return -ENOMEM;
262 }
263
264 /*
265 * @description : 驱动出口函数
266 * @param : 无
267 * @return : 无
268 */
269 static void __exit ramdisk_exit(void)
270 {
271
272 printk("ramdisk exit\r\n");
273 /* 释放gendisk */
274 del_gendisk(ramdisk->gendisk);
275 put_disk(ramdisk->gendisk);
276
277 /* 清除请求队列 */
278 blk_cleanup_queue(ramdisk->queue);
279
280 /* 释放blk_mq_tag_set */
281 blk_mq_free_tag_set(&ramdisk->tag_set);
282
283 /* 注销块设备 */
284 unregister_blkdev(ramdisk->major, RAMDISK_NAME);
285
286 /* 释放内存 */
287 kfree(ramdisk->ramdiskbuf);
288 kfree(ramdisk);
289 }
290
291 module_init(ramdisk_init);
292 module_exit(ramdisk_exit);
293 MODULE_LICENSE("GPL");
294 MODULE_AUTHOR("ALIENTEK");
295 MODULE_INFO(intree, "Y");
第19~21行，实验相关宏定义，RAMDISK_SIZE就是模拟块设备的大小，这里设置为2MB，也就是说本实验中的虚拟块设备大小为 2MB。RAMDISK_NAME 为本实验名字，RADMISK_MINOR 是本实验此设备号数量，注意不是次设备号！此设备号数量决定了本块设备的磁盘分区数量。
第24~31行，ramdisk的设备结构体。
第33行，定义一个全局变量ramdisk_dev类型的指针。
ramdisk_init 和 ramdisk_exit 这两个函数分别为驱动入口以及出口函数，我们依次来看一下这两个函数。
第219行，先给自定义的ramdisk结构体申请空间。
第224行，因为本实验是使用一块内存模拟真实的块设备，因此这里先使用 kzalloc 函数申请用于 ramdisk 实验的内存，大小为 2MB。
第232行，初始化一个自旋锁，用于在队列操作的时候做保护。
第235行，使用 register_blkdev 函数向内核注册一个块设备，返回值就是注册成功的块设备主设备号。这里我们让内核自动分配一个主设备号，因此 register_blkdev 函数的第一个参数为 0。
第241行，create_req_queue函数用于创建一个多队列。这一部分主要用于操作块设备，后面会讲解此函数。
第247行，create_req_gendisk函数用于创建一个块设备和提供一些接口给应用层调用，后面会讲解此函数。
ramdisk_exit函数就比较简单了，在卸载块设备驱动模块的时候需要将前面注册的对象进行卸载、实例化的对象要进行释放。
第156~175行，初始化多队列。在159行到163行里先设置多队列的重要参数，比如一些操作函数、队列深度、硬件队列个数和标志位等等；其中第159行设置blk_mq_tag_set的ops成员变量，这就是块设备的队列操作集，这里设置为mq_ops，需要驱动开发人员自行编写实现，后面讲解。使用blk_mq_alloc_tag_set函数进行再次初始化blk_mq_tag_set对象，最后我们根据此对象分配请求队列。我们也可以使用blk_mq_init_sq_queue函数一步到位，第一个参数为blk_mq_tag_set对象、第二个参数为操作函数集合、第三个参数为硬件队列个数，第四个参数为标志位。
第191行，使用alloc_disk分配一个gendisk。
第196~201行，初始化申请到的gendisk对象，重点第208行设置geddisk的fops成员变量，fops负责设置块设备的操作集。第210行设置我们的多队列。
第202行，使用set_capacity函数设置本块设备容量大小，注意这里的大小是扇区数，不是字节数，一个扇区是512字节。
第203行，gendisk初始化完成以后就可以使用add_disk函数将gendisk添加到内核中，也就是向内核添加一个磁盘设备
第4587行就是多队列的操作集blk_mq_os，这里我们只是实现了queue_rq，第6781行就是queue_rq的具体实现；第79行通过blk_mq_queue_data的rq成员获取到request，第73行使用blk_mq_start_request函数开启多队列处理，第75行就是我们自定义的处理数据函数ramdisk_transfer，第76行就是我们通过blk_mq_end_request函数去结束多队列处理。
ramdisk_transfer数据处理函数，第42行blk_rq_pos函数获取要操作的块设备扇区地址，第43行使用blk_rq_cur_bytes函数获取请求要操作的数据长度，第50行使用bio_data函数获取请求中的bio保存的数据。第52~55行rq_data_dio函数判断当前是读还是写，如果是写的话就将bio中的数据拷贝到ramdisk指定地址(扇区)，如果是读的话就从ramdisk中的指定打字(扇区)读取数据放到bio中。
这里就简单总结一下块设备的编写步骤，首先有两个重要的结构体：blk_mq_tag_set和gendisk。可以把blk_mq_tag_set看作真正的IO读写操作(ops操作集就是IO操作)，有了底层操作还不行，还需要gendisk结构体为上层提供接口调用(fops就是实现上层调用的操作)。代码当中注释已经非常清楚了，这里就不给大家解释了。
35.3.2 运行测试
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为“miscled.o”，Makefile内容如下所示：
示例代码35.3.2.1 Makefile文件
1 KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
......
4 obj-m := ramdisk_withrequest.o
......
11 clean:
12 $(MAKE) -C
(
K
E
R
N
E
L
D
I
R
)
M
=
(KERNELDIR) M=
(KERNELDIR)M=(CURRENT_PATH) clean
第4行，设置obj-m变量的值为“ramdisk_withrequest.o”。
输入如下命令编译出驱动模块文件：
make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“ramdisk_withrequest.ko”的驱动模块文件。
2、运行测试
在Ubuntu中将上一小节编译出来的ramdisk_withrequest.ko通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push ramdisk_withrequest.ko keyinputApp /lib/modules/4.19.232
接下来输入如下命令加载keyinput.ko这个驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe ramdisk_withrequest //加载驱动模块
正常加载驱动就会有如下所示：
图35.3.2.1 加载randisk_withrequest驱动
3、查看ramdisk磁盘
驱动加载成功之后就会在/dev/目录下生成一个名为“ramdisk”的设备，输入如下命令查看ramdisk磁盘信息：
fdisk -l //查看磁盘信息
上述命令会将当前系统中所有的磁盘信息都打印出来，其中包括了ramdisk设备，如图35.3.2.2所示：
图35.3.2.2 ramdisk磁盘信息
从图35.3.2.2可以看出，ramdisk已经识别出来了，大小为2MB，但同时也提示/dev/ramdisk没有分区表，因为我们还没格式化/dev/ramdisk。这里注意一下：2MB等于2097152bytes，图上是20971XX52bytes，这是是因为串口终端输出和内核打印日志重叠而出现的问题。我们可以使用另外一种方法来查看，如下图35.3.2.3操作：
图35.3.2.3 log.txt磁盘信息
4、格式化/dev/ramdisk
使用mkfs.vfat命令格式化/dev/ramdisk，将其格式化为vfat格式，输入如下命令：
mkfs.vfat /dev/ramdisk
格式化完成以后就可以挂载/dev/ramdisk来访问了，挂载点可以自定义，这里笔者就将其挂载到/mnt目录下，输入如下命令：
mkdir /mnt/ram_disk -p //创建ramdisk挂载目录
mount /dev/ramdisk /mnt/ram_disk //挂载ramdisk
挂载成功以后就可以通过/mnt来访问ramdisk这个磁盘了，进入到/mnt目录中，可以通过vi命令新建一个txt文件来测试磁盘访问是否正常。
35.4 不使用请求队列实验
35.4.1 实验程序编写
本实验对应的例程路径为：开发板光盘1、程序源码3、Linux驱动例程 22_ramdisk_norequest。
前面我们学习了如何使用请求队列，请求队列会用到 I/O 调度器，适合机械硬盘这种存储设备。对于 EMMC、SD、ramdisk 这样没有机械结构的存储设备，我们可以直接访问任意一个扇区，因此可以不需要 I/O 调度器，也就不需要请求队列了，这个我们前面已经说过了。本实验就来学习一下如何使用“制造请求”方法，本实验在上一个实验的基础上修改而来，首先是驱动入口函数 ramdisk_init，ramdisk_init 函数大部分和上一个实验相同，我们只需要把blk_mq_tag_set相关的都删除掉，然后修改create_req_queue函数即可，在此函数里使用create_req_queue函数设置“制造请求”函数，修改后的create_req_queue函数内容如下：
示例代码35.4.1.1 create_req_queue函数
130 static struct request_queue * create_req_queue(struct ramdisk_dev *dev)
131 {
132 struct request_queue *q;
133 /* 分配请求队列 */
134 q = blk_alloc_queue(GFP_KERNEL);
135
136 /* 设置“制造请求”函数 */
137 blk_queue_make_request(q, ramdisk_make_request_fn);
138
139 /* 保存dev 方便在ramdisk_make_request_fn函数使用 */
140 q->queuedata = dev;
141 return q;
142 }
create_req_queue函数与上一个实验不同的地方在于，这里使用blk_alloc_queue和blk_queue_make_request这两个函数取代了上一个实验中blk_mq_tag_set结构体相关的操作。
第134行，使用blk_alloc_queue函数申请一个请求队列。
第137行，使用blk_queue_make_request函数设置“制造请求”函数，这里设置的制造请求函数为ramdisk_make_request_fn，这个需要驱动编写人员去实现，稍后讲解。
第140行，保存我们自定义的ramdisk_dev结构体。
接下来重点看一下“制造请求”函数 ramdisk_make_request_fn，函数内容如下：
示例代码35.4.1.1 ramdisk_make_request_fn函数
99 static blk_qc_t ramdisk_make_request_fn(struct request_queue *q,
struct bio *bio)
100 {
101 int offset;
102 struct bio_vec bvec;
103 struct bvec_iter iter;
104 unsigned long len = 0;
105 struct ramdisk_dev *dev = q->queuedata;
106
107 offset = (bio->bi_iter.bi_sector) << 9;/* 获取偏移地址 */
108 spin_lock(&dev->lock);
109 /* 处理bio中的每个段 */
110 bio_for_each_segment(bvec, bio, iter){
111 char *ptr = page_address(bvec.bv_page) + bvec.bv_offset;
112 len = bvec.bv_len;
113
114 if(bio_data_dir(bio) == READ) /* 读数据 */
115 memcpy(ptr, dev->ramdiskbuf + offset, len);
116 else if(bio_data_dir(bio) == WRITE) /* 写数据 */
117 memcpy(dev->ramdiskbuf + offset, ptr, len);
118 offset += len;
119 }
120 spin_unlock(&dev->lock);
121 bio_endio(bio);
122 return BLK_QC_T_NONE;
123 }
虽然ramdisk_make_request_fn函数第一个参数依旧是请求队列，但是实际上这个请求队列不包含真正的请求，所有的处理内容都在第二个bio参数里面，所以ramdisk_make_request_fn函数里面是全部是对bio的操作。
第103行，直接读取bio的bi_iter成员变量的bi_sector来获取要操作的设备地址(扇区)。
第110~119行，使用bio_for_each_segment函数循环获取bio中的每个段，然后对其每个段进行处理。
第111行，根据bio_vec中页地址以及偏移地址转为真正的数据起始地址。
第112行，获取要出来的数据长度，也就是bio_vec的bv_len成员变量。
第114~117行，和上一个实验一样，要操作的块设备起始地址找到了，数据的存放地址以及长度也知道，接下来就是根据读写操作将数据从块设备中读出来，或者将数据写入到块设备中。
第121行，调用bio_endio函数，结束bio。
35.4.2 运行测试
测试方法和上一个实验一样，参考35.3小节即可。
扫一扫
786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
