ok6410学习笔记（19.块设备驱动程序设计）
本节还存在问题：
问题一：为什么开辟的内存是0扇区，下文中有具体说明。
问题二：块设备能不能像字符设备一样进行，read，write，下文中有详细说明。
问题三：对于整体的块设备的体系结构开不是很透彻，应该再看看<linux内核注释> 和 <linux内核设计与实现>两本书的块设备部分
本节知识点：
预备知识：
1.块设备与字符设备的区别：a.块设备和字符设备的读取单元不同，块设备是以一块为基本单元进行读写的，一般是512字节，字符设备是以字节为单位进行读写的。
b.块设备可以随机访问(随机对各个块进行访问) 字符设备必须按照顺序访问(按照地址进行访问)
2.块设备在linux中的体系架构：
当访问块设备文件的时候，linux先调用VFS虚拟文件系统，先在硬盘缓存中去寻找有没有要访问的数据，如果有就直接返回，没有就继续调用下面的
文件系统或
设备文件。然后在Mapping layer层来寻找文件的inode，通过inode让操作系统找到数据在磁盘上的逻辑地址，即sector。Generic Block Layer层是通用块设备层，这个层把块设备分成若干个扇区，并处理上层的读写请求，变成若干个bio结构。IO scheduler layer层针对，各种机械存储设备(硬盘)，进行IO请求的调度，如电梯调度算法。Block Device Driver 块设备驱动，负责对硬件进行控制。
总结一下：VFS：负责统一文件接口
Mapping Layer：负责通过inode找到sector
Generic Block Layer：负责分扇区和处理上层读写请求
IO scheduler layer：负责IO请求进行调度
重点函数：
1、描述块设备的结构
struct gendisk
{
int major; // 主设备号
int first_minor; //第一个设备的次设备号
int minor; //有多少设备 一般是在申请块设备函数alloc_disk函数中填写的
char disk_name[DISK_NAME_LEN];//驱动名 /dev路径下的名
struct block_device_operations *fops;// 块设备处理函数
struct request_queue *queue;//IO请求队列
}
2、set_capacity(struct gendisk *gd, MY_BLKDEV_BYTES>>9) 这个函数的第一个参数是 块设备结构 第二个参数是开辟的内存除上512 应该是有多少个块 这个函数的功能应该是告诉内核这个块设备有多少个块
3、alloc_disk(minor) 对于块设备的申请要使用这个函数，不能自己直接给上面的那个结构体赋值，这个函数的参数是 此类块设备有多少个设备
4、add_disk(struct gendisk *gd) 把块设备添加到linux内核中去 如果在内核配置的时候安装了udev 这个函数可以在/dev目录下直接产生块设备文件
5、del_gendisk(struct gendisk *gd) 把块设备从内核中卸载掉
6、IO请求的结构
struct request
{
struct list_head queuelist;//链表结构
sector_t sector;//要操作的首扇区
unsigned long nr_sectors;//要操作的扇区数目
struct bio* bio;//请求的bio结构体的链表
struct bio* biotail;//请求的bio结构体的链表尾
}
request IO请求和bio结构的关系就是 request是操作系统根据IO调度机制把一个一个的bio(一次块设备请求)组成成一个链表 就变成了一次IO请求了 好多个request IO请求就变成了request_queue IO请求队列
7、struct request_queue *blk_init_queue(request_fn_proc *rfn,spinlock_t *lock) 该函数初始化IO请求队列(
是用在想要使用linuxIO调度器的情况下的，如访问硬盘等) 第一个参数是处理IO请求队列的函数，第二个参数是自旋锁 返回值是IO请求队列
8、blk_cleanup_queue(request_queue *p) 清楚IO请求队列
9、struct request *elv_next_request(request_queue *q) 通过当前请求队列 去寻找下一个IO请求 (我觉得应该是在请求队列中 用一个链表保存了所有的IO请求和当前IO请求)
10、void blkdev_dequeue_request(request_queue *q) 从请求队列中 删除当前IO请求
11、end_request(req,1) 次函数非常重要 我出了问题 就是在这个函数上面 此函数功能是结束当前IO请求 如果成功第二个参数写1，如果不成功写0。1和0影响很大，千万别写错了，第一个参数是当前IO请求。
上面的函数是使用在 使用linuxIO调度器的情况的，如访问硬盘设备
下面的函数是使用在 无linuxIO调度器的情况 如U盘 内存
12、一次块设备IO请求结构
struct bio
{
sector_t bi_sector;//要访问的第一个扇区
unsigned int bi_size;//以字节为单位所需传输的数据大小
struct bio_vec *bi_io_vec;//实际的vec列表
}
struct bio_vec
{
struct page *bv_page;//页指针 用来寻找IO请求缓冲区的页指针
unsigned int bv_len;//传输的数据长度，与bi_size有区别 后面详细说
unsigned int bv_offset;//偏移量 和页指针配合一起寻找IO请求缓冲区
}
13、struct request_queue *blk_alloc_queue(GFP_KERNEL)申请一个IO请求队列
14、blk_queue_make_request(request_queue *q, make_request_fn *mfn) 绑定请求函数和制造请求函数(详细结构在后面驱动结构里面详细说) 第一个参数是请求队列 第二个参数是处理请求函数
15、bio_endio(bio,0,-EIO) 结束当前bio(失败的情况) bio_endio(bio,bio->bi_size,0)结束当前bio(成功的情况)
bio_endio()原型如下：
void bio_endio(struct bio* bio, unsigned int byetes, int error);
bytes是已经传送的字节数(注意:bytes≤bio->bi_size),这个函数同时更新了bio的当前缓冲区指针.当设备进一步处理bio后,驱动应再次调用bio_endio(),如不能完成请求,将错误码赋给error参数,并在函数中得以处理.此函数无论处理IO成功与否都返回0,如果返回非零值,则bio将再次被提交
bytes是已经传送的字节数(注意:bytes≤bio->bi_size),这个函数同时更新了bio的当前缓冲区指针.当设备进一步处理bio后,驱动应再次调用bio_endio(),如不能完成请求,将错误码赋给error参数,并在函数中得以处理.此函数无论处理IO成功与否都返回0,如果返回非零值,则bio将再次被提交
驱动结构：
本节最重要的知识点就是了解块设备的驱动结构。本节的块设备分两类，一类是有IO调度器的，一类是没有IO调度器的。
一、有linux IO调度器的情况
1.使用blk_init_queue函数，初始化一个IO请求队列，并把请求队列处理函数绑定给这个请求队列。
2.使用alloc_disk函数，申请一个块设备结构
3.填充gendisk块设备结构(主设备号 次设备号 设备名 IO请求队列 块设备函数操作集，块设备的函数操作集没有read和write的 只有open，release，ioctl等)
4.使用set_capacity函数，把块设备有多少块，赋值给gendisk
6.使用add_disk函数，将这个块设备注册到linux内核，此时产生了设备文件。
7.填写IO请求处理函数：
a.因为是处理一个请求队列，所以应该使用elv_next_request遍历所有的IO请求，知道没有请求了，才退出函数
b.当通过elv_next_request得到一个请求request的时候，然后通过linux内核回馈的sector头扇区和current_nr_sectors操作扇区个数判断操作的扇区是否，超过了开辟的内存大小。
这里默认内存开辟的首地址是0扇区，原因我也不知道。可能是跟后面的格式化有关系，这是我还没弄懂的知识点一。
c.通过rq_data_dir()函数，判断IO请求的数据处理方向，即是读还是写。
d.根据读写，决定是从IO请求的缓冲区(req->buffer)中度数据，还是往缓冲区中写数据。如果是对硬盘进行操作，则是通过寄存器的控制，把硬盘中的数据读出来写入buffer和把buffer中的数据写入硬盘。本节的代码是用内存模拟硬件设备，所以是在内存与缓冲区之间进行copy。
总结：首先声明，对于块设备能否进行应用程序的read和write 我不知道，这是我没弄懂的知识二。本节的测试是ramdisk，把块设备中开辟的内存，格式化成ext3文件系统，并挂载到mnt中的某个目录，制作成硬盘，进行文件的拷贝。
1.写入文件的过程，用户态-------->内核态------------>硬件设备，
(1.)
内核根据你要拷贝的文件大小先去寻找哪些硬件空间没有被使用，文件被内核分成好多个块即分成好多的bio结构，这些bio都有自己的sector，这些sector跟刚刚的硬件空间有着某种转换关系(Mapping Layer层)，
(2.)
然后内核再把你要拷贝的文件一块一块的写入每一个IO请求的缓冲区中(Generic Block Layer层)，
(3.)对于这个使用了IO调度器的驱动，blk_init_queue调用了blk_queue_make_request(q,_make_request),这里面首先调用了_make_request函数，这个函数是把所以产生的bio结构，通过IO调度器(调度算法)制作成一个一个的IO请求，即request结构，再把request结构制作成request_queueIO请求队列，然后调用了q->make_request_fn=mfn，mfn这个函数就是blk_init_queue中我们自己写的那个函数，用来处理IO请求队列的。(IO schedule层)，在这个层次中，产生了我们常常见到的request中的sector和current_nr_sectors，他们的来源是bio的sector，(4.)在驱动中，你再把这个缓存区中的数据写入硬件设备中去(Block Driver层)，但是我觉得硬件设备不应该仅仅是通过纯寄存器去控制，还应该是同过内核分配的sector和current_nr_sectors去找到硬件空间，因为只有这样才能确定那里是被使用的，那里是空闲的。这里面sector和current_nr_sectors与内核直接的关系应该是在，linux内核移植的时候完成的。这个过成就是上面那个体系结构图的具体解释。
补充：bio、request和request_queue三者关系：
首先是IO请求队列，这个里面有好多个IO请求request，当确定了文件大小，找到空闲硬件空间的时候，内核就产生了好多IO请求，每个IO请求都有一个sector，一个current_nr_sectors。一个IO请求一次可以操作好多个块，每一个块的每次IO请求就是一个bio，IO调度器就是优化一个request中的多个bio的。而一个request中的多个bio又有自己的sector，这就保证了不管IO调度器怎么优化，对于一次request的处理，都不会把文件拷贝到错的地址。(这里面就体现出了块设备的访问随机性)，在这里我们考虑的最小单位是IO请求，bio的排序是调度器处理的，bio的顺序不会影响IO请求的处理的原因上面已经阐述过了。
2.读出文件的过程，硬件设备------------>内核态---------->用户态，当读一个文件的时候，确定了文件的inode属性，找到了文件的物理地址属性，操作系统可以根据这个物理地址找到文件对应的一组sector和current_nr_sectors并形成一个IO请求队列，因为产生和查找都是根据物理地址来的所以这组sector和current_nr_sectors应该是当时write的时候的那组是完全对应的。所以就可以毫无错误的找到你要的问题，在写入各个IO请求的缓冲区中，用户态就得到了你想要的文件了。这里也体现了块设备的访问随机性。
这里面有一个问题很纠结：比如我用read和write在应用程序中，往块设备中写入和读出数据，因为是顺序读取的，在读取数据的时候没有inode，所以sector和current_nr_sectors是随机的，不一定是写入时候的那个sector和current_nr_sectors，所以我在IO请求的缓存区中没有读出对应的数据，但是貌似我的应用程序还真的接到了对应的数据。原因我也不是很清楚。
注意：在整个过程中，程序中对错误的处理，都是有一个前提的，对于本节代码来说前提就是内存开辟的头地址，就是0扇区(可能是因为格式化成ext3文件系统的缘故，把这个内存空间当成了一个硬盘了，自然内存首地址就成了0扇区)。对于真实的硬盘驱动程序，应该是在内核移植的时候都移植好的，不管是硬盘还是nandflash，他们的起始地址应该就是0扇区，也就是说在安全性检测的时候，只需用 (头扇区+扇区数)*512再与总共硬盘大小进行比较就好了。
二、无linux IO调度器的情况
1.使用blk_alloc_queue(GFP_KERNEL) 申请一个IO请求队列
2.blk_queue_make_request(request_queue *q, make_request_fn *mfn) 这个函数是把申请的IO请求队列和你自己定义的处理函数建立联系
3.使用alloc_disk函数，申请一个块设备结构
4.填充gendisk块设备结构(主设备号 次设备号 设备名 IO请求队列 块设备函数操作集，块设备的函数操作集没有read和write的 只有open，release，ioctl等)
5.使用set_capacity函数，把块设备有多少块，赋值给gendisk
6.使用add_disk函数，将这个块设备注册到linux内核，此时产生了设备文件。
7.填写IO请求队列处理函数：
a.使用bio的sector和size来进行安全检测，判断是否超出我们开辟的内存大小
b.使用bio_for_each_segment函数遍历bio，因为每一个bio应该是由很多个bio_vec组成的，每一个bio_vec中都有一个缓冲区。这里可以看出bi_size和bio_vec->len的区别了，bi_size应该是整个bio进行操作的总字节数，bio_vec->len应该是每一次bio_vec缓冲区数据传输的字节数。
c.使用bio_rw函数来判断bio的数据传输方向
d.根据页指针和偏移量找到bio_vec的缓冲区，再根据读写方向进行数据传输。此处也有像上一方法一样的对硬件进行的操作，此时的硬件应该也是与bio的sector有关的
总结：对于这个没有使用IO调度器的情况，步骤和上面的写入过程是一样的，只有第三步是不一样，当到达第三步的时候直接使用了blk_queue_make_request(q,make_request_fn *mfn)函数，中的mfn函数即我们自己建立的处理好多bio结构的函数，没有调用系统中__make_queue函数了，因为这个函数中有一步IO调度器，优化bio顺序，我们直接使用这个函数来处理各个bio结构，很自然这个方法也没用IO请求request。与上面的方法不同的是有IO调度器的最小单元是request，没有IO调度器的最小单元是bio。
下面的图展示出了，两者中的第三步的函数调用关系：
本节代码：
1.如果对本节代码进行检测：
a.insmod block.ko 块设备
b.ls /dev/my_blkdev 查看有没有产生设备文件
c.mkfs.ext3 /dev/my_blkdev 把块设备格式化成ext3文件系统
d.mkdir -p /mnt/blk 在mnt目录下创建一个文件夹 用来映射这个块设备
e.mount /dev/my_blkdev /mnt/blk 把格式化好的块设备映射到新建的目录下
f.cp考入一些文件 再考出这些文件 看见你的块设备能不能读写
g.umount /dev/my_blkdev 卸载 看看 blk目录下还有没有文件了
2.不使用IO调度器的 block.c：
#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/timer.h>
#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/blkdev.h>
#include <linux/buffer_head.h> /* invalidate_bdev */
#include <linux/bio.h>
#include <linux/major.h>
static struct gendisk *my_blkdev_disk;
static struct request_queue *my_blkdev_queue;
#define MY_BLKDEV_BYTES (16*1024*1024) //块设备大小为16M
unsigned char DATA[MY_BLKDEV_BYTES]; //这是当作块设备的内存
static int do_queue(struct request_queue *q,struct bio *bio) //IO请求队列处理函数
{
struct bio_vec *bvec;
int i;
void *dsk_mem;
/*bio->bi_sector头扇区 bio->bi_size 传输字节大小*/
if ((bio->bi_sector << 9) + bio->bi_size > MY_BLKDEV_BYTES)
{
printk(KERN_EMERG": bad request: block=%llu, count=%u\n",(unsigned long long)bio->bi_sector, bio->bi_size);
bio_endio(bio,0,-EIO);
return 0;
}
dsk_mem = DATA + (bio->bi_sector << 9); //把bio内存中的头地址保存下来
bio_for_each_segment(bvec, bio, i) //遍历bio 应该是一个bio 会分成好多个bvec步骤进行 数据传输
{
void *iovec_mem;
switch(bio_rw(bio))
{
case READ:
case READA:
iovec_mem=kmap(bvec->bv_page) + bvec->bv_offset;//用bio的页地址和偏移量 计算出缓冲区的虚拟地址
memcpy(iovec_mem, dsk_mem, bvec->bv_len);//把头扇区开始的内容copy到 bio的缓冲区中
printk(KERN_EMERG "READing is %s\n",(char *)iovec_mem);
kunmap(bvec->bv_page);//释放映射
break;
case WRITE:
iovec_mem=kmap(bvec->bv_page) + bvec->bv_offset;
memcpy(dsk_mem, iovec_mem, bvec->bv_len); //把来自用户空间的内容 从bio缓冲区copy到头扇区
printk(KERN_EMERG "WRITing is %s\n",(char *)iovec_mem);
kunmap(bvec->bv_page);
break;
default:
printk(KERN_EMERG": unknown value of bio_rw: %lu\n",bio_rw(bio));
bio_endio(bio,0,-EIO);//结束当前bio请求
return 0;
break;
}
dsk_mem += bvec->bv_len; //在每次完成bio中 的一个bvec的时候 都要把模仿设备的内存指针进行移动
}
bio_endio(bio,bio->bi_size,0);
return 0;
}
struct block_device_operations my_blkdev_fop = {
.owner = THIS_MODULE,
};
static int __init blkdev_init(void)
{
printk(KERN_EMERG "module init is finished!!!\n");
int ret;
/*初始化IO请求队列 并绑定IO队列处理函数*/
my_blkdev_queue = blk_alloc_queue(GFP_KERNEL); //申请一个IO请求队列
if (!my_blkdev_queue)
{
ret = -ENOMEM;
goto err_alloc_queue;
}
blk_queue_make_request(my_blkdev_queue, do_queue); //把申请的IO请求队列和我们自己的请求队列处理函数绑定起来 跳过以前操作系统带IO调度的那个函数
/*跟系统申请 描述块设备的结构体 赋值给定义的全局变量指针*/
my_blkdev_disk=alloc_disk(1); //动态分配gendisk结构体 参数为该设备使用的次设备号数量
if (!my_blkdev_disk)
{
ret = -ENOMEM;
goto err_alloc_disk;
}
/*填充块设备结构体*/
my_blkdev_disk->major=255;//主设备号为255
my_blkdev_disk->first_minor=0;//只有一个设备在alloc_disk中体现的，这个是第一个设备的次设备号
strcpy(my_blkdev_disk->disk_name,"my_blkdev");//填写设备名
my_blkdev_disk->fops=&my_blkdev_fop; //填写设备操作函数集合
my_blkdev_disk->queue=my_blkdev_queue; //填写该块设备的IO请求队列
set_capacity(my_blkdev_disk, MY_BLKDEV_BYTES>>9); //一般一个扇区的大小是512个字节 这个函数应该是得到这个块设备上有几个扇区
/*注册块设备 进入内核*/
add_disk(my_blkdev_disk);//注册块设备驱动
return 0;
err_alloc_disk:
blk_cleanup_queue(my_blkdev_queue);//如果IO请求队列申请失败 则应该清除队列
err_alloc_queue:
return ret;
}
static void __exit blkdev_exit(void)
{
blk_cleanup_queue(my_blkdev_queue);
del_gendisk(my_blkdev_disk);
}
module_init(blkdev_init);
module_exit(blkdev_exit);
3.使用IO调度器的block.c：
#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/timer.h>
#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/blkdev.h>
#include <linux/buffer_head.h> /* invalidate_bdev */
#include <linux/bio.h>
#include <linux/major.h>
static struct gendisk *my_blkdev_disk;
static struct request_queue *my_blkdev_queue;
#define MY_BLKDEV_BYTES (16*1024*1024) //块设备大小为16M
unsigned char DATA[MY_BLKDEV_BYTES]; //这是当作块设备的内存
static void do_queue(struct request_queue *q) //IO请求队列处理函数
{
struct request *req;//定义一个请求
/*要处理完这个请求队列上的所有请求*/
while((req=elv_next_request(q))!=NULL) //当第一次调用elv_next_request函数的时候 q中的保存的应该是链表头 然后每次调用elv_next_request函数都指向下一个 也就是说第一次调用elv_next_request函数得到的request应该是第一次io请求
{
/*我想看看每次请求中的sector都是不是0*/
printk(KERN_EMERG "sector is %llu , nr_sectors is %u \n",(unsigned long long)req->sector,req->current_nr_sectors);
if(((req->sector+req->current_nr_sectors)<<9)>MY_BLKDEV_BYTES) //我觉得这里应该不加上req->sector 问问老师
{
printk(KERN_EMERG "error:sector is %llu , nr_sectors is %u \n",(unsigned long long)req->sector,req->current_nr_sectors);
end_request(req,0);//结束本次请求 第二个参数是返回请求是否执行成功 成功为1 失败为0
continue; //如果所操作的扇区大小 大于 我们最大分配内存的大小(此处做ramdisk 用内存当扇区) 则结束这次请求 进行下面的请求
}
/*下面是针对请求的方向进行处理*/
switch(rq_data_dir(req))//该函数是判断请求的方向的 即数据流向
{
case READ: //这里还不能使用copy_from_user或者copy_to_user因为req->buffer是内核空间的内存 是需要操作系统传递到用户空间的不是这里传递的 但是最好还是检查一下这个内存的有效性
/*这里的读 应该是用户空间读 内核把req->buffer中的数据传递给用户空间*/
memcpy(req->buffer,DATA+(req->sector<<9),req->current_nr_sectors<<9);
// memcpy(req->buffer,DATA+(0<<9),3<<9);
// memcpy(req->buffer,"hello0",5);
printk(KERN_EMERG"READing!!! %s\n",req->buffer);
end_request(req,1);//结束本次请求 第二个参数是返回请求是否执行成功 成功为1 失败为0
break;
case WRITE:
/*这里的写 应该是用户空间写 用户空间通过内核把数据写入req->buffer中 应把这个buffer中的值 写入硬件中*/
memcpy(DATA+(req->sector<<9),req->buffer,req->current_nr_sectors<<9);
// memcpy(DATA+(0<<9),req->buffer,3<<9);
printk(KERN_EMERG"WRITEing!!! %s\n",req->buffer);
end_request(req,1);//结束本次请求 第二个参数是返回请求是否执行成功 成功为1 失败为0
break;
default:
break;
}
}
}
struct block_device_operations my_blkdev_fop = {
.owner = THIS_MODULE,
};
static int __init blkdev_init(void)
{
printk(KERN_EMERG "module init is finished!!!\n");
int ret;
/*初始化IO请求队列*/
my_blkdev_queue=blk_init_queue(do_queue,NULL);//初始化块设备的IO请求队列 第一个参数是IO请求队列的处理函数名 第二个参数是一个自旋锁
if (!my_blkdev_queue)
{
ret = -ENOMEM;
goto err_alloc_queue;
}
/*跟系统申请 描述块设备的结构体 赋值给定义的全局变量指针*/
my_blkdev_disk=alloc_disk(1); //动态分配gendisk结构体 参数为该设备使用的次设备号数量
if (!my_blkdev_disk)
{
ret = -ENOMEM;
goto err_alloc_disk;
}
/*填充块设备结构体*/
my_blkdev_disk->major=255;//主设备号为255
my_blkdev_disk->first_minor=0;//只有一个设备在alloc_disk中体现的，这个是第一个设备的次设备号
strcpy(my_blkdev_disk->disk_name,"my_blkdev");//填写设备名
my_blkdev_disk->fops=&my_blkdev_fop; //填写设备操作函数集合
my_blkdev_disk->queue=my_blkdev_queue; //填写该块设备的IO请求队列
set_capacity(my_blkdev_disk, MY_BLKDEV_BYTES>>9); //一般一个扇区的大小是512个字节 这个函数应该是得到这个块设备上有几个扇区
/*注册块设备 进入内核*/
add_disk(my_blkdev_disk);//注册块设备驱动
return 0;
err_alloc_disk:
blk_cleanup_queue(my_blkdev_queue);//如果IO请求队列申请失败 则应该清除队列
err_alloc_queue:
return ret;
}
static void __exit blkdev_exit(void)
{
blk_cleanup_queue(my_blkdev_queue);
del_gendisk(my_blkdev_disk);
}
module_init(blkdev_init);
module_exit(blkdev_exit);