块设备驱动、bio理解

别人写过的内容,我就不写了。贴一下大佬的博客,写的非常好:

  1. 块设备驱动实战基础篇一 (170行代码构建一个逻辑块设备驱动)

  2. 块设备驱动实战基础篇二 (继续完善170行过滤驱动代码至200行)

  3. 块设备驱动实战基础篇三 (BIO请求回调机制)

  4. 块设备驱动实战基础篇四 (逐渐成型,加入ioctl通信机制)

较遗憾的是,该博主的 块设备驱动实战高级篇 自2013年后就未更新了,可能有更重要的事忙。

复制进去的demo代码,直接编译会报错,做了轻微改动。我的实验环境如下:

系统:ubuntu 16.04

内核:4.15.0-122-generic

架构:x86-64

1. 编译生成demo

创建头文件:

vim fbd_device.h

fbd_device.h 的内容如下:

#ifndef  _FBD_DRIVER_H
#define  _FBD_DRIVER_H

#include <linux/init.h>
#include <linux/module.h>		/* 写内核模块都需要包含该头文件 */
#include <linux/blkdev.h>		/* 写内核块设备驱动必须要包含的三个头文件:blkdev.h, bio.h, genhd.h */
#include <linux/bio.h>
#include <linux/genhd.h>

#define SECTOR_BITS             (9)		/* 用来表示扇区的比特数,对于块设备,扇区是其最小的传输和存储单元,默认扇区大小是512字节,这里的9代表将512换算为二进制需要多少位描述,很快可以算出来:2^9 = 512 */
#define DEV_NAME_LEN            32		/* 过滤块设备的名字最长为32个字节 */
#define DEV_SIZE                (512UL<< 20)   /* 过滤块设备大小是512M,1左移20位是1M,再乘以扇区大小即为512M */

#define DRIVER_NAME            "filter driver"	/* 给驱动程序注册的名字"fbd_driver" */

#define DEVICE1_NAME           "fbd1_dev"		/* 过滤块设备驱动程序创建的过滤块设备名字"fbd1_dev" */
#define DEVICE1_MINOR           0
#define DEVICE2_NAME           "fbd2_dev"		/* 过滤块设备驱动程序创建的过滤块设备名字"fbd2_dev" */
#define DEVICE2_MINOR           1

struct fbd_dev {		/* 结构体fbd_dev,三个成员:queue指针成员,disk指针,设备大小,该结构体描述我们创建的过滤块设备 */
  struct request_queue *queue;
  struct gendisk *disk;
  sector_t size;          /* device size in Bytes */
};

#endif

创建主要代码文件:

vim fbd_device.c

fbd_device.c 的内容如下:

/**
 *  fbd-driver - filter block device driver
 *  Author: Talk@studio
 *  Modified by abin
 **/
 
#include "fbd_driver.h"

static int fbd_driver_major = 0;

static struct fbd_dev fbd_dev1 = {NULL};
static struct fbd_dev fbd_dev2 = {NULL};

static int fbddev_open(struct inode *inode, struct file *file);
static int fbddev_close(struct inode *inode, struct file *file);

static struct block_device_operations disk_fops = {
  .open = (void *)fbddev_open,
  .release = (void *)fbddev_close,
  .owner = THIS_MODULE,
};

/* 块设备被打开时调用该函数 */
static int fbddev_open(struct inode *inode, struct file *file)
{
  printk("device is opened by:[%s]\n", current->comm);
  return 0;
}

/* 块设备被关闭时调用该函数 */
static int fbddev_close(struct inode *inode, struct file *file)
{
  printk("device is closed by:[%s]\n", current->comm);
  return 0;
}

/* 仓库的加工函数,在dev_create中被调用 */
static int make_request(struct request_queue *q, struct bio *bio)		//参数1是我们的关卡请求队列,参数2是上层准备好的盒子bio请求描述结构体指针
{
  struct fbd_dev *dev = (struct fbd_dev *)q->queuedata;

  printk("device [%s] recevied [%s] io request, "
         "access on dev sector[%llu], length is [%u] sectors.\n",
         dev->disk->disk_name,
         bio_data_dir(bio) == READ ?"read" : "write",
         (long long)bio->bi_iter.bi_sector,
         bio_sectors(bio));

  bio_endio(bio);		//结束一个bio请求

  return 0;
}

/* 创建过滤设备的函数,在init函数中被调用 */
static int dev_create(struct fbd_dev *dev, char *dev_name, int major, int minor)
{
  int ret = 0;

  /* init fbd_dev */
  dev->size = DEV_SIZE;

  dev->disk = alloc_disk(1);		/* 申请仓库gendisk,返回值为gendisk结构体 */
  if (!dev->disk) {
    printk("alloc diskerror");
    ret = -ENOMEM;
    goto err_out1;
  }

  dev->queue = blk_alloc_queue(GFP_KERNEL);		/* 建立关卡,关卡申请后,可以用也可以不用,但必须申请 */

  if (!dev->queue) {
    printk("alloc queueerror");
    ret = -ENOMEM;
    goto err_out2;
  }

  /* init queue */
  blk_queue_make_request(dev->queue, (void *)make_request);		/* 仓库加工函数,即:请求处理函数make_request,第一参数是刚申请到的请求队列,第二个参数是我们写好的make_request函数名 */
  dev->queue->queuedata = dev;

  /* init gendisk */
  strncpy(dev->disk->disk_name, dev_name, DEV_NAME_LEN);	/* 给gendisk的disk_name成员赋值,也就是给仓库取名字 */
  dev->disk->major = major;		/* 把申请到的门牌号赋值给disk的成员major */
  dev->disk->first_minor = minor;	/* 赋值了一个次设备号 */
  dev->disk->fops = &disk_fops;		/* 为gendisk的文件操作函数赋值了一个函数指针集结构体 */
  set_capacity(dev->disk, (dev->size >> SECTOR_BITS));	/* 设置设备的容量大小为512M */

  /* bind queue to disk */
  dev->disk->queue =dev->queue;		/* 把申请的queue地址保存在disk中,这样仓库和关卡就绑定在一起了 */

  /* add disk to kernel */
  add_disk(dev->disk);	/*告诉内核我们的仓库需要审核一下,如果通过,那仓库就建好了 */
  return 0;

err_out2:
  put_disk(dev->disk);
err_out1:
  return ret;
}

static void dev_delete(struct fbd_dev *dev, char *name)
{
  printk("delete the device [%s]!\n", name);

  blk_cleanup_queue(dev->queue);
  del_gendisk(dev->disk);
  put_disk(dev->disk);
}

/* 内核模块入口,也是构建块设备驱动的核心部分 */
static int __init fbd_driver_init(void)
{
  int ret;

  /* register fbd driver, get the driver major number */
  fbd_driver_major =register_blkdev(fbd_driver_major, DRIVER_NAME);		/* 第一个参数是初始化的major号,第二参数是块设备驱动的名字。第一参数0时,系统会从它自己管理的情况表上查找是否有可用的号码,如果有就分配,作为regiser_blkdev的返回值 */

  if (fbd_driver_major < 0) {
    printk("get majorfail");
    ret = -EIO;
    goto err_out1;
  }

  /* create the first device */
  ret = dev_create(&fbd_dev1, DEVICE1_NAME, fbd_driver_major,DEVICE1_MINOR);

  if (ret) {
    printk("create device[%s] failed!\n", DEVICE1_NAME);
    goto err_out2;
  }

  /* create the second device */
  ret = dev_create(&fbd_dev2, DEVICE2_NAME, fbd_driver_major,DEVICE2_MINOR);

  if (ret) {
    printk("create device[%s] failed!\n", DEVICE2_NAME);
    goto err_out3;
  }
  return ret;

err_out3:
  dev_delete(&fbd_dev1, DEVICE1_NAME);
err_out2:
  unregister_blkdev(fbd_driver_major, DRIVER_NAME);
err_out1:
  return ret;
}

static void __exit fbd_driver_exit(void)
{
  /* delete the two devices */
  dev_delete(&fbd_dev2, DEVICE2_NAME);
  dev_delete(&fbd_dev1, DEVICE1_NAME);

  /* unregister fbd driver */
  unregister_blkdev(fbd_driver_major,DRIVER_NAME);
  printk("block device driver exit successfuly!\n");
}

module_init(fbd_driver_init);
module_exit(fbd_driver_exit);
MODULE_LICENSE("GPL");

创建Makefile文件:

vim Makefile

Makefile 文件的内容:

obj-m := fbd_driver.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

default:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean
	rm -rf Module.markers modules.order Module.symvers

编译块设备,生成内核模块:

make

make -C /lib/modules/4.15.0-122-generic/build M=/home/abin/Desktop/share/abin_files/bio modules

make[1]: Entering directory '/usr/src/linux-headers-4.15.0-122-generic'

CC [M] /home/abin/Desktop/share/abin_files/bio/fbd_driver.o

Building modules, stage 2.

MODPOST 1 modules

CC /home/abin/Desktop/share/abin_files/bio/fbd_driver.mod.o

LD [M] /home/abin/Desktop/share/abin_files/bio/fbd_driver.ko

make[1]: Leaving directory '/usr/src/linux-headers-4.15.0-122-generic'

ls -l

-rw-rw-r-- 1 abin abin 4255 Nov 12 20:22 fbd_driver.c

-rw-rw-r-- 1 abin abin 667 Nov 12 16:59 fbd_driver.h

-rw-rw-r-- 1 abin abin 8144 Nov 12 20:30 fbd_driver.ko

-rw-rw-r-- 1 abin abin 603 Nov 12 20:30 fbd_driver.mod.c

-rw-rw-r-- 1 abin abin 2584 Nov 12 20:30 fbd_driver.mod.o

-rw-rw-r-- 1 abin abin 7856 Nov 12 20:30 fbd_driver.o

-rw-rw-r-- 1 abin abin 229 Nov 12 20:09 Makefile

-rw-rw-r-- 1 abin abin 61 Nov 12 20:30 modules.order

-rw-rw-r-- 1 abin abin 0 Nov 12 20:30 Module.symvers

其中,fbd_driver.ko 是编译好的内核模块,也就是块设备。

2. 运行demo

加载内核模块:

sudo insmod fbd_driver.ko
dmesg

[337420.127568] device is opened by:[systemd-udevd]

[337420.127695] device is opened by:[systemd-udevd]

[337420.166190] device is closed by:[systemd-udevd]

[337420.166208] device is closed by:[systemd-udevd]

ls -l /dev/fbd*

brw-rw---- 1 root disk 252, 0 Nov 13 09:08 /dev/fbd1_dev

brw-rw---- 1 root disk 252, 1 Nov 13 09:08 /dev/fbd2_dev

/dev/fbd1_dev/dev/fbd2_dev 是创建好的过滤块设备,下面使用dd命令来使用其中一个设备。

sudo dd if=/dev/zero of=/dev/fbd1_dev bs=1M oflag=direct count=1
dmesg

[337577.539057] device is opened by:[dd]

[337577.539329] device [fbd1_dev] recevied [write] io request, access on dev sector[0], length is [2048] sectors.

[337577.539335] device is closed by:[dd]

第二行是在make_request函数中输出的,第一行是fbddev_open函数中输出的,第三行是fbddev_close函数中输出的。

3. 关键信息

块设备驱动程序做的四件事情:

序号 函数 功能
1 register_blk_device 注册并申请门牌号
2 alloc_disk 申请仓库
3 alloc_queue 申请仓库的关卡
4 blk_queue_make_request 注册仓库的加工处理函数

块设备核心数据结构:

结构体名称 结构体作用
gendisk 块设备仓库
hd_struct 块设备分区
block_device 文件系统层使用的块设备描述符
request_queue 仓库的关卡(请求队列)
request 包含多个bio的大请求
bio 单个请求

块设备核心API接口:

API名称 API作用
register_blkdev 注册并申请门牌号
alloc_disk 申请仓库
blk_alloc_queue 申请仓库的关卡
blk_queue_make_request 注册仓库的加工处理函数
add_disk 将申请的仓库注册到内核中,成为合法仓库

bio关键成员:

类型 字段 说明
dev_t bd_dev 块设备的主设备号和次设备号
struct inode* bd_inode 指向bdev文件系统中块设备对应的文件索引节点的指针
int bd_openers 计数器,统计块设备已经被打开了多少次
struct mutex bd_mutex 打开或关闭的互斥量
struct list_head bd_inodes 已打开的块设备文件的索引节点链表的首部
void* bd_holders 块设备描述符的当前所有者
struct block_device* bd_contains 如果块设备是一个分区,则指向整个磁盘的块设备描述符;否则,指向该块设备描述符
unsigned bd_block_size 块大小
struct hd_struct* bd_part 指向分区描述符的指针(如果该块设备不是一个分区,则为NULL)
unsigned bd_part_count 计数器,统计包含在块设备中的分区已经被打开了多少次
struct gendisk* bd_disk 指向块设备中基本磁盘的gendisk结构的指针
struct list_head bd_list 用于块设备描述符链表的指针
unsigned long bd_private 指向块设备持有者的私有数据的指针

hd_struct关键成员:

类型 字段 说明
sector_t start_sect 磁盘中分区的起始扇区
sector_t nr_sects 分区的长度(总共的扇区数)
int policy 如果分区是只读的,则置为1;否则为0
int partno 磁盘中分区的相对索引

gendisk关键成员:

类型 字段 说明
int major 磁盘主设备号, 每个块设备都有唯一的主设备号,在这个块设备上建立的分区都使用这个相同的主设备号。具有相同主设备号的设备,使用相同的驱动程序。
int first_minor 与磁盘关联的第一个次设备号。在某一个设备上首先创建的设备的初始次设备号为0,在名称中不显示,如sda;在这个设备上依次建立的其他设备,此设备号在0基础上依次加1,并在名称中显示,如sda1,sda2。
int minors 与磁盘关联的次设备号范围。规定了可以在这个设备上创建多少个分设备(分区)。当次设备号数量是1时,表示这个设备不能被分区。
char disk_name 磁盘的标准命名(通常是相应设备文件的规范名称)
struct hd_struct part0 磁盘的分区信息
const struct block_device_operations * fops 指向块设备操作函数集的指针
struct request_queue * queue 指向磁盘请求队列的指针
void * private_data 块设备驱动程序的私有数据
int flags 描述磁盘类型的标志

块设备gendisk fops函数指针集:

类型 方法 参数 触发操作
int (*open) struct block_device*, fmode_t 打开块设备文件,增加引用计数
int (*release) struct gendisk*, fmode_t 关闭对块设备文件的最后一个引用,减少引用计数
int (*ioctl) struct block_device*, fmode_t, unsigned,unsigned long 在块设备文件上发出ioctl()系统调用

request_queue请求队列描述符中的关键字段:

类型 字段 说明
struct list_head queue_head 待处理请求的链表
make_request_fn* make_request_fn 设备驱动程序的请求处理函数

request描述符的关键字段:

类型 字段 说明
struct list_head queuelist 请求队列链表的指针
struct bio* bio 请求中第一个没有完成传送操作的bio,不能直接对该成员进行访问;而要使用rq_for_each_bio访问
struct bio* biotail 请求链表中末尾的bio

bio结构中的关键字段:

类型 字段 说明
sector_t bi_sector 块I/O操作的第一个磁盘扇区
struct bio* bi_next 链接到请求队列中的下一个bio
struct block_device * bi_bdev 指向块设备描述符的指针
unsigned long bi_flags bio的状态标志
unsigned long bi_rw I/O操作标志
unsigned short bi_vcnt bio的bio_vec数组中段的数目
unsigned short bi_idx bio的bio_vec数组中段的当前索引值
unsigned int bi_phys_segments 合并之后bio中物理段的数目
unsigned int bi_size 需要传送的字节数
unsigned int bi_seg_front_size 第一个可合并的段大小
unsigned int bi_seg_back_size 最后一个可合并的段大小
unsigned int bi_max_vecs bio的bio_vec数组中允许的最大段数
struct bio_vec* bi_io_vec 指向bio的bio_vec数组中的段的指针
atomic_t bi_cnt bio的引用计数
bio_end_io_t* bi_end_io bio的I/O操作结束时调用的方法
void* bi_private 通用块层和块设备驱动程序的I/O完成方法使用的指针

bio_vec结构中的字段:

类型 字段 说明
struct page* bv_page 指向段的页框中页描述符的指针
unsigned int bv_len 段的字节长度
unsigned int bv_offset 页框中中段数据的偏移量

核心API函数:

函数名 输入参数 返回值 说明
int register_blkdev unsigned int major, const char* name 成功返回主设备号,失败返回一个负数。
struct gendisk* alloc_disk int minors 成功返回一个指向gendisk描述符的指针,失败返回NULL
struct request_queue* blk_alloc_queue gfp_t gfp_mask 成功返回一个指向request_queue的指针,失败时返回NULL
void blk_queue_make_request struct request_queue* q, make_request_fn* mfn 无返回
void add_disk struct gendisk *disk 无返回
void del_gendisk struct gendisk* disk 无返回
void put_disk struct gendisk* disk 无返回
void unregister_blkdev unsigned int major, const char *name 无返回
void blk_cleanup_queue struct request_queue *q 无返回
void bio_endio struct bio *bio, int error 无返回

4. 完善代码(加入bio过滤功能)

Makefile文件不变,fbd_driver.h 内容如下:

#ifndef  _FBD_DRIVER_H
#define  _FBD_DRIVER_H

#include <linux/init.h>
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/bio.h>
#include <linux/genhd.h>


#define SECTOR_BITS             (9)
#define DEV_NAME_LEN            32

#define DRIVER_NAME            "filter driver"

#define DEVICE1_NAME           "fbd1_dev"
#define DEVICE1_MINOR           0
#define DEVICE2_NAME           "fbd2_dev"
#define DEVICE2_MINOR           1


struct fbd_dev {
  struct request_queue *queue;
  struct gendisk *disk;
  sector_t size;          /* devicesize in Bytes */
	
  /* new code */
  char lower_dev_name[DEV_NAME_LEN];
  struct block_device *lower_bdev;
};

#endif

size记录将来要创建的fbd_dev设备的容量大小,该容量需要保持与fbd_dev底层设备大小一致,lower_dev_name记录了底层设备的文件名字,lower_bdev保存着底层设备的block_device描述符。

fbd_driver.c内容如下:

/**
 *  fbd-driver - filter block device driver
 *  Author: Talk@studio
 *  Modified by abin
 **/
 
#include "fbd_driver.h"

static int fbd_driver_major = 0;

/* new code */
static struct fbd_dev fbd_dev1 = {
  .queue = NULL,
  .disk = NULL,
  .lower_dev_name = "/dev/sdb",
  .lower_bdev = NULL,
  .size = 0
};
/* new code */
static struct fbd_dev fbd_dev2 = {
  .queue = NULL,
  .disk = NULL,
  .lower_dev_name = "/dev/sdc",
  .lower_bdev = NULL,
  .size = 0
};

static int fbddev_open(struct inode *inode, struct file *file);
static int fbddev_close(struct inode *inode, struct file *file);

static struct block_device_operations disk_fops = {
  .open = (void *)fbddev_open,
  .release = (void *)fbddev_close,
  .owner = THIS_MODULE,
};

/* 块设备被打开时调用该函数 */
static int fbddev_open(struct inode *inode, struct file *file)
{
  printk("device is opened by:[%s]\n", current->comm);
  return 0;
}

/* 块设备被关闭时调用该函数 */
static int fbddev_close(struct inode *inode, struct file *file)
{
  printk("device is closed by:[%s]\n", current->comm);
  return 0;
}

/* 仓库的加工函数,在dev_create中被调用 */
static int make_request(struct request_queue *q, struct bio *bio)		/* 参数1是我们的关卡请求队列,参数2是上层准备好的盒子bio请求描述结构体指针 */
{
  struct fbd_dev *dev = (struct fbd_dev *)q->queuedata;

  printk("device [%s] recevied [%s] io request, "
         "access on dev sector[%llu], length is [%u] sectors.\n",
         dev->disk->disk_name,
         bio_data_dir(bio) == READ ?"read" : "write",
         (long long)bio->bi_iter.bi_sector,
         bio_sectors(bio));

  /* new code */
  /* bio->bi_bdev = dev->lower_bdev; */
  bio_set_dev(bio, dev->lower_bdev);	/* 告诉bio请求的下一站是下层设备,即: dev->lower_bdev */
  submit_bio(bio);		/* 提交bio请求 */

  return 0;
}

/* 创建过滤设备的函数,在init函数中被调用 */
static int dev_create(struct fbd_dev *dev, char *dev_name, int major, int minor)
{
  int ret = 0;

  /* init fbd_dev */
  dev->size = DEV_SIZE;

  dev->disk = alloc_disk(1);		/* 申请仓库gendisk,返回值为gendisk结构体 */
  if (!dev->disk) {
    printk("alloc diskerror");
    ret = -ENOMEM;
    goto err_out1;
  }

  dev->queue = blk_alloc_queue(GFP_KERNEL);		/* 建立关卡,关卡申请后,可以用也可以不用,但必须申请 */

  if (!dev->queue) {
    printk("alloc queueerror");
    ret = -ENOMEM;
    goto err_out2;
  }

  /* init queue */
  blk_queue_make_request(dev->queue, (void *)make_request);		/* 仓库加工函数,即:请求处理函数make_request,第一参数是刚申请到的请求队列,第二个参数是我们写好的make_request函数名 */
  dev->queue->queuedata = dev;

  /* init gendisk */
  strncpy(dev->disk->disk_name, dev_name, DEV_NAME_LEN);	/* 给gendisk的disk_name成员赋值,也就是给仓库取名字 */
  dev->disk->major = major;		/* 把申请到的门牌号赋值给disk的成员major */
  dev->disk->first_minor = minor;	/* 赋值了一个次设备号 */
  dev->disk->fops = &disk_fops;		/* 为gendisk的文件操作函数赋值了一个函数指针集结构体 */

  /* new code */
  /* dev->lower_bdev = open_bdev_exclusive(dev->lower_dev_name, FMODE_WRITE| FMODE_READ, dev->lower_bdev); */
  blkdev_get_by_path(dev->lower_dev_name,FMODE_WRITE| FMODE_READ, dev->lower_bdev);		/* 获取底层设备的block_device数据结构指针 */
  if (IS_ERR(dev->lower_bdev)) {
    printk("Open thedevice[%s]'s lower dev [%s] failed!\n", dev_name, dev->lower_dev_name);
    ret = -ENOENT;
    goto err_out3;
  }

  dev->size = get_capacity(dev->lower_bdev->bd_disk) <<SECTOR_BITS;		/* 获取底层设备的容量大小 */
  set_capacity(dev->disk, (dev->size >> SECTOR_BITS));	/* 设置设备的容量为底层设备的容量大小 */

  /* bind queue to disk */
  dev->disk->queue =dev->queue;		/* 把申请的queue地址保存在disk中,这样仓库和关卡就绑定在一起了 */

  /* add disk to kernel */
  add_disk(dev->disk);	/*告诉内核我们的仓库需要审核一下,如果通过,那仓库就建好了 */

  return 0;

err_out3:
  blk_cleanup_queue(dev->queue);
err_out2:
  put_disk(dev->disk);
err_out1:
  return ret;
}

static void dev_delete(struct fbd_dev *dev, char *name)
{
  printk("delete the device [%s]!\n", name);

  /* new code */
  // close_bdev_excl(dev->lower_bdev);
  blkdev_put(dev->lower_bdev, FMODE_WRITE| FMODE_READ);

  blk_cleanup_queue(dev->queue);
  del_gendisk(dev->disk);
  put_disk(dev->disk);
}

/* 内核模块入口,也是构建块设备驱动的核心部分 */
static int __init fbd_driver_init(void)
{
  int ret;

  /* register fbd driver, get the driver major number */
  fbd_driver_major =register_blkdev(fbd_driver_major, DRIVER_NAME);		/* 第一个参数是初始化的major号,第二参数是块设备驱动的名字。第一参数0时,系统会从它自己管理的情况表上查找是否有可用的号码,如果有就分配,作为regiser_blkdev的返回值 */

  if (fbd_driver_major < 0) {
    printk("get majorfail");
    ret = -EIO;
    goto err_out1;
  }

  /* create the first device */
  ret = dev_create(&fbd_dev1, DEVICE1_NAME, fbd_driver_major,DEVICE1_MINOR);

  if (ret) {
    printk("create device[%s] failed!\n", DEVICE1_NAME);
    goto err_out2;
  }

  /* create the second device */
  ret = dev_create(&fbd_dev2, DEVICE2_NAME, fbd_driver_major,DEVICE2_MINOR);

  if (ret) {
    printk("create device[%s] failed!\n", DEVICE2_NAME);
    goto err_out3;
  }
  return ret;

err_out3:
  dev_delete(&fbd_dev1, DEVICE1_NAME);
err_out2:
  unregister_blkdev(fbd_driver_major, DRIVER_NAME);
err_out1:
  return ret;
}

static void __exit fbd_driver_exit(void)
{
  /* delete the two devices */
  dev_delete(&fbd_dev2, DEVICE2_NAME);
  dev_delete(&fbd_dev1, DEVICE1_NAME);

  /* unregister fbd driver */
  unregister_blkdev(fbd_driver_major,DRIVER_NAME);
  printk("block device driver exit successfuly!\n");
}

module_init(fbd_driver_init);
module_exit(fbd_driver_exit);
MODULE_LICENSE("GPL");

和上一个demo比较,查看改动的地方:

diff fbd_driver.c fbd_driver_old.c -u > fbd_driver.patch
cat fbd_driver.patch

补丁的内容如下:

--- fbd_driver_old.c	2020-11-16 16:51:27.344000000 +0800
+++ fbd_driver.c	2020-11-16 17:55:27.850994518 +0800
@@ -8,8 +8,22 @@
 
 static int fbd_driver_major = 0;
 
-static struct fbd_dev fbd_dev1 = {NULL};
-static struct fbd_dev fbd_dev2 = {NULL};
+/* new code */
+static struct fbd_dev fbd_dev1 = {
+  .queue = NULL,
+  .disk = NULL,
+  .lower_dev_name = "/dev/sdb",
+  .lower_bdev = NULL,
+  .size = 0
+};
+/* new code */
+static struct fbd_dev fbd_dev2 = {
+  .queue = NULL,
+  .disk = NULL,
+  .lower_dev_name = "/dev/sdc",
+  .lower_bdev = NULL,
+  .size = 0
+};
 
 static int fbddev_open(struct inode *inode, struct file *file);
 static int fbddev_close(struct inode *inode, struct file *file);
@@ -46,7 +60,10 @@
          (long long)bio->bi_iter.bi_sector,
          bio_sectors(bio));
 
-  bio_endio(bio);		//结束一个bio请求
+  /* new code */
+  // bio->bi_bdev = dev->lower_bdev;
+  bio_set_dev(bio, dev->lower_bdev);
+  submit_bio(bio);
 
   return 0;
 }
@@ -83,15 +100,29 @@
   dev->disk->major = major;		/* 把申请到的门牌号赋值给disk的成员major */
   dev->disk->first_minor = minor;	/* 赋值了一个次设备号 */
   dev->disk->fops = &disk_fops;		/* 为gendisk的文件操作函数赋值了一个函数指针集结构体 */
-  set_capacity(dev->disk, (dev->size >> SECTOR_BITS));	/* 设置设备的容量大小为512M */
+
+  /* new code */
+  // dev->lower_bdev = open_bdev_exclusive(dev->lower_dev_name, FMODE_WRITE| FMODE_READ, dev->lower_bdev);
+  blkdev_get_by_path(dev->lower_dev_name,FMODE_WRITE| FMODE_READ, dev->lower_bdev);
+  if (IS_ERR(dev->lower_bdev)) {
+    printk("Open thedevice[%s]'s lower dev [%s] failed!\n", dev_name, dev->lower_dev_name);
+    ret = -ENOENT;
+    goto err_out3;
+  }
+
+  dev->size = get_capacity(dev->lower_bdev->bd_disk) <<SECTOR_BITS;
+  set_capacity(dev->disk, (dev->size >> SECTOR_BITS));	/* 设置设备的容量 */
 
   /* bind queue to disk */
   dev->disk->queue =dev->queue;		/* 把申请的queue地址保存在disk中,这样仓库和关卡就绑定在一起了 */
 
   /* add disk to kernel */
   add_disk(dev->disk);	/*告诉内核我们的仓库需要审核一下,如果通过,那仓库就建好了 */
+
   return 0;
 
+err_out3:
+  blk_cleanup_queue(dev->queue);
 err_out2:
   put_disk(dev->disk);
 err_out1:
@@ -102,6 +133,10 @@
 {
   printk("delete the device [%s]!\n", name);
 
+  /* new code */
+  // close_bdev_excl(dev->lower_bdev);
+  blkdev_put(dev->lower_bdev, FMODE_WRITE| FMODE_READ);
+
   blk_cleanup_queue(dev->queue);
   del_gendisk(dev->disk);
   put_disk(dev->disk);

修改完成之后,重新编译:

make clean
make

先卸载内核模块,然后重新加载:

sudo rmmod fbd_driver.ko
sudo dmesg -C
sudo insmod fbd_driver.ko
dmesg

[54554.965217] device is opened by:[systemd-udevd]

[54554.965802] device is opened by:[systemd-udevd]

[54554.998264] device is closed by:[systemd-udevd]

[54555.018357] device is closed by:[systemd-udevd]

ls -l /dev/fbd*

brw-rw---- 1 root disk 252, 0 Nov 13 09:08 /dev/fbd1_dev

brw-rw---- 1 root disk 252, 1 Nov 13 09:08 /dev/fbd2_dev

5. 完善代码(BIO请求回调机制)

fbd_driver.h 的内容:

#ifndef  _FBD_DRIVER_H
#define  _FBD_DRIVER_H

#include <linux/init.h>
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/bio.h>
#include <linux/genhd.h>


#define SECTOR_BITS             (9)
#define DEV_NAME_LEN            32

#define DRIVER_NAME            "filter driver"

#define DEVICE1_NAME           "fbd1_dev"
#define DEVICE1_MINOR           0
#define DEVICE2_NAME           "fbd2_dev"
#define DEVICE2_MINOR           1


struct fbd_dev {
        struct request_queue *queue;
        struct gendisk *disk;
        sector_t size;          /* devicesize in Bytes */

        /* new code */
        char lower_dev_name[DEV_NAME_LEN];
        struct block_device *lower_bdev;

};

/* new code for bio  call back */
struct bio_context {
        void *old_private;
        void *old_callback;
};

#endif

fbd_driver.c 的内容:

/**
 *  fbd-driver - filter block device driver
 *  Author: Talk@studio
 *  Modified by abin
 **/
 
#include "fbd_driver.h"

static int fbd_driver_major = 0;

/* new code */
static struct fbd_dev fbd_dev1 = {
  .queue = NULL,
  .disk = NULL,
  .lower_dev_name = "/dev/loop13",
  .lower_bdev = NULL,
  .size = 0
};
/* new code */
static struct fbd_dev fbd_dev2 = {
  .queue = NULL,
  .disk = NULL,
  .lower_dev_name = "/dev/loop14",
  .lower_bdev = NULL,
  .size = 0
};

static int fbddev_open(struct inode *inode, struct file *file);
static int fbddev_close(struct inode *inode, struct file *file);

static struct block_device_operations disk_fops = {
  .open = (void *)fbddev_open,
  .release = (void *)fbddev_close,
  .owner = THIS_MODULE,
};

/* 块设备被打开时调用该函数 */
static int fbddev_open(struct inode *inode, struct file *file)
{
  printk("device is opened by:[%s]\n", current->comm);
  return 0;
}

/* 块设备被关闭时调用该函数 */
static int fbddev_close(struct inode *inode, struct file *file)
{
  printk("device is closed by:[%s]\n", current->comm);
  return 0;
}

/* new code for bio  call back */
/* bio请求回调时执行的函数 */
static int fbd_io_callback(struct bio *bio,unsigned int bytes_done, int error)
{
  struct bio_context *ctx = bio->bi_private;
  bio->bi_private = ctx->old_private;
  bio->bi_end_io = ctx->old_callback;
  kfree(ctx);

  printk("returned [%s] io request, end on sector %lu!\n", bio_data_dir(bio) == READ ?"read" : "write", bio->bi_iter.bi_sector);

  if (bio->bi_end_io) {
    int (*callback)(struct bio *bio,unsigned int bytes_done, int error) = (void *)(bio->bi_end_io);
    callback(bio, bytes_done, error);
  }

  return 0;
}

/* 仓库的加工函数,在dev_create中被调用 */
static int make_request(struct request_queue *q, struct bio *bio)		//参数1是我们的关卡请求队列,参数2是上层准备好的盒子bio请求描述结构体指针
{
  struct fbd_dev *dev = (struct fbd_dev *)q->queuedata;
  /* new code for bio  call back */
  struct bio_context *ctx;

  printk("device [%s] recevied [%s] io request, "
         "access on dev sector[%llu], length is [%u] sectors.\n",
         dev->disk->disk_name,
         bio_data_dir(bio) == READ ?"read" : "write",
         (long long)bio->bi_iter.bi_sector,
         bio_sectors(bio));

  /* new code for bio  call back */
  ctx = kmalloc(sizeof(struct bio_context), GFP_KERNEL);
  if (!ctx) {
    printk("alloc memory forbio_context failed!\n");
    bio_endio(bio);
    goto out;
  }
  memset(ctx, 0, sizeof(struct bio_context));

  ctx->old_private = bio->bi_private;
  ctx->old_callback = bio->bi_end_io;
  bio->bi_private = ctx;
  bio->bi_end_io = (void *)fbd_io_callback;

  /* new code */
  // bio->bi_bdev = dev->lower_bdev;
  bio_set_dev(bio, dev->lower_bdev);
  submit_bio(bio);

out:
  return 0;
}

/* 创建过滤设备的函数,在init函数中被调用 */
static int dev_create(struct fbd_dev *dev, char *dev_name, int major, int minor)
{
  int ret = 0;

  /* init fbd_dev */

  dev->disk = alloc_disk(1);		/* 申请仓库gendisk,返回值为gendisk结构体 */
  if (!dev->disk) {
    printk("alloc diskerror");
    ret = -ENOMEM;
    goto err_out1;
  }

  dev->queue = blk_alloc_queue(GFP_KERNEL);		/* 建立关卡,关卡申请后,可以用也可以不用,但必须申请 */

  if (!dev->queue) {
    printk("alloc queueerror");
    ret = -ENOMEM;
    goto err_out2;
  }

  /* init queue */
  blk_queue_make_request(dev->queue, (void *)make_request);		/* 仓库加工函数,即:请求处理函数make_request,第一参数是刚申请到的请求队列,第二个参数是我们写好的make_request函数名 */
  dev->queue->queuedata = dev;

  /* init gendisk */
  strncpy(dev->disk->disk_name, dev_name, DEV_NAME_LEN);	/* 给gendisk的disk_name成员赋值,也就是给仓库取名字 */
  dev->disk->major = major;		/* 把申请到的门牌号赋值给disk的成员major */
  dev->disk->first_minor = minor;	/* 赋值了一个次设备号 */
  dev->disk->fops = &disk_fops;		/* 为gendisk的文件操作函数赋值了一个函数指针集结构体 */

  /* new code */
  // dev->lower_bdev = open_bdev_exclusive(dev->lower_dev_name, FMODE_WRITE| FMODE_READ, dev->lower_bdev);
  blkdev_get_by_path(dev->lower_dev_name,FMODE_WRITE| FMODE_READ, dev->lower_bdev);
  if (IS_ERR(dev->lower_bdev)) {
    printk("Open thedevice[%s]'s lower dev [%s] failed!\n", dev_name, dev->lower_dev_name);
    ret = -ENOENT;
    goto err_out3;
  }

  dev->size = get_capacity(dev->lower_bdev->bd_disk) <<SECTOR_BITS;
  set_capacity(dev->disk, (dev->size >> SECTOR_BITS));	/* 设置设备的容量 */

  /* bind queue to disk */
  dev->disk->queue =dev->queue;		/* 把申请的queue地址保存在disk中,这样仓库和关卡就绑定在一起了 */

  /* add disk to kernel */
  add_disk(dev->disk);	/*告诉内核我们的仓库需要审核一下,如果通过,那仓库就建好了 */

  return 0;

err_out3:
  blk_cleanup_queue(dev->queue);
err_out2:
  put_disk(dev->disk);
err_out1:
  return ret;
}

static void dev_delete(struct fbd_dev *dev, char *name)
{
  printk("delete the device [%s]!\n", name);

  /* new code */
  // close_bdev_excl(dev->lower_bdev);
  blkdev_put(dev->lower_bdev, FMODE_WRITE| FMODE_READ);

  blk_cleanup_queue(dev->queue);
  del_gendisk(dev->disk);
  put_disk(dev->disk);
}

/* 内核模块入口,也是构建块设备驱动的核心部分 */
static int __init fbd_driver_init(void)
{
  int ret;

  /* register fbd driver, get the driver major number */
  fbd_driver_major =register_blkdev(fbd_driver_major, DRIVER_NAME);		/* 第一个参数是初始化的major号,第二参数是块设备驱动的名字。第一参数0时,系统会从它自己管理的情况表上查找是否有可用的号码,如果有就分配,作为regiser_blkdev的返回值 */

  if (fbd_driver_major < 0) {
    printk("get majorfail");
    ret = -EIO;
    goto err_out1;
  }

  /* create the first device */
  ret = dev_create(&fbd_dev1, DEVICE1_NAME, fbd_driver_major,DEVICE1_MINOR);

  if (ret) {
    printk("create device[%s] failed!\n", DEVICE1_NAME);
    goto err_out2;
  }

  /* create the second device */
  ret = dev_create(&fbd_dev2, DEVICE2_NAME, fbd_driver_major,DEVICE2_MINOR);

  if (ret) {
    printk("create device[%s] failed!\n", DEVICE2_NAME);
    goto err_out3;
  }
  return ret;

err_out3:
  dev_delete(&fbd_dev1, DEVICE1_NAME);
err_out2:
  unregister_blkdev(fbd_driver_major, DRIVER_NAME);
err_out1:
  return ret;
}

static void __exit fbd_driver_exit(void)
{
  /* delete the two devices */
  dev_delete(&fbd_dev2, DEVICE2_NAME);
  dev_delete(&fbd_dev1, DEVICE1_NAME);

  /* unregister fbd driver */
  unregister_blkdev(fbd_driver_major,DRIVER_NAME);
  printk("block device driver exit successfuly!\n");
}

module_init(fbd_driver_init);
module_exit(fbd_driver_exit);
MODULE_LICENSE("GPL");

加入bio过滤功能和bio请求回调机制后的示意图如下:

图源 https://img-blog.csdn.net/20130614111543781

其中,fbd_driver 接管了来自上层( VFS )的bio请求,经过处理后提交给下层设备( /dev/sdb 和 /dev/sdc ),下层设备处理完后,bio 返回也会被 fbd_driver 捕获,并进行相应处理。可以看出,fbd_driver 的作用就是在 VFS 和 底层设备之间增加了一个中间处理流程。

posted @ 2020-11-22 22:37  abin在路上  阅读(880)  评论(0编辑  收藏  举报