简单的块设备驱动例程

单队列架构的：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

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
1
2
3
4
5
6
7
8

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

多队列架构的：

#include 
#include 
#include 

#include 
#include 	/* printk() */
#include 		/* kmalloc() */
#include 		/* everything... */
#include 	/* error codes */
#include 	/* size_t */
#include 	/* O_ACCMODE */
#include 	/* HDIO_GETGEO */
#include 
#include 
#include 
#include 
#include 	/* invalidate_bdev */
#include 

#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");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

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