实验七补充sbull虚拟的磁盘驱动的编写.docx
《实验七补充sbull虚拟的磁盘驱动的编写.docx》由会员分享，可在线阅读，更多相关《实验七补充sbull虚拟的磁盘驱动的编写.docx（19页珍藏版）》请在冰豆网上搜索。
实验七补充sbull虚拟的磁盘驱动的编写
sbull虚拟的磁盘驱动的编写
分类：
Embedded[ARM/DSP...]驱动2011-11-2817:
24191人阅读评论（0）收藏举报
原理指导：
我们通过vmalloc在内存中开辟一部分空间，作为一个虚拟的磁盘，然后我们以块设备的方式来访问这片内存，例如这个sbull模型。
sbull（Simple Block Utility for Loading Localities），该驱动程序实现了一个使用系统内存的块设备，从本质上讲，属于一种 RAM 磁盘驱动程序。
字符设备的IO操作则是直接不绕弯的，块设备的IO操作会配对和整合。
驱动的任务是处理请求，对于这些请求的排队和整合的工作有IO调度算法处理。
所以块设备的核心工作就是：
请求处理函数或者是制造请求。
Block_devices_operations结构体中没有读写一类的成员函数，而只是包含打开、释放和IO控制等函数。
块设备的流程：
（1）先把模块模型搭建好
MODULE_LICENSE（"Dual BSD/GPL"）;
static struct block_device_operations sbull_ops = {
.owner = THIS_MODULE,
.open = sbull_open,
.release = sbull_release,
.media_changed = sbull_media_changed,
.revalidate_disk = sbull_revalidate,
.ioctl = sbull_ioctl,
.getgeo= sbull_getgeo,
};
module_init（sbull_init）;
module_exit（sbull_exit）;
（2）定义一个我们用内存虚拟出来的块设备sbull_dev
struct sbull_dev {
int size; /* Device size in sectors */
u8 *data; /* The data array */
short users; /* How many users */
short media_change; /* Flag a media change?
*/
spinlock_t lock; /* For mutual exclusion */
struct request_queue *queue; /* The device request queue */
struct gendisk *gd; /* The gendisk structure */
struct timer_list timer; /* For simulated media changes */
};
这个设备结构体是我们工作的核心，也许你不知道需要哪些成员，不要紧，还是那句话，编写驱动的时候，需要设备表现出那些性质和功能，相应的添加上就OK了。
（3）设备的初始化
sbull_init（ ）{
一、sbull_major = register_blkdev（sbull_major, "sbull"）;
二、Static struct sbull_dev *Devices = kmalloc（ndevices*sizeof （struct sbull_dev）, GFP_KERNEL）;//在这里可以对Kmalloc的结果判断下，然后进一步处理...
三、setup_device（）跳到我们设备注册函数中去
}//初始化函数结束
（4）开始注册我们的这个设备
setup_device（ ）{ //安装（注册）一个设备前，一定要保证它被初始化了
这些成员都得出初始化好：
一、 int size; /* Device size in sectors */
u8 *data; /* The data array */
short users; /* How many users */
spinlock_t lock; /* For mutual exclusion */
struct request_queue *queue; /* The device request queue */
struct gendisk *gd; /* The gendisk structure */
二、add_disk（dev->gd）;//这个重要的注册函数}//函数结束
（5）扇区大小、data数组、user、锁lock的初始化：
一、dev->size = nsectors*hardsect_size;
dev->data = vmalloc（dev->size）;
spin_lock_init（&dev->lock）;
二、//dev->queue = blk_alloc_queue（GFP_KERNEL）; //RM_NOQUEUE
//dev->queue = blk_init_queue（sbull_full_request, &dev->lock）; //RM_FULL
dev->queue = blk_init_queue（sbull_request, &dev->lock）; //RM_SIMPLE
（6）告知内核硬件扇区尺寸、和timer模拟的初始化
blk_queue_logical_block_size（dev->queue, hardsect_size）;
init_timer（&dev->timer）;
dev->timer.data = （unsigned long） dev;
dev->timer.function = sbull_invalidate;gendisk初始化
一、初始化gendisk:
dev->gd = alloc_disk（SBULL_MINORS）;
二、 初始化gendisk的成员
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;
（7）设置gendisk容量为xxx_size个扇区大小
set_capacity（dev->gd , nsectors*（hardsect_size / KERNEL_SECTOR_SIZE））;
（8）剩下的就是为devices_operation结构体里声明的那些接口进行实现：
.open = sbull_open,
.release = sbull_release,
.media_changed = sbull_media_changed,
.revalidate_disk = sbull_revalidate,
.ioctl= sbull_ioctl,
.getgeo= sbull_getgeo,
一、sbull_open（struct block_device *bdev,fmode_t mode ）
二、sbull_release（struct gendisk *bd_disk, fmode_t mode）
三、sbull_media_changed（struct gendisk *gd）
四、sbull_revalidate（struct gendisk *gd）
五、sbull_invalidate（unsigned long ldev）
六、sbull_ioctl （struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg）
七、sbull_getgeo（struct block_device *bdev, struct hd_geometry *geo）
以下是代码：
[cpp]viewplaincopyprint?
1./*
2. * Sample disk driver for 2.6.35.
3. */
4.
5.//#include
6.#include
7.#include
8.#include
9.
10.#include
11.#include /* printk（） */
12.#include /* kmalloc（） */
13.#include /* everything... */
14.#include /* error codes */
15.#include
16.#include /* size_t */
17.#include /* O_ACCMODE */
18.#include /* HDIO_GETGEO */
19.#include
20.#include
21.#include
22.#include
23.#include /* invalidate_bdev */
24.#include
25.
26.MODULE_LICENSE（"Dual BSD/GPL"）;
27.
28.static int sbull_major = 0;
29.module_param（sbull_major, int, 0）;
30.static int hardsect_size = 512;
31.module_param（hardsect_size, int, 0）;
32.static int nsectors = 25600; /* How big the drive is */
33.module_param（nsectors, int, 0）;
34.static int ndevices = 1;
35.module_param（ndevices, int, 0）;
36.
37./*
38. * The different "request modes" we can use.
39. */
40.enum {
41. RM_SIMPLE = 0, /* The extra-simple request function */
42. RM_FULL = 1, /* The full-blown version */
43. RM_NOQUEUE = 2, /* Use make_request */
44.};
45.//static int request_mode = RM_FULL;
46.//static int request_mode = RM_SIMPLE;
47.static int request_mode = RM_NOQUEUE;
48.module_param（request_mode, int, 0）;
49.
50./*
51. * Minor number and partition management.
52. */
53.#define SBULL_MINORS 16
54.#define MINOR_SHIFT 4
55.#define DEVNUM（kdevnum） （MINOR（kdev_t_to_nr（kdevnum）） >> MINOR_SHIFT
56.
57./*
58. * We can tweak our hardware sector size, but the kernel talks to us
59. * in terms of small sectors, always.
60. */
61.#define KERNEL_SECTOR_SIZE 512
62.
63./*
64. * After this much idle time, the driver will simulate a media change.
65. */
66.#define INVALIDATE_DELAY 60*HZ
67.
68./*
69. * The internal representation of our device.
70. */
71.struct sbull_dev {
72. int size; /* Device size in sectors */
73. u8 *data; /* The data array */
74. short users; /* How many users */
75. short media_change; /* Flag a media change?
*/
76. spinlock_t lock; /* For mutual exclusion */
77. struct request_queue *queue; /* The device request queue */
78. struct gendisk *gd; /* The gendisk structure */
79. struct timer_list timer; /* For simulated media changes */
80.};
81.
82.static struct sbull_dev *Devices = NULL;
83.
84./*
85. * Handle an I/O request.
86. */
87.static void sbull_transfer（struct sbull_dev *dev, unsigned long sector,
88. unsigned long nsect, char *buffer, int write）
89.{
90. unsigned long offset = sector*KERNEL_SECTOR_SIZE;
91. unsigned long nbytes = nsect*KERNEL_SECTOR_SIZE;
92. //printk（"<0>""in %s offset=%d nbytes=%d write=%d\n",__FUNCTION__,offset,nbytes,write）;
93. //buffer[10]='\0';
94. //printk（buffer）;
95. //printk（"\n"）;
96. if （（offset + nbytes） > dev->size） {
97. printk （KERN_NOTICE "Beyond-end write （%ld %ld）\n", offset, nbytes）;
98. return;
99. }
100. if （write）
101. memcpy（dev->data + offset, buffer, nbytes）;
102. else
103. memcpy（buffer, dev->data + offset, nbytes）;
104.}
105.
106./*The simple form of the request function.*/
107.
108.static void sbull_request（struct request_queue *q）
109.{
110. struct request *req;
111.
112. req = blk_fetch_request（q）;
113. while （req !
= NULL） {
114. struct sbull_dev *dev = req->rq_disk->private_data;
115. if （!
blk_fs_request（req）） {
116. printk （KERN_NOTICE "Skip non-fs request\n"）;
117. __blk_end_request_all（req, -EIO）;
118. continue;
119. }
120. // printk （KERN_NOTICE "Req dev %d dir %ld sec %ld, nr %d f %lx\n",
121. // dev - Devices, rq_data_dir（req）,
122. // req->sector, req->current_nr_sectors,
123. // req->flags）;
124. // printk（"sectors=%d\n",req->current_nr_sectors）;
125. sbull_transfer（dev, blk_rq_pos（req）, blk_rq_cur_sectors（req）,
126. req->buffer, rq_data_dir（req））;
127. if （ !
__blk_end_request_cur（req, 0） ） {
128. req = NULL;
129. }
130. }
131.}
132.
133.
134./*
135. * Transfer a single BIO.
136. */
137.static int sbull_xfer_bio（struct sbull_dev *dev, struct bio *bio）
138.{
139. int i;
140. struct bio_vec *bvec;
141. sector_t sector = bio->bi_sector;
142.
143. /* Do each segment independently. */
144. bio_for_each_segment（bvec, bio, i） {
145. char *buffer = __bio_kmap_atomic（bio, i, KM_USER0）;
146. sbull_transfer（dev, sector, bio_cur_bytes（bio）>>9 ,
147. buffer, bio_data_dir（bio） == WRITE）;
148. sector += bio_cur_bytes（bio）>>9;
149. __bio_kunmap_atomic（bio, KM_USER0）;
150. }
151. return 0; /* Always "succeed" */
152.}
153.
154./*
155. * Transfer a full request.
156. */
157.static int sbull_xfer_request（struct sbull_dev *dev, struct request *req）
158.{
159. struct bio *bio;
160. int nsect = 0;
161.
162. __rq_for_each_bio（bio, req） {
163. sbull_xfer_bio（dev, bio）;
164. nsect += bio->bi_size/KERNEL_SECTOR_SIZE;
165. }
166. return nse
升级会员 