简单的块设备驱动例程

已于 2023-10-23 16:55:35 修改
阅读量143 收藏
点赞数
分类专栏： # block 文章标签： linux
于 2023-10-16 15:21:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38158479/article/details/133859511
版权

单队列架构的：

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/kdev_t.h>
#include <linux/vmalloc.h>
#include <linux/genhd.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>
#include <linux/bio.h>
#include <linux/pci.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>

static int ramdisk_major = 0;
module_param(ramdisk_major, int, 0);
static int hardsect_size = 512;
module_param(hardsect_size, int, 0);
static int nsectors = 1024;
module_param(nsectors, int, 0);

#define RAMDISK_MINORS		16

struct ramdisk_dev {
	int size;
	int users;
	u8 *data;
	spinlock_t lock;
	struct gendisk *gd;
	struct request_queue *queue;
};

static struct ramdisk_dev *Devices = NULL;

static void ramdisk_transfer(struct ramdisk_dev *dev, unsigned long sector,
		unsigned long nsect, char *buffer, int write)
{
	unsigned long offset = sector * hardsect_size;
	unsigned long nbytes = nsect * hardsect_size;

	if ((offset + nbytes) > dev->size) {
		printk (KERN_NOTICE "Beyond-end write (%ld %ld)\n", offset, nbytes);
		return;
	}
	if (write)
		memcpy(dev->data + offset, buffer, nbytes);
	else
		memcpy(buffer, dev->data + offset, nbytes);
}

static int ramdisk_xfer_bio(struct ramdisk_dev *dev, struct bio *bio)
{
	int index;
	struct bio_vec *bvec;
	sector_t sector = bio->bi_sector; //bio的起始扇区号

	bio_for_each_segment(bvec, bio, index) { //遍历bio里面的每一个bvec
		char *buffer = __bio_kmap_atomic(bio, index);//bvec bv_page成员转内核态虚拟地址
		unsigned len = bvec->bv_len >> 9;//当前bvec的扇区数

		ramdisk_transfer(dev, sector, len, buffer, bio_data_dir(bio) == WRITE);
		sector += len; //扇区数累加
		__bio_kunmap_atomic(bio); //解除映射
	}
	return 0;
}

static int ramdisk_make_request(struct request_queue *q, struct bio *bio)
{
	struct ramdisk_dev *dev = q->queuedata;
	int status = ramdisk_xfer_bio(dev, bio);
	bio_endio(bio, status);
}

int ramdisk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
{
	printk("ramdisk_ioctl \n");
	return 0;
}

static int ramdisk_open(struct block_device *bdev, fmode_t mode)
{
	struct ramdisk_dev *dev = bdev->bd_disk->private_data;

	spin_lock(&dev->lock);
	if (!dev->users)
		check_disk_change(bdev);
	++dev->users;
	printk("ramdisk_open, dev->users = %d\n", dev->users);
	spin_unlock(&dev->lock);
	return 0;
}

static void ramdisk_release(struct gendisk *disk, fmode_t mode)
{
	struct ramdisk_dev *dev = disk->private_data;
	spin_lock(&dev->lock);
	--dev->users;
	printk("ramdisk_release, dev->users = %d\n", dev->users);
	spin_unlock(&dev->lock);
}

static struct block_device_operations ramdisk_ops = {
	.owner = THIS_MODULE,
	.ioctl = ramdisk_ioctl,
	.open = ramdisk_open,
	.release = ramdisk_release,
};

static void setup_device(struct ramdisk_dev *dev)
{
	memset (dev, 0, sizeof (struct ramdisk_dev));
	dev->size = nsectors * hardsect_size;
	dev->data = vmalloc(dev->size);
	if (dev->data == NULL) {
		printk (KERN_NOTICE "vmalloc failure.\n");
		return;
	}
	spin_lock_init(&dev->lock);

	dev->queue = blk_alloc_queue(GFP_KERNEL);
	if (dev->queue == NULL)
		goto out_vfree;
	blk_queue_make_request(dev->queue, ramdisk_make_request);
	dev->queue->queuedata = dev;

	dev->gd = alloc_disk(RAMDISK_MINORS);
	if (!dev->gd) {
		printk (KERN_NOTICE "alloc_disk failure\n");
		goto out_alloc_disk;
	}
	dev->gd->major = ramdisk_major;
	dev->gd->first_minor = RAMDISK_MINORS;
	dev->gd->fops = &ramdisk_ops;
	dev->gd->queue = dev->queue;
	dev->gd->private_data = dev;
	snprintf (dev->gd->disk_name, 32, "ramdisk%c", 'a');
	set_capacity(dev->gd, nsectors);
	add_disk(dev->gd);
	return;
out_alloc_disk:
	blk_cleanup_queue(dev->queue);
	dev->queue = NULL;
out_vfree:
	if (dev->data)
		vfree(dev->data);
}

static int __init ramdisk_init(void)
{
	ramdisk_major = register_blkdev(ramdisk_major, "ramdisk");
	if (ramdisk_major <= 0) {
		printk(KERN_WARNING "ramdisk: unable to get major number\n");
		return -EBUSY;
	}
	Devices = kmalloc(sizeof(struct ramdisk_dev), GFP_KERNEL);
	if(Devices == NULL)
		goto out_unregister;

	setup_device(Devices);
	return 0;
out_unregister:
	unregister_blkdev(ramdisk_major, "ramdisk");
	return -ENOMEM;
}

static void __exit ramdisk_exit(void)
{
	if(Devices->gd)
		del_gendisk(Devices->gd);
	if(Devices->queue)
		blk_cleanup_queue(Devices->queue);
	if(Devices->data)
		vfree(Devices->data);
	kfree(Devices);
	unregister_blkdev(ramdisk_major, "ramdisk");
}

module_init(ramdisk_init);
module_exit(ramdisk_exit);

Makefile:

# SPDX-License-Identifier: GPL-2.0
obj-m += ram.o
ram-objs := ramdisk.o

all:
	make -C /usr/src/linux-headers-$(shell uname -r) M=$(shell pwd) modules
clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(shell pwd) clean

代码在linux3.13版本下可以编译通过，装载驱动以后，可以用fio工具进行读写测试。

多队列架构的：

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>

#include <linux/sched.h>
#include <linux/kernel.h>	/* printk() */
#include <linux/slab.h>		/* kmalloc() */
#include <linux/fs.h>		/* everything... */
#include <linux/errno.h>	/* error codes */
#include <linux/types.h>	/* size_t */
#include <linux/fcntl.h>	/* O_ACCMODE */
#include <linux/hdreg.h>	/* HDIO_GETGEO */
#include <linux/kdev_t.h>
#include <linux/vmalloc.h>
#include <linux/genhd.h>
#include <linux/blk-mq.h>
#include <linux/buffer_head.h>	/* invalidate_bdev */
#include <linux/bio.h>

#ifndef BLK_STS_OK
typedef int blk_status_t;
#define BLK_STS_OK 0
#define OLDER_KERNEL 1
#endif

#ifndef BLK_STS_IOERR
#define BLK_STS_IOERR 10
#endif
 
#ifndef SECTOR_SHIFT
#define SECTOR_SHIFT 9
#endif

/* FIXME: implement these macros in kernel mainline */
#define size_to_sectors(size) ((size) >> SECTOR_SHIFT)
#define sectors_to_size(size) ((size) << SECTOR_SHIFT)

static int sbull_major;
module_param(sbull_major, int, 0);
static int logical_block_size = 512;
module_param(logical_block_size, int, 0);
static char* disk_size = "256M";
module_param(disk_size, charp, 0);
static int ndevices = 1;
module_param(ndevices, int, 0);
static bool debug = false;
module_param(debug, bool, false);

#define SBULL_MINORS	16
#define KERNEL_SECTOR_SIZE	512

struct sbull_dev {
	int size;                       /* Device size in sectors */
	u8 *data;                       /* The data array */
	spinlock_t lock;                /* For mutual exclusion */
	struct request_queue *queue;    /* The device request queue */
	struct gendisk *gd;             /* The gendisk structure */
	struct blk_mq_tag_set tag_set;
};

static struct sbull_dev *Devices;

static blk_status_t sbull_transfer(struct sbull_dev *dev, unsigned long sector, unsigned long nsect, char *buffer, int op)
{
	unsigned long offset = sectors_to_size(sector);
	unsigned long nbytes = sectors_to_size(nsect);
 
	if ((offset + nbytes) > dev->size) {
		pr_notice("Beyond-end write (%ld %ld)\n", offset, nbytes);
		return BLK_STS_IOERR;
	}

	if  (debug)
		pr_info("%s: %s, sector: %ld, nsectors: %ld, offset: %ld,"
			       " nbytes: %ld",
			dev->gd->disk_name,
			op == REQ_OP_WRITE ? "WRITE" : "READ", sector, nsect,
			offset, nbytes);

	if (op == REQ_OP_WRITE)
		memcpy(dev->data + offset, buffer, nbytes);
	else
		memcpy(buffer, dev->data + offset, nbytes);
	return BLK_STS_OK;
}

static blk_status_t sbull_queue_rq(struct blk_mq_hw_ctx *hctx, const struct blk_mq_queue_data *bd)
{
	struct request *req = bd->rq;
	struct sbull_dev *dev = req->rq_disk->private_data;
	int op = req_op(req);
	blk_status_t ret;

	blk_mq_start_request(req);
	spin_lock(&dev->lock);

	if (op != REQ_OP_READ && op != REQ_OP_WRITE) {
		pr_notice("Skip non-fs request\n");
		blk_mq_end_request(req, BLK_STS_IOERR);
		spin_unlock(&dev->lock);
		return BLK_STS_IOERR;
	}

	ret = sbull_transfer(dev, blk_rq_pos(req), blk_rq_cur_sectors(req), bio_data(req->bio), op);

	blk_mq_end_request(req, ret);
	spin_unlock(&dev->lock);
	return ret;
}

static const struct block_device_operations sbull_ops = {
	.owner	= THIS_MODULE,
};

static const struct blk_mq_ops sbull_mq_ops = {
	.queue_rq = sbull_queue_rq,
};

static struct request_queue *create_req_queue(struct blk_mq_tag_set *set)
{
	struct request_queue *q;
#ifndef OLDER_KERNEL
	q = blk_mq_init_sq_queue(set, &sbull_mq_ops, 2, BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING);
#else
	int ret;
	memset(set, 0, sizeof(*set));
	set->ops = &sbull_mq_ops;
	set->nr_hw_queues = 1;
	/*set->nr_maps = 1;*/
	set->queue_depth = 2;
	set->numa_node = NUMA_NO_NODE;
	set->flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
 
	ret = blk_mq_alloc_tag_set(set);
	if (ret)
		return ERR_PTR(ret);
 
	q = blk_mq_init_queue(set);
	if (IS_ERR(q)) {
		blk_mq_free_tag_set(set);
		return q;
	}
#endif
	return q;
}

static void setup_device(struct sbull_dev *dev, int which)
{
	long long sbull_size = memparse(disk_size, NULL);
 
	memset(dev, 0, sizeof(struct sbull_dev));
	dev->size = sbull_size;
	dev->data = vzalloc(dev->size);
	if (dev->data == NULL) {
		pr_notice("vmalloc failure.\n");
		return;
	}
	spin_lock_init(&dev->lock);
 
	dev->queue = create_req_queue(&dev->tag_set);
	if (IS_ERR(dev->queue))
		goto out_vfree;
 
	blk_queue_logical_block_size(dev->queue, logical_block_size);
	dev->queue->queuedata = dev;

	dev->gd = alloc_disk(SBULL_MINORS);
	if (!dev->gd) {
		pr_notice("alloc_disk failure\n");
		goto out_vfree;
	}
	dev->gd->major = sbull_major;
	dev->gd->first_minor = which*SBULL_MINORS;
	dev->gd->fops = &sbull_ops;
	dev->gd->queue = dev->queue;
	dev->gd->private_data = dev;
	snprintf(dev->gd->disk_name, 32, "sbull%c", which + 'a');
	set_capacity(dev->gd, size_to_sectors(sbull_size));
	add_disk(dev->gd);
	return;
 
out_vfree:
	if (dev->data)
		vfree(dev->data);
}

static int __init sbull_init(void)
{
	int i;

	sbull_major = register_blkdev(sbull_major, "sbull");
	if (sbull_major <= 0) {
		pr_warn("sbull: unable to get major number\n");
		return -EBUSY;
	}

	Devices = kmalloc(ndevices * sizeof(struct sbull_dev), GFP_KERNEL);
	if (Devices == NULL)
		goto out_unregister;
	for (i = 0; i < ndevices; i++)
		setup_device(Devices + i, i);
	return 0;
out_unregister:
	unregister_blkdev(sbull_major, "sbull");
	return -ENOMEM;
}

static void sbull_exit(void)
{
	int i;

	for (i = 0; i < ndevices; i++) {
		struct sbull_dev *dev = Devices + i;

		if (dev->gd) {
			del_gendisk(dev->gd);
			put_disk(dev->gd);
		}
		if (dev->queue)
			blk_cleanup_queue(dev->queue);

		if (dev->data)
			vfree(dev->data);
	}
	unregister_blkdev(sbull_major, "sbull");
	kfree(Devices);
}

module_init(sbull_init);
module_exit(sbull_exit);

MODULE_LICENSE("GPL");

参考：https://blog.csdn.net/jfhgk3445/article/details/104792941/

酸菜。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个失败的块设备驱动案例----用内存模拟磁盘
09-23
一个失败的块设备驱动案例----用内存模拟磁盘 通过一个简单的驱动例程来，使用内存来模拟块设备，初步体验一下linux的块设备驱动程序。
windows驱动开发技术详解-part2
07-06
　1.2.4 卸载驱动例程 　1.2.5 默认派遣例程 　1.3 HelloDDK的编译和安装 　1.3.1 用DDK环境编译HelloDDK 　1.3.2 用VC集成开发环境编译HelloDDK 　1.3.3 HelloDDK的安装 　1.4 第二个驱动程序HelloWDM的代码...
Linux设备驱动开发 - 块设备驱动ramdisk实例
fulinux的博客
04-10 629
Linux设备驱动开发 - 块设备驱动ramdisk实例
Linux 块设备驱动实验
afddasfa的博客
03-29 928
块设备是针对存储设备的，比如 SD 卡、EMMC、NAND Flash、Nor Flash、SPI Flash、机械硬盘、固态硬盘等。块设备驱动相比字符设备驱动的主要区别如下：①、块设备只能以块为单位进行读写访问，块是 linux 虚拟文件系统(VFS)基本的数据传输单位。字符设备是以字节为单位进行数据传输的，不需要缓冲。②、块设备在结构上是可以进行随机访问的，对于这些设备的读写都是按块进行的，块设备使用缓冲区来暂时存放数据，等到条件成熟以后在一次性将缓冲区中的数据写入块设备中。
深入理解linux内核-磁盘IO-块设备驱动程序
x13262608581的博客
08-18 519
深入理解linux内核--块设备驱动
编写最简单的字符设备驱动
qq_41683305的博客
04-22 6362
编写最简单的字符设备驱动1 编写驱动代码2 编写makefile3 编译和加载驱动4 编写应用程序测试驱动 1 编写驱动代码 驱动代码chardev.c如下： #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/cdev.h> #include <linux/fs.h> #include <linux/wait.h> #include <linux/
Linux 块设备驱动测试,Linux块设备驱动---概念与框架
weixin_30487899的博客
05-05 141
基本概念块设备(blockdevice)--- 是一种具有一定结构的随机存取设备，对这种设备的读写是按块进行的，他使用缓冲区来存放暂时的数据，待条件成熟后，从缓存一次性写入设备或者从设备一次性读到缓冲区。字符设备(Character device)---是一个顺序的数据流设备，对这种设备的读写是按字符进行的，而且这些字符是连续地形成一个数据流。他不具备缓冲区，所以对这种设备的读写是实时的。扇区(S...
Windows驱动开发技术详解的光盘-part1
07-06
　1.2.4 卸载驱动例程 　1.2.5 默认派遣例程 　1.3 HelloDDK的编译和安装 　1.3.1 用DDK环境编译HelloDDK 　1.3.2 用VC集成开发环境编译HelloDDK 　1.3.3 HelloDDK的安装 　1.4 第二个驱动程序HelloWDM的代码...
ARM 嵌入式LINUX 系统构建与驱动开发
06-19
简单的就可以把他理解为你自己做的JTAG的驱动就行了。 调试代理还有很多种，什么H-JTAG了、ARM7了（不知道具体叫什么，就记得可执行文件叫ARM7.EXE）都是，BANYANT比较好。 需要注意的是，没种调试代理安装方*虽然...
Windows 系统错误代码简单分析
04-14
Microsoft Windows 系统错误代码简单分析： 　0000 操作已成功完成。 　0001 错误的函数。 　0002 系统找不到指定的文件。 　0003 系统找不到指定的路径。 　0004 系统无法打开文件。 　0005 拒绝访问。...
linux-journal日志文件特别大怎么办，journal日志文件学习
你是我的天晴
04-28 181
今天发现磁盘容量不多了，就去清理磁盘，发现这个文件特别大：journal，特此来学习下。
Linux｜Awk 变量、数字表达式和赋值运算符
冷冻工厂
04-25 595
同样，数字 22 被赋予了变量 port_no，还可以把一个变量的值赋给另一个变量，就像最后一个例子中，将变量 computer_name 的值赋给了变量 server。例如，假设有一个名为 names.txt 的文件，该文件列出了一个应用程序的用户的名单，包括他们的名、姓和性别。要理解在 Awk 中数值表达式的运用，来看下面的例子，这个例子中用到了一个名为 domains.txt 的文件，这个文件列出了 Tecmint 所持有的所有域名。接下来，将探讨 Awk 的最后一个特性——赋值运算符。
Linux：浏览器访问网站的基本流程（优先级从先到后）
fox_kang的博客
04-28 663
浏览器访问网站的基本流程（优先级从先到后） 首先查找浏览器是否存在该网站的访问缓存 其次查找本机的域名解析服务器 windows：C:\Windows\System32\drivers\etc\hosts Linux：/etc/hosts 使用外部的域名解析服务器解析（例如：114.114.114.114） 第一步：浏览器使用域名访问www.bilibili.com.网站 第二步：首先去访问根域名解析服务器查询，根服务器返回.com域名解析服务器地址==（这里的根域名解析服务器不会直接给出域名对应的
Linux 第十八章
最新发布
一怀明月的博客
05-01 840
程序地址空间 区间的地址分布 真正理解同一个地址进行读取不同内容 地址空间 虚拟地址和物理地址 虚拟地址： 物理地址： struct mm_struct 页表
linux kernel内存泄漏检测工具之kmemleak
yanghao23的专栏
04-27 1064
3.1 原理简介kmemleak实现方法是一个插桩加扫描过程, 它提供一个kmemleak_alloc桩函数，这个函数会在内核slab、vmalloc、alloc_bootmem、pcpu_alloc等函数分配接口中被调用，每次调用时该函数均会创建一个kmemleak object记录分配内存的相关信息比如内存地址，大小，调用栈等，并将这个object加入到一个rbtree里面;当内核释放内存时，也会调用kmemleak_free删除对应object。
linux 编译binutil 遇到问题
123
04-26 214
linux 编译binutil
linux 信号
l2894的博客
04-27 757
设定闹钟是再OS内部，OS内可能有很多进程使用闹钟，所以OS要管理所有的闹钟，先描述，再组织，所以内核中一定要有描述闹钟属性的结构体，并用特定的数据结构组织起来，这里可以使用小根堆来对闹钟进行管理。)，并保存在指定寄存器中，当中断发生时，CPU会暂停当前正在执行的程序，并保存当前进程的上下文数据，然后查找中断向量表，找到与中断号对应的处理函数的地址，回调方法。同时CPU有很多针脚，和外设物理连接，每个针脚有自己的编号，键盘按下按键会给特定的针脚发送高电平，触发硬件中断，CPU会识别到针脚的编号(
Linux: Netfilter 简介
JiMoKuangXiangQu的专栏
04-28 884
Linux，网络，Netfilter
Linux 环境变量的增删改
夏沫的杂物间
04-27 896
本文章旨在总结备份、方便以后查询，由于是个人总结，如有不对，欢迎指正；另外，内容大部分来自网络、书籍、和各类手册，如若侵权请告知，马上删帖致歉。
ms41949 驱动例程
10-21
ms41949驱动例程是一种用于控制和管理ms41949芯片的软件代码。ms41949是一款高压驱动器芯片，广泛应用于工业领域，常用于控制和驱动电机、液压系统等。驱动例程的作用是提供一系列的函数或方法，供开发者调用，从而...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值