Linux学习第50天：Linux块设备驱动实验（二）：Linux三大驱动之一

news2024/9/26 5:20:04

Linux版本号4.1.15 芯片I.MX6ULL 大叔学Linux 品人间百味思文短情长

三、使用请求队列实验

1.实验程序编写

使用开发板上的一段RAM来模拟一段块设备，也就是ramdisk.

机械硬盘

34 #define RAMDISK_SIZE (2 * 1024 * 1024) /* 容量大小为 2MB */
35 #define RAMDISK_NAME "ramdisk" /* 名字 */
36 #define RADMISK_MINOR 3 /* 表示三个磁盘分区！不是次设备号为 3！ */
37
38 /* ramdisk 设备结构体 */
39 struct ramdisk_dev{
40 int major; /* 主设备号 */
41 unsigned char *ramdiskbuf; /* ramdisk 内存空间,用于模拟块设备 */
42 spinlock_t lock; /* 自旋锁 */
43 struct gendisk *gendisk; /* gendisk */
44 struct request_queue *queue;/* 请求队列 */
45 };
46
47 struct ramdisk_dev ramdisk; /* ramdisk 设备 */

驱动模块的加载与卸载：

6 static int __init ramdisk_init(void)
7 {
8 int ret = 0;
9
10 /* 1、申请用于 ramdisk 内存 */
11 ramdisk.ramdiskbuf = kzalloc(RAMDISK_SIZE, GFP_KERNEL);
12 if(ramdisk.ramdiskbuf == NULL) {
13 ret = -EINVAL;
14 goto ram_fail;
15 }
16
17 /* 2、初始化自旋锁 */
18 spin_lock_init(&ramdisk.lock);
19
20 /* 3、注册块设备 */
21 ramdisk.major = register_blkdev(0, RAMDISK_NAME); /* 自动分配 */
22 if(ramdisk.major < 0) {
23 goto register_blkdev_fail;
24 }
25 printk("ramdisk major = %d\r\n", ramdisk.major);
26
27 /* 4、分配并初始化 gendisk */
28 ramdisk.gendisk = alloc_disk(RADMISK_MINOR);
29 if(!ramdisk.gendisk) {
30 ret = -EINVAL;
31 goto gendisk_alloc_fail;
32 }
33
34 /* 5、分配并初始化请求队列 */
35 ramdisk.queue = blk_init_queue(ramdisk_request_fn,
&ramdisk.lock);
36 if(!ramdisk.queue) {
37 ret = EINVAL;
38 goto blk_init_fail;
39 }
40
41 /* 6、添加(注册)disk */
42 ramdisk.gendisk->major = ramdisk.major; /* 主设备号 */
43 ramdisk.gendisk->first_minor = 0; /*起始次设备号) */
44 ramdisk.gendisk->fops = &ramdisk_fops; /* 操作函数 */
45 ramdisk.gendisk->private_data = &ramdisk; /* 私有数据 */
46 ramdisk.gendisk->queue = ramdisk.queue; /* 请求队列 */
47 sprintf(ramdisk.gendisk->disk_name, RAMDISK_NAME);/* 名字 */
48 set_capacity(ramdisk.gendisk, RAMDISK_SIZE/512); /* 设备容量(单位
为扇区)*/
49 add_disk(ramdisk.gendisk);
50
51 return 0;
52
53 blk_init_fail:
54 put_disk(ramdisk.gendisk);
55 gendisk_alloc_fail:
56 unregister_blkdev(ramdisk.major, RAMDISK_NAME);
57 register_blkdev_fail:
58 kfree(ramdisk.ramdiskbuf); /* 释放内存 */
59 ram_fail:
60 return ret;
61 }
62
63 /*
64 * @description : 驱动出口函数
65 * @param : 无
66 * @return : 无
67 */
68 static void __exit ramdisk_exit(void)
69 {
70 /* 释放 gendisk */
71 put_disk(ramdisk.gendisk);
72 del_gendisk(ramdisk.gendisk);
73
74 /* 清除请求队列 */
75 blk_cleanup_queue(ramdisk.queue);
76

77 /* 注销块设备 */
78 unregister_blkdev(ramdisk.major, RAMDISK_NAME);
79
80 /* 释放内存 */
81 kfree(ramdisk.ramdiskbuf);
82 }
83
84 module_init(ramdisk_init);
85 module_exit(ramdisk_exit);
86 MODULE_LICENSE("GPL");
87 MODULE_AUTHOR("zuozhongkai");

块设备的操作集：

1 /*
2 * @description : 打开块设备
3 * @param - dev : 块设备
4 * @param - mode : 打开模式
5 * @return : 0 成功;其他 失败
6 */
7 int ramdisk_open(struct block_device *dev, fmode_t mode)
8 {
9 printk("ramdisk open\r\n");
10 return 0;
11 }
12
13 /*
14 * @description : 释放块设备
15 * @param - disk : gendisk
16 * @param - mode : 模式
17 * @return : 0 成功;其他 失败
18 */
19 void ramdisk_release(struct gendisk *disk, fmode_t mode)
20 {
21 printk("ramdisk release\r\n");
22 }
23
24 /*
25 * @description : 获取磁盘信息
26 * @param - dev : 块设备
27 * @param - geo : 模式
28 * @return : 0 成功;其他 失败
29 */
30 int ramdisk_getgeo(struct block_device *dev,
struct hd_geometry *geo)
31 {
32 /* 这是相对于机械硬盘的概念 */
33 geo->heads = 2; /* 磁头 */
34 geo->cylinders = 32; /* 柱面 */
35 geo->sectors = RAMDISK_SIZE / (2 * 32 *512); /* 磁道上的扇区数量 */
36 return 0;
37 }
38
39 /*
40 * 块设备操作函数
41 */
42 static struct block_device_operations ramdisk_fops =
43 {
44 .owner = THIS_MODULE,
45 .open = ramdisk_open,
46 .release = ramdisk_release,
47 .getgeo = ramdisk_getgeo,
48 };

getgeo函数获取磁盘信息，信息保存在参数geo中，为结构体hd_geometry类型：

1 struct hd_geometry {
2 unsigned char heads; /* 磁头 */
3 unsigned char sectors; /*一个磁道上的扇区数量 */
4 unsigned short cylinders; /* 柱面 */
5 unsigned long start;
6 };

请求处理函数：从块设备中读取数据，或向块设备中写入数据。

1 /*
2 * @description : 处理传输过程
3 * @param-req : 请求
4 * @return : 无
5 */
6 static void ramdisk_transfer(struct request *req)
7 {
8 unsigned long start = blk_rq_pos(req) << 9; /* blk_rq_pos 获取到的是
扇区地址，左移 9 位转换为字节地址 */
9 unsigned long len = blk_rq_cur_bytes(req); /* 大小 */
10
11 /* bio 中的数据缓冲区
12 * 读：从磁盘读取到的数据存放到 buffer 中
13 * 写： buffer 保存这要写入磁盘的数据
14 */
15 void *buffer = bio_data(req->bio);
16
17 if(rq_data_dir(req) == READ) /* 读数据 */
18 memcpy(buffer, ramdisk.ramdiskbuf + start, len);
19 else if(rq_data_dir(req) == WRITE) /* 写数据 */
20 memcpy(ramdisk.ramdiskbuf + start, buffer, len);
21
22 }
23
24 /*
25 * @description : 请求处理函数
26 * @param-q : 请求队列
27 * @return : 无
28 */
29 void ramdisk_request_fn(struct request_queue *q)
30 {
31 int err = 0;
32 struct request *req;
33
34 /* 循环处理请求队列中的每个请求 */
35 req = blk_fetch_request(q);
36 while(req != NULL) {
37
38 /* 针对请求做具体的传输处理 */
39 ramdisk_transfer(req);
40
41 /* 判断是否为最后一个请求，如果不是的话就获取下一个请求
42 * 循环处理完请求队列中的所有请求。
43 */
44 if (!__blk_end_request_cur(req, err))
45 req = blk_fetch_request(q);
46 }
47 }

2.运行测试

输入如下命令加载 ramdisk.ko 这个驱动模块。

depmod //第一次加载驱动的时候需要运行此命令
modprobe ramdisk.ko //加载驱动模块

参看ramdisk磁盘：

fdisk -l //查看磁盘信息

格式化/dev/ramdisk：

mkfs.vfat /dev/ramdisk

格式化以后就可以挂载访问：

mount /dev/ramdisk /tmp

四、不使用请求队列实验

1.实验程序编写

ramdisk_init 函数：

1 static int __init ramdisk_init(void)
2 {
......
29
30 /* 5、分配请求队列 */
31 ramdisk.queue = blk_alloc_queue(GFP_KERNEL);
32 if(!ramdisk.queue){
33 ret = -EINVAL;
34 goto blk_allo_fail;
35 }
36
37 /* 6、设置“制造请求”函数 */
38 blk_queue_make_request(ramdisk.queue, ramdisk_make_request_fn);
39
40 /* 7、添加(注册)disk */
41 ramdisk.gendisk->major = ramdisk.major; /* 主设备号 */
42 ramdisk.gendisk->first_minor = 0; /* 起始次设备号 */
43 ramdisk.gendisk->fops = &ramdisk_fops; /* 操作函数 */
44 ramdisk.gendisk->private_data = &ramdisk; /* 私有数据 */
45 ramdisk.gendisk->queue = ramdisk.queue; /* 请求队列 */
46 sprintf(ramdisk.gendisk->disk_name, RAMDISK_NAME); /* 名字 */
47 set_capacity(ramdisk.gendisk, RAMDISK_SIZE/512); /* 设备容量*/
48 add_disk(ramdisk.gendisk);
49
......
60 return ret;
61 }

“制造请求”函数 ramdisk_make_request_fn：ramdisk_make_request_fn函数里面是全部是对 bio 的操作：

1 /*
2 * @description : “制造请求”函数
3 * @param-q : 请求队列
4 * @return : 无
5 */
6 void ramdisk_make_request_fn(struct request_queue *q,
struct bio *bio)
7 {
8 int offset;
9 struct bio_vec bvec;
10 struct bvec_iter iter;
11 unsigned long len = 0;
12
13 offset = (bio->bi_iter.bi_sector) << 9; /* 获取设备的偏移地址 */
//直接读取 bio 的 bi_iter 成员变量的 bi_sector 来获取要操作的设备地址(扇区)。
14
15 /* 处理 bio 中的每个段 */
16 bio_for_each_segment(bvec, bio, iter){/*使用 bio_for_each_segment 函数循环获取 bio 中的每个段，然后对其每个段进
行处理。*/
17 char *ptr = page_address(bvec.bv_page) + bvec.bv_offset;/*根据 bio_vec 中页地址以及偏移地址转换为真正的数据起始地址。*/
18 len = bvec.bv_len;/*获取要处理的数据长度，也就是 bio_vec 的 bv_len 成员变量。*/
19
20 if(bio_data_dir(bio) == READ) /* 读数据 */
21 memcpy(ptr, ramdisk.ramdiskbuf + offset, len);
22 else if(bio_data_dir(bio) == WRITE) /* 写数据 */
23 memcpy(ramdisk.ramdiskbuf + offset, ptr, len);
24 offset += len;
25 }
26 set_bit(BIO_UPTODATE, &bio->bi_flags);
27 bio_endio(bio, 0);/*调用 bio_endio 函数，结束 bio。*/
28 }