通过内存模拟硬盘实现一个简单的块设备驱动

拼搏现实的明天。 2022-06-15 02:57 239阅读 0赞

本文的主要工作是通过硬盘来模拟内存，按照块设备驱动编程的框架实现一个简单的块设备驱动程序。

**一、前期的准备工作**

1、基本开发环境

Linux内核版本：Linux-3.4.10

开发板 ： JZ2440（ARM9）

2、块设备驱动的一般开发步骤

a、分配一个gendisk的结构体变量

b、设置这个结构体变量，

b1、分配设置一个队列，通过它来为块设备提供读写能力

b2、设置gendisk结构体的其他成员

c、注册这个gendisk结构体的变量

**二、编写块设备驱动程序**

通过在内存中分配2MB的空间来模拟硬盘，实现简单的块设备的读写、格式化、挂接等操作。为了驱动编写的方便，定义了这样一个全局的结构体，并通过这个结构体定义了一个全局变量，具体实现如下：

/* 定义一个yl_ramdisk_t的结构体，封装驱动程序使用的各种数据 */
    struct yl_ramdisk_t
    {
    	int major;				// 主设备号
    	unsigned char *ramdisk_buffer;		// 在内存中分配的缓冲区的存储区
    	struct gendisk *gendisk;		// 定义一个gendisk结构体变量指针变量
    	struct request_queue *queue;		// 定义一个请求队列的结构体指针变量
    };
    
    /* 定义一个yl_ramdisk结构体的全局变量 */
    static struct yl_ramdisk_t yl_ramdisk;

1、分配一个gendisk结构体变量，具体实现如下：

/* 1、分配一个gendisk结构体变量 */
    yl_ramdisk.gendisk = alloc_disk(8);	/* 分区数 + 1 =  minors*/	
    if (!yl_ramdisk.gendisk)
    {
    	printk("alloc_disk error!\n");
    	return -ENOMEM;
    }

2、设置这个分配的gendisk结构体变量的成员，具体如下：

2.1 分配一个队列，主要是为了给块设备提供读写能力

/* 2.1 分配一个队列，提供读写能力 */
    yl_ramdisk.queue = blk_init_queue(do_yl_ramdisk_request, &ramdisk_lock);
    if (!yl_ramdisk.queue)
    {
        put_disk(yl_ramdisk.gendisk);
     printk("blk_init_queue error!\n");
    	return -ENOMEM;
    }

这里面需要提供一个函数来实现具体的块设备的读写操作：do\_yl\_ramdisk\_request()函数，它的具体实现如下：

/* 定义队列处理函数 */
    static void do_yl_ramdisk_request(struct request_queue *q)
    {
    	struct request *req;
    
    	/* 从求情队列里面获得一个请求 */
    	req = blk_fetch_request(q);
    	while (req) 
    	{
    		unsigned long offset = blk_rq_pos(req) << 9;	// 获取ramdisk的偏移值
    		unsigned long len  = blk_rq_cur_bytes(req);		// 获取传输数据的大小
    		int err = 0;
    
    		/* 根据读写来决定数据传输方向 */
    		if (rq_data_dir(req) == READ)
    			memcpy(req->buffer, (char *)(yl_ramdisk.ramdisk_buffer + offset), len);
    		else
    			memcpy((char *)(yl_ramdisk.ramdisk_buffer + offset), req->buffer, len);
    
    		/* 判断是否是队列尾部，如果不是再次获得一个请求 */
    		if (!__blk_end_request_cur(req, err))
    			req = blk_fetch_request(q);
    	}
    }

2.2 设置gendisk其他相关的属性、成员，具体如下：

/* 2.2 设置其他相关属性 */
    yl_ramdisk.major = register_blkdev(0, "yl_ramdisk");	// 注册块设备，获取主设备号
    	
    yl_ramdisk.gendisk->major 		= yl_ramdisk.major;		// 设置主设备号
    yl_ramdisk.gendisk->first_minor = 0;					// 设置次设备号的起始为0
    yl_ramdisk.gendisk->queue		= yl_ramdisk.queue;		// 设置队列
    yl_ramdisk.gendisk->fops 		= &yl_ramdisk_fops;		// 块设备操作函数集合
    sprintf(yl_ramdisk.gendisk->disk_name, YL_DEVICE_NAME);	 // 设置名字
    set_capacity(yl_ramdisk.gendisk, YL_RAMDISK_SIZE / 512);		// 设置ramdisk的大小

这里面实现了一个块设备操作的函数结合的成员：yl\_ramdisk\_fops，它的主要功能就是实现对块设备的操作，我们这里主要用它实现模拟硬盘时磁头、柱面、扇区等的大小，它的具体实现如下：

/* 模拟机械硬盘，为其设置磁头、柱面、扇区等的大小 */
    static int yl_ramdisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
    {
    	/* 磁盘大小 =  heads*cylinders*sectors*512 */
    	geo->heads = 4;
    	geo->cylinders = 32;
    	geo->sectors = YL_RAMDISK_SIZE/geo->heads/geo->cylinders/512;
    	return 0;
    }
    
    /* 定义块设备的操作函数结构体变量 */
    static const struct block_device_operations yl_ramdisk_fops = {
    	.owner	= THIS_MODULE,
    	.getgeo = yl_ramdisk_getgeo,
    };

3、硬件相关的操作，主要是在内存中分配2MB的内存空间，为模拟硬盘做准备，具体实现如下：

/* 3、硬件相关的操作 */
    yl_ramdisk.ramdisk_buffer = kzalloc(YL_RAMDISK_SIZE, GFP_KERNEL);
    if (!yl_ramdisk.ramdisk_buffer) {
    	unregister_blkdev(yl_ramdisk.major, YL_DEVICE_NAME);
    	blk_cleanup_queue(yl_ramdisk.queue);
    	put_disk(yl_ramdisk.gendisk);
    	printk("kzalloc error!\n");
    	return -ENOMEM;
    }

4、注册这个gendisk结构体变量

/* 4、注册这个gendisk结构体变量 */
    add_disk(yl_ramdisk.gendisk);

**完整的程序代码实现如下所示：**

#include <linux/module.h>
    #include <linux/errno.h>
    #include <linux/interrupt.h>
    #include <linux/mm.h>
    #include <linux/fs.h>
    #include <linux/kernel.h>
    #include <linux/timer.h>
    #include <linux/genhd.h>
    #include <linux/hdreg.h>
    #include <linux/ioport.h>
    #include <linux/init.h>
    #include <linux/wait.h>
    #include <linux/blkdev.h>
    #include <linux/mutex.h>
    #include <linux/blkpg.h>
    #include <linux/delay.h>
    #include <linux/io.h>
    #include <linux/gfp.h>
    
    #include <asm/uaccess.h>
    #include <asm/dma.h>
    
    /* 定义ramdisk的大小为2MB */
    #define YL_RAMDISK_SIZE		((2) * (1024) * (1024))
    
    /* 定义ramdisk块设备的名称 */
    #define YL_DEVICE_NAME		"yl_ramdisk"
    
    /* 定义一个yl_ramdisk_t的结构体，封装驱动程序使用的各种数据 */
    struct yl_ramdisk_t
    {
    	int major;				// 主设备号
    	unsigned char *ramdisk_buffer;		// 在内存中分配的缓冲区的存储区
    	struct gendisk *gendisk;		// 定义一个gendisk结构体变量指针变量
    	struct request_queue *queue;		// 定义一个请求队列的结构体指针变量
    };
    
    /* 定义一个yl_ramdisk结构体的全局变量 */
    static struct yl_ramdisk_t yl_ramdisk;
    
    /* 模拟机械硬盘，为其设置磁头、柱面、扇区等的大小 */
    static int yl_ramdisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
    {
    	/* 磁盘大小 =  heads*cylinders*sectors*512 */
    	geo->heads = 4;
    	geo->cylinders = 32;
    	geo->sectors = YL_RAMDISK_SIZE/geo->heads/geo->cylinders/512;
    	return 0;
    }
    
    /* 定义块设备的操作函数结构体变量 */
    static const struct block_device_operations yl_ramdisk_fops = {
    	.owner	= THIS_MODULE,
    	.getgeo = yl_ramdisk_getgeo,
    };
    
    /* 定义一个自旋锁，用于分配一个队列 */
    static DEFINE_SPINLOCK(ramdisk_lock);
    
    /* 定义队列处理函数 */
    static void do_yl_ramdisk_request(struct request_queue *q)
    {
    	struct request *req;
    
    	/* 从求情队列里面获得一个请求 */
    	req = blk_fetch_request(q);
    	while (req) 
    	{
    		unsigned long offset = blk_rq_pos(req) << 9;	// 获取ramdisk的偏移值
    		unsigned long len  = blk_rq_cur_bytes(req);		// 获取传输数据的大小
    		int err = 0;
    
    		/* 根据读写来决定数据传输方向 */
    		if (rq_data_dir(req) == READ)
    			memcpy(req->buffer, (char *)(yl_ramdisk.ramdisk_buffer + offset), len);
    		else
    			memcpy((char *)(yl_ramdisk.ramdisk_buffer + offset), req->buffer, len);
    
    		/* 判断是否是队列尾部，如果不是再次获得一个请求 */
    		if (!__blk_end_request_cur(req, err))
    			req = blk_fetch_request(q);
    	}
    }
    
    /* 定义入口函数 */
    static int __init yl_ramdisk_init(void)
    {
    	/* 1、分配一个gendisk结构体变量 */
    	yl_ramdisk.gendisk = alloc_disk(8);	/* 分区数 + 1 =  minors*/	
    	if (!yl_ramdisk.gendisk)
    	{
    		printk("alloc_disk error!\n");
    		return -ENOMEM;
    	}
    
    	/* 2、设置分配的gendisk结构体变量 */
    	/* 2.1 分配一个队列，提供读写能力 */
    	yl_ramdisk.queue = blk_init_queue(do_yl_ramdisk_request, &ramdisk_lock);
        if (!yl_ramdisk.queue)
        {
        	put_disk(yl_ramdisk.gendisk);
    		printk("blk_init_queue error!\n");
    		return -ENOMEM;
    	}
    
    	/* 2.2 设置其他相关属性 */
    	yl_ramdisk.major = register_blkdev(0, "yl_ramdisk");	// 注册块设备，获取主设备号
    	
    	yl_ramdisk.gendisk->major 		= yl_ramdisk.major;		// 设置主设备号
    	yl_ramdisk.gendisk->first_minor = 0;					// 设置次设备号的起始为0
    	yl_ramdisk.gendisk->queue		= yl_ramdisk.queue;		// 设置队列
    	yl_ramdisk.gendisk->fops 		= &yl_ramdisk_fops;		// 块设备操作函数集合
    	sprintf(yl_ramdisk.gendisk->disk_name, YL_DEVICE_NAME);	 // 设置名字
    	set_capacity(yl_ramdisk.gendisk, YL_RAMDISK_SIZE / 512);		// 设置ramdisk的大小
    
    	/* 3、硬件相关的操作 */
    	yl_ramdisk.ramdisk_buffer = kzalloc(YL_RAMDISK_SIZE, GFP_KERNEL);
    	if (!yl_ramdisk.ramdisk_buffer) {
    		unregister_blkdev(yl_ramdisk.major, YL_DEVICE_NAME);
    		blk_cleanup_queue(yl_ramdisk.queue);
    		put_disk(yl_ramdisk.gendisk);
    		printk("kzalloc error!\n");
    		return -ENOMEM;
    	}
    
    	/* 4、注册这个gendisk结构体变量 */
    	add_disk(yl_ramdisk.gendisk);
    
    	return 0;
    }
    
    /* 定义出口函数 */
    static void __exit yl_ramdisk_exit(void)
    {
    	/* 将入口函数分配的资源依次释放掉 */
    	del_gendisk(yl_ramdisk.gendisk);
    	put_disk(yl_ramdisk.gendisk);
    	blk_cleanup_queue(yl_ramdisk.queue);
    	unregister_blkdev(yl_ramdisk.major, YL_DEVICE_NAME);
    
    	kfree(yl_ramdisk.ramdisk_buffer);
    }
    
    module_init(yl_ramdisk_init);
    module_exit(yl_ramdisk_exit);
    
    MODULE_LICENSE("GPL");